Merge pull request #79317 from NixOS/haskell-updates

Update Haskell package set to LTS 14.23 (plus other fixes)

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "0s8sv6h90l2a9xdabj0nirhpr6d2k8s5cddjdkm50x395i014w31";
+      sha256 = "1shb1jgm78bx88rbsr1nmimjzzfqw96qdr38mcrr1c2qz5ky820v";
     };
   }).override {
     dbus = if pkgs.stdenv.isLinux then self.dbus else null;
···
   constraints-deriving = dontCheck super.constraints-deriving;
 
   # Use a matching version of ghc-lib-parser.
-  ghc-lib-parser-ex = super.ghc-lib-parser-ex.override { ghc-lib-parser = self.ghc-lib-parser_8_8_2; };
+  ghc-lib-parser-ex = super.ghc-lib-parser-ex.override { ghc-lib-parser = self.ghc-lib-parser_8_8_2_20200205; };
 
   # https://github.com/sol/hpack/issues/366
   hpack = self.hpack_0_33_0;
···
   # There are more complicated ways of doing this but I was able to make it fairly simple -- kiwi
   matterhorn = doJailbreak (super.matterhorn.override {
     brick-skylighting = self.brick-skylighting.override {
-      brick = self.brick_0_50_1;
+      brick = self.brick_0_51;
     };
   });
 
···
 
   # Needs ghc-lib-parser 8.8.1 (does not build with 8.8.0)
   ormolu = doJailbreak (super.ormolu.override {
-    ghc-lib-parser = self.ghc-lib-parser_8_8_2;
+    ghc-lib-parser = self.ghc-lib-parser_8_8_2_20200205;
   });
 
   # krank-0.1.0 does not accept PyF-0.9.0.0.
···
 
   # prettyprinter-1.6.0 fails its doctest suite.
   prettyprinter_1_6_0 = dontCheck super.prettyprinter_1_6_0;
+
+  # the test suite has an overly tight restriction on doctest
+  # See https://github.com/ekmett/perhaps/pull/5
+  perhaps = doJailbreak super.perhaps;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
     hackage-db = self.hackage-db_2_1_0;
   });
 
+  # cabal2spec needs a recent version of Cabal
+  cabal2spec = super.cabal2spec.overrideScope (self: super: { Cabal = self.Cabal_3_0_0_0; });
+
+  # Builds only with ghc-8.8.x and beyond.
+  policeman = markBroken super.policeman;
+
 }

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

···
   xmobar = doJailbreak super.xmobar;
 
   # use latest version to fix the build
-  brick = self.brick_0_50_1;
+  brick = self.brick_0_51;
   dbus = self.dbus_1_2_11;
   doctemplates = self.doctemplates_0_8;
   exact-pi = doJailbreak super.exact-pi;
···
   HaTeX = self.HaTeX_3_22_0_0;
   HsYAML = self.HsYAML_0_2_1_0;
   json-autotype = doJailbreak super.json-autotype;
-  lens = self.lens_4_18_1;
+  lens = self.lens_4_19;
   memory = self.memory_0_15_0;
   microlens = self.microlens_0_4_11_2;
   microlens-ghc = self.microlens-ghc_0_4_12;

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

···
 default-package-overrides:
   # pandoc-2.9 does not accept the 0.3 version yet
   - doclayout < 0.3
-  # LTS Haskell 14.22
+  # LTS Haskell 14.23
   - abstract-deque ==0.3
   - abstract-deque-tests ==0.3
   - abstract-par ==0.3.3
···
   - ansi-wl-pprint ==0.6.9
   - ANum ==0.2.0.2
   - aos-signature ==0.1.1
-  - apecs ==0.8.2
+  - apecs ==0.8.3
   - apecs-gloss ==0.2.3
   - apecs-physics ==0.4.2
   - api-field-json-th ==0.1.0.2
···
   - arrow-extras ==0.1.0.1
   - asciidiagram ==1.3.3.3
   - ascii-progress ==0.3.3.0
-  - asif ==6.0.4
   - asn1-encoding ==0.9.6
   - asn1-parse ==0.9.5
   - asn1-types ==0.3.3
···
   - base-compat-batteries ==0.10.5
   - basement ==0.0.11
   - base-noprelude ==4.12.0.0
-  - base-orphans ==0.8.1
+  - base-orphans ==0.8.2
   - base-prelude ==1.3
   - base-unicode-symbols ==0.2.3
   - basic-prelude ==0.7.0
···
   - bencoding ==0.4.5.2
   - between ==0.11.0.0
   - bibtex ==0.1.0.6
-  - bifunctors ==5.5.6
+  - bifunctors ==5.5.7
   - bimap ==0.4.0
   - bimap-server ==0.1.0.1
   - binary-bits ==0.5
···
   - conduit-throttle ==0.3.1.0
   - conduit-zstd ==0.0.1.1
   - config-ini ==0.2.4.0
-  - configuration-tools ==0.4.1
+  - configuration-tools ==0.4.2
   - configurator ==0.3.0.0
   - configurator-export ==0.1.0.1
   - configurator-pg ==0.1.0.3
···
   - errors ==2.3.0
   - errors-ext ==0.4.2
   - error-util ==0.0.1.2
-  - ersatz ==0.4.7
+  - ersatz ==0.4.8
   - esqueleto ==3.0.0
   - etc ==0.4.1.0
   - eventful-core ==0.2.0
···
   - fast-logger ==2.4.17
   - fast-math ==1.0.2
   - fb ==2.0.0
-  - fclabels ==2.0.3.3
+  - fclabels ==2.0.4
   - feature-flags ==0.1.0.1
   - fedora-dists ==1.0.1
   - feed ==1.2.0.1
   - FenwickTree ==0.1.2.1
   - fft ==0.1.8.6
-  - fgl ==5.7.0.1
+  - fgl ==5.7.0.2
   - fib ==0.1
   - filecache ==0.4.1
   - file-embed ==0.0.11.1
···
   - flac ==0.2.0
   - flac-picture ==0.1.2
   - flags-applicative ==0.1.0.2
-  - flat-mcmc ==1.5.0
+  - flat-mcmc ==1.5.1
   - flay ==0.4
   - flexible-defaults ==0.0.3
   - FloatingHex ==0.4
···
   - free-vl ==0.1.4
   - friendly-time ==0.4.1
   - frisby ==0.2.2
-  - from-sum ==0.2.2.0
+  - from-sum ==0.2.3.0
   - frontmatter ==0.1.0.2
   - fsnotify ==0.3.0.1
   - fsnotify-conduit ==0.1.1.1
···
   - graph-core ==0.3.0.0
   - graphite ==0.10.0.1
   - graphs ==0.7.1
-  - graphviz ==2999.20.0.3
+  - graphviz ==2999.20.0.4
   - graph-wrapper ==0.2.6.0
   - gravatar ==0.8.0
   - graylog ==0.1.0.1
···
   - hw-dsv ==0.3.5
   - hweblib ==0.6.3
   - hw-eliasfano ==0.1.1.0
-  - hw-excess ==0.2.2.2
+  - hw-excess ==0.2.2.3
   - hw-fingertree ==0.1.1.1
   - hw-fingertree-strict ==0.1.1.3
   - hw-hedgehog ==0.1.0.5
···
   - js-jquery ==3.3.1
   - json ==0.9.3
   - json-alt ==1.0.0
-  - json-feed ==1.0.7
+  - json-feed ==1.0.8
   - jsonpath ==0.1.0.2
   - json-rpc ==1.0.1
   - json-rpc-client ==0.2.5.0
···
   - justified-containers ==0.3.0.0
   - jwt ==0.10.0
   - kan-extensions ==5.2
-  - kanji ==3.4.0.2
+  - kanji ==3.4.1
   - katip ==0.8.3.0
   - kawhi ==0.3.0
   - kazura-queue ==0.1.0.4
   - kdt ==0.2.4
   - keycode ==0.2.2
-  - keys ==3.12.2
+  - keys ==3.12.3
   - kind-apply ==0.3.2.0
   - kind-generics ==0.3.0.0
   - kind-generics-th ==0.1.1.0
···
   - kraken ==0.1.0
   - l10n ==0.1.0.1
   - labels ==0.3.3
-  - lackey ==1.0.10
+  - lackey ==1.0.11
   - lambdabot-core ==5.2
   - lambdabot-irc-plugins ==5.2
   - LambdaHack ==0.9.5.0
···
   - language-haskell-extract ==0.2.4
   - language-java ==0.2.9
   - language-javascript ==0.6.0.14
-  - language-puppet ==1.4.6.1
+  - language-puppet ==1.4.6.2
   - lapack ==0.3.1
   - lapack-carray ==0.0.3
   - lapack-comfort-array ==0.0.0.1
···
   - libffi ==0.1
   - libgit ==0.3.1
   - libgraph ==1.14
-  - libmpd ==0.9.0.10
+  - libmpd ==0.9.1.0
   - liboath-hs ==0.0.1.1
   - libraft ==0.5.0.0
-  - libyaml ==0.1.1.1
+  - libyaml ==0.1.2
   - LibZip ==1.0.1
   - lifted-async ==0.10.0.4
   - lifted-base ==0.2.3.12
···
   - log-domain ==0.12
   - logfloat ==0.13.3.3
   - logger-thread ==0.1.0.2
-  - logging-effect ==1.3.8
+  - logging-effect ==1.3.9
   - logging-facade ==0.3.0
   - logging-facade-syslog ==1
   - logict ==0.7.0.2
···
   - mono-traversable-keys ==0.1.0
   - more-containers ==0.2.2.0
   - mountpoints ==1.0.2
-  - mpi-hs ==0.5.3.0
   - msgpack ==1.0.1.0
   - msgpack-aeson ==0.1.0.0
   - mtl ==2.2.2
···
   - natural-sort ==0.1.2
   - natural-transformation ==0.4
   - ndjson-conduit ==0.1.0.5
-  - neat-interpolation ==0.3.2.5
+  - neat-interpolation ==0.3.2.6
   - netlib-carray ==0.1
   - netlib-comfort-array ==0.0.0.1
   - netlib-ffi ==0.1.1
···
   - network-simple-tls ==0.3.2
   - network-transport ==0.5.4
   - network-transport-composed ==0.2.1
-  - network-uri ==2.6.1.0
+  - network-uri ==2.6.2.0
   - newtype ==0.2.2.0
   - newtype-generics ==0.5.4
   - nicify-lib ==1.0.1
···
   - palette ==0.3.0.2
   - pandoc ==2.7.3
   - pandoc-citeproc ==0.16.2
-  - pandoc-csv2table ==1.0.7
+  - pandoc-csv2table ==1.0.8
   - pandoc-markdown-ghci-filter ==0.1.0.0
   - pandoc-pyplot ==2.1.5.1
   - pandoc-types ==1.17.6.1
···
   - persistent-iproute ==0.2.4
   - persistent-mysql ==2.9.0
   - persistent-mysql-haskell ==0.5.2
-  - persistent-pagination ==0.1.1.0
+  - persistent-pagination ==0.1.1.1
   - persistent-postgresql ==2.9.1
   - persistent-qq ==2.9.1
   - persistent-sqlite ==2.9.3
···
   - range-set-list ==0.1.3.1
   - rank1dynamic ==0.4.0
   - rank2classes ==1.3.2.1
-  - Rasterific ==0.7.5
+  - Rasterific ==0.7.5.1
   - rasterific-svg ==0.3.3.2
   - ratel ==1.0.9
   - ratel-wai ==1.1.1
···
   - scientific ==0.3.6.2
   - scotty ==0.11.5
   - scrypt ==0.5.0
-  - sdl2 ==2.5.0.0
+  - sdl2 ==2.5.1.0
   - sdl2-gfx ==0.2
   - sdl2-image ==2.0.0
   - sdl2-mixer ==1.1.0
···
   - sexpr-parser ==0.1.1.2
   - SHA ==1.6.4.4
   - shake-language-c ==0.12.0
-  - shakespeare ==2.0.23
+  - shakespeare ==2.0.24
   - shared-memory ==0.2.0.0
   - shell-conduit ==4.7.0
   - shell-escape ==0.2.0
···
   - slack-web ==0.2.0.11
   - smallcheck ==1.1.5
   - smallcheck-series ==0.6.1
-  - smoothie ==0.4.2.9
+  - smoothie ==0.4.2.10
   - snap-blaze ==0.2.1.5
   - snap-core ==1.0.4.1
   - snap-server ==1.1.1.1
···
   - stm-split ==0.0.2.1
   - stopwatch ==0.1.0.6
   - storable-complex ==0.2.3.0
-  - storable-record ==0.0.4
+  - storable-record ==0.0.4.1
   - storable-tuple ==0.0.3.3
   - storablevector ==0.2.13
-  - store ==0.5.1.2
   - store-core ==0.4.4.2
   - Strafunski-StrategyLib ==5.0.1.0
   - stratosphere ==0.40.0
···
   - stripe-signature ==1.0.0.1
   - stripe-wreq ==1.0.1.0
   - strive ==5.0.9
-  - structs ==0.1.2
+  - structs ==0.1.3
   - structured-cli ==2.5.2.0
   - summoner ==1.3.0.1
   - sum-type-boilerplate ==0.1.1
···
   - tasty-hunit ==0.10.0.2
   - tasty-kat ==0.0.3
   - tasty-leancheck ==0.0.1
-  - tasty-lua ==0.2.0.1
+  - tasty-lua ==0.2.2
   - tasty-program ==1.0.5
-  - tasty-quickcheck ==0.10.1
+  - tasty-quickcheck ==0.10.1.1
   - tasty-silver ==3.1.13
   - tasty-smallcheck ==0.8.1
   - tasty-th ==0.1.7
···
   - users-test ==0.5.0.1
   - utf8-light ==0.4.2
   - utf8-string ==1.0.1.1
-  - util ==0.1.17.0
+  - util ==0.1.17.1
   - utility-ht ==0.0.14
   - uuid ==1.3.13
   - uuid-types ==1.0.3
···
   - valor ==0.1.0.0
   - vault ==0.3.1.3
   - vec ==0.1.1.1
-  - vector ==0.12.0.3
+  - vector ==0.12.1.2
   - vector-algorithms ==0.8.0.3
   - vector-binary-instances ==0.2.5.1
   - vector-buffer ==0.4.1
···
   - vector-split ==1.0.0.2
   - vector-th-unbox ==0.2.1.7
   - verbosity ==0.3.0.0
-  - versions ==3.5.2
+  - versions ==3.5.3
   - ViennaRNAParser ==1.3.3
   - viewprof ==0.0.0.32
   - vinyl ==0.11.0
···
   - wizards ==1.0.3
   - wl-pprint-annotated ==0.1.0.1
   - wl-pprint-console ==0.1.0.2
-  - wl-pprint-text ==1.2.0.0
+  - wl-pprint-text ==1.2.0.1
   - word24 ==2.0.1
   - word8 ==0.1.3
   - wordpress-auth ==1.0.0.0
···
   - yeshql ==4.1.0.1
   - yeshql-core ==4.1.0.2
   - yeshql-hdbc ==4.1.0.2
-  - yesod ==1.6.0
+  - yesod ==1.6.0.1
   - yesod-alerts ==0.1.3.0
-  - yesod-auth ==1.6.8
+  - yesod-auth ==1.6.8.1
   - yesod-auth-hashdb ==1.7.1.2
   - yesod-auth-oauth2 ==0.6.1.2
   - yesod-bin ==1.6.0.4
-  - yesod-core ==1.6.17
+  - yesod-core ==1.6.17.2
   - yesod-csp ==0.2.5.0
   - yesod-eventsource ==1.6.0
   - yesod-fb ==0.5.0
···
   - atomic-primops-vector
   - atomo
   - ats-format
+  - ats-pkg
   - ats-setup
   - ats-storable
   - attic-schedule
···
   - hs-twitterarchiver
   - hs-vcard
   - hs-watchman
+  - hs2ats
   - hs2bf
   - Hs2lib
   - hsaml2
···
   - lame
   - lame-tester
   - lang
+  - language-ats
   - language-bash
   - language-boogie
   - language-c-comments
···
   - lxd-client
   - lye
   - Lykah
+  - lz4-bytes
   - lz4-conduit
   - lzma-enumerator
   - lzma-streams
···
   - perfect-vector-shuffle
   - PerfectHash
   - perfecthash
-  - perhaps
   - periodic
   - perm
   - permutations
···
   - sha-streams
   - shade
   - shadower
+  - shake-ats
   - shake-cabal-build
   - shake-extras
   - shake-minify
···
   - simseq
   - singleton-dict
   - singleton-typelits
+  - singletons-presburger
   - singnal
   - singular-factory
   - sink
···
   - uuagc-bootstrap
   - uuagc-diagrams
   - uuid-aeson
+  - uuid-bytes
   - uuid-orphans
   - uvector
   - uvector-algorithms

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

···
     '';
   });
 
+  # Break infinite recursion cycle with criterion and network-uri.
+  js-flot = dontCheck super.js-flot;
+
   # Break infinite recursion cycle between QuickCheck and splitmix.
   splitmix = dontCheck super.splitmix;
 

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

···
 
   "Color" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, colour, criterion
-     , data-default-class, deepseq, doctest, hspec, HUnit, QuickCheck
-     , random, template-haskell, vector
+     , data-default-class, deepseq, doctest, hspec, HUnit, JuicyPixels
+     , QuickCheck, random, template-haskell, vector
      }:
      mkDerivation {
        pname = "Color";
-       version = "0.1.1";
-       sha256 = "0jwqyvch7mpg83q57c50qc0visgc0nav6ihb8gr81wdp8i3f680k";
+       version = "0.1.2";
+       sha256 = "078qc0fjzhn4v1zq37hql3b84cnv39kc48hxxk9f3ngl7yn3d8va";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base data-default-class deepseq vector ];
        testHaskellDepends = [
-         base colour doctest hspec HUnit QuickCheck random template-haskell
-         vector
+         base colour doctest hspec HUnit JuicyPixels QuickCheck random
+         template-haskell vector
        ];
        benchmarkHaskellDepends = [ base colour criterion deepseq random ];
        description = "Color spaces and conversions between them";
···
      }:
      mkDerivation {
        pname = "Fin";
-       version = "0.2.8.0";
-       sha256 = "1smzghfifiqakbv9308bz5b4mkzmrfvgs6zpry5nw2lbqh7crcc7";
+       version = "0.2.9.0";
+       sha256 = "1wkbdjrpb7ydc659h76yrrhyv7akwx64k7cxv5fmjrwn4vgd0r8a";
        libraryHaskellDepends = [
          alg base foldable1 natural-induction peano universe-base
        ];
···
      }:
      mkDerivation {
        pname = "Rasterific";
-       version = "0.7.5";
-       sha256 = "158s0w95x0yxhffcccvhil827jmv7mmbh65nbg8qypvw9j4ldb9j";
-       libraryHaskellDepends = [
-         base bytestring containers dlist FontyFruity free JuicyPixels mtl
-         primitive transformers vector vector-algorithms
-       ];
-       description = "A pure haskell drawing engine";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "Rasterific_0_7_5_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, dlist, FontyFruity
-     , free, JuicyPixels, mtl, primitive, transformers, vector
-     , vector-algorithms
-     }:
-     mkDerivation {
-       pname = "Rasterific";
        version = "0.7.5.1";
        sha256 = "0n2kamiymfnh93yc8zn3bjjnxlz1q2yyc33f9h2ahyn4wzfw64n6";
        libraryHaskellDepends = [
···
        ];
        description = "A pure haskell drawing engine";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ReadArgs" = callPackage
···
        pname = "acme-mutable-package";
        version = "0";
        sha256 = "16da6pkkdr2g77dn3n4v9x6mwi6yz3xlpisvpn0id2xz0bayipmr";
-       revision = "3";
-       editedCabalFile = "094kr4ib0hldgccr5bvy9azpfvkf5dmq3hq6xk5hyha6djjkx2gc";
+       revision = "4";
+       editedCabalFile = "1154vbz0yar1xd8jn2v2dl5fc2pkawwp93yd0g5dcrb9bbx6pagf";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [ base ];
        description = "A mutable package";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ad_4_4" = callPackage
+    ({ mkDerivation, array, base, Cabal, cabal-doctest, comonad
+     , containers, criterion, data-reify, directory, doctest, erf
+     , filepath, free, nats, reflection, semigroups, transformers
+     }:
+     mkDerivation {
+       pname = "ad";
+       version = "4.4";
+       sha256 = "1v7m5nk9aa0sfqfqmv15dq87s2nl7i3v1d5xx0xla9ydhlqizy4x";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array base comonad containers data-reify erf free nats reflection
+         semigroups transformers
+       ];
+       testHaskellDepends = [ base directory doctest filepath ];
+       benchmarkHaskellDepends = [ base criterion erf ];
+       description = "Automatic Differentiation";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "adaptive-containers" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "adjunction" = callPackage
+    ({ mkDerivation, base, gauge, hs-functors }:
+     mkDerivation {
+       pname = "adjunction";
+       version = "0.0.0.0";
+       sha256 = "1n83ak423jwyj3w708alj9ngczzll05jyn60d0fgx8bvr3hlmi0i";
+       libraryHaskellDepends = [ base hs-functors ];
+       testHaskellDepends = [ base hs-functors ];
+       benchmarkHaskellDepends = [ base gauge hs-functors ];
+       description = "See README for more info";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "adjunctions" = callPackage
     ({ mkDerivation, array, base, comonad, containers, contravariant
      , distributive, free, generic-deriving, hspec, hspec-discover, mtl
···
        broken = true;
      }) {};
 
+  "aeson-default" = callPackage
+    ({ mkDerivation, aeson, base, containers }:
+     mkDerivation {
+       pname = "aeson-default";
+       version = "0.9.1.0";
+       sha256 = "0fmjxanahqdkrrgy56i2xbm3547c512k4p4if6c6lvrxcfvb8zjy";
+       libraryHaskellDepends = [ aeson base containers ];
+       testHaskellDepends = [ aeson base containers ];
+       description = "Apply default value to FromJSON instacnes' Maybe fields";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "aeson-diff" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, doctest
      , edit-distance-vector, filepath, Glob, hashable, mtl
···
      }:
      mkDerivation {
        pname = "aeson-match-qq";
-       version = "1.0.0";
-       sha256 = "0py6h62a9h7wmrgcc79inbpx5b3jv660jlf5hqc1hdnvmf96prkr";
+       version = "1.1.0";
+       sha256 = "0qkj38b05klzwrgy0vyr9qnkllzz9v225b3d60f6mbx3q3nxdk9x";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either haskell-src-meta scientific
          template-haskell text unordered-containers vector
···
        testHaskellDepends = [
          aeson aeson-qq base hspec unordered-containers
        ];
-       description = "Matching Aeson values with a quasiquoter";
+       description = "Declarative JSON matchers";
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "alex-meta";
-       version = "0.3.0.9";
-       sha256 = "0882p9j272dhq94kgmg6pnxzi3qfwa01fk7npsz748rgx6ggycyr";
-       revision = "1";
-       editedCabalFile = "0p6j9ilvn5gjx0n7v1war0z8rlmcz1qnvpc8lcik8l7baydz6qjl";
+       version = "0.3.0.11";
+       sha256 = "0pb6m2h9r3j71iy8ch8kgvssblidlr6r7k12fa1q2v7wi5q2mq91";
        libraryHaskellDepends = [
          array base containers haskell-src-meta QuickCheck template-haskell
        ];
···
        testHaskellDepends = [
          array base base-compat base-orphans containers extra
          inspection-testing QuickCheck
+       ];
+       description = "A library for algebraic graph construction and transformation";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "algebraic-graphs_0_5" = callPackage
+    ({ mkDerivation, array, base, containers, deepseq, extra
+     , inspection-testing, mtl, QuickCheck, transformers
+     }:
+     mkDerivation {
+       pname = "algebraic-graphs";
+       version = "0.5";
+       sha256 = "02y5g459zl6hgdyq0kkqv4gz9v2xp7y2al9m4g46wis5hb7zxfc9";
+       libraryHaskellDepends = [
+         array base containers deepseq mtl transformers
+       ];
+       testHaskellDepends = [
+         array base containers deepseq extra inspection-testing mtl
+         QuickCheck transformers
        ];
        description = "A library for algebraic graph construction and transformation";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "apecs";
-       version = "0.8.2";
-       sha256 = "06dhq7knzxj48563ll7r1srlgq5nd2kbk5fzrf7x6yjp0w2c9kmp";
-       libraryHaskellDepends = [
-         array base containers mtl template-haskell vector
-       ];
-       testHaskellDepends = [ base containers linear QuickCheck vector ];
-       benchmarkHaskellDepends = [ base criterion linear ];
-       description = "Fast Entity-Component-System library for game programming";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "apecs_0_8_3" = callPackage
-    ({ mkDerivation, array, base, containers, criterion, linear, mtl
-     , QuickCheck, template-haskell, vector
-     }:
-     mkDerivation {
-       pname = "apecs";
        version = "0.8.3";
        sha256 = "1g9fvyhsbriz0c5l3xyaba7yds2iqwkrrrlfvihdr8mr1cx5mw3n";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion linear ];
        description = "Fast Entity-Component-System library for game programming";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "apecs-gloss" = callPackage
···
      }:
      mkDerivation {
        pname = "arduino-copilot";
-       version = "1.3.0";
-       sha256 = "0524xga8r55zpf6fw4vg7al2d6i9q4qinsx3zlqq0825qq8pp5nr";
+       version = "1.4.0";
+       sha256 = "031vi24iz25qrzjw3xha1sajzrgjrkypypy0ngfpffzl5zlarpsb";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language directory
          filepath mtl optparse-applicative unix
···
        doHaddock = false;
        description = "A build tool for ATS";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "ats-setup" = callPackage
···
      }:
      mkDerivation {
        pname = "base-orphans";
-       version = "0.8.1";
-       sha256 = "1nwr9av27i9p72k0sn96mw3ywdczw65dy5gd5wxpabhhxlxdcas4";
-       libraryHaskellDepends = [ base ghc-prim ];
-       testHaskellDepends = [ base hspec QuickCheck ];
-       testToolDepends = [ hspec-discover ];
-       description = "Backwards-compatible orphan instances for base";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "base-orphans_0_8_2" = callPackage
-    ({ mkDerivation, base, ghc-prim, hspec, hspec-discover, QuickCheck
-     }:
-     mkDerivation {
-       pname = "base-orphans";
        version = "0.8.2";
        sha256 = "00gbp4v4nxgp8gb3pyg23yy5f59rp5r2r8i8hi0ywpaxbqw6501a";
        libraryHaskellDepends = [ base ghc-prim ];
···
        testToolDepends = [ hspec-discover ];
        description = "Backwards-compatible orphan instances for base";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "base-prelude" = callPackage
···
      }:
      mkDerivation {
        pname = "base64";
-       version = "0.4.0";
-       sha256 = "0mq9pnlcmjxalkq6i9shp6652l34qqp6gsahma9pi2rvk1klk7vv";
+       version = "0.4.1";
+       sha256 = "06mwamlqdz90k7nh3x4w0j0mjkbhkns11hvj9zd8d1yw6wy3l4hd";
+       revision = "1";
+       editedCabalFile = "1jvx3wpnfwzxfz5w3bqglqcv539fkk7wivl8ylm126pqh7sjdp5f";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base base64-bytestring bytestring random-bytestring tasty
···
          base base64-bytestring bytestring deepseq gauge memory
          random-bytestring text
        ];
-       description = "RFC 4648-compliant padded and unpadded base64 and base64url encodings";
+       description = "Fast RFC 4648-compliant Base64 encoding";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        pname = "base64-lens";
        version = "0.2.0";
        sha256 = "0d4lri7wpaxx7hgd7slxj5jl2qkgfairzsga4vajl05g49amyk80";
+       revision = "1";
+       editedCabalFile = "07x38p4zcv05y94gjn5j3j1ydv06vi17fbjnz4ckcgc3ay0dzbzf";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base base64 bytestring lens text ];
        testHaskellDepends = [ base doctest lens ];
···
      }:
      mkDerivation {
        pname = "bifunctors";
-       version = "5.5.6";
-       sha256 = "1jnsnc0rj3vkx8rjwsf2aacla9xzdfy1am9mmjk8crxp2gkazcnc";
-       libraryHaskellDepends = [
-         base base-orphans comonad containers tagged template-haskell
-         th-abstraction transformers
-       ];
-       testHaskellDepends = [
-         base hspec QuickCheck template-haskell transformers
-         transformers-compat
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Bifunctors";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "bifunctors_5_5_7" = callPackage
-    ({ mkDerivation, base, base-orphans, comonad, containers, hspec
-     , hspec-discover, QuickCheck, tagged, template-haskell
-     , th-abstraction, transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "bifunctors";
        version = "5.5.7";
        sha256 = "0cimvd64jzd6dyxjw2kx8wqhd1x0z89pj0ppmsikj4afa3aa5cw8";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Bifunctors";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "bighugethesaurus" = callPackage
···
      }) {};
 
   "binary-strict" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, mtl }:
+    ({ mkDerivation, array, base, bytestring, mtl }:
      mkDerivation {
        pname = "binary-strict";
-       version = "0.4.8.3";
-       sha256 = "1c9cm428zp8ncrjca5y5i0y91rzppmrk4zpjkp1ppbpxv5dzpf4f";
-       revision = "1";
-       editedCabalFile = "1y4x4zhqs8lxxy9qcmkf93g9a1fa6bkn9my8pb9ac75qnc8mi42x";
-       libraryHaskellDepends = [ array base bytestring containers mtl ];
+       version = "0.4.8.4";
+       sha256 = "07b62k4vqdxwaa8fp3zy2xgzc8j1wgzjh04jij2dabk0329flham";
+       libraryHaskellDepends = [ array base bytestring mtl ];
        description = "Binary deserialisation using strict ByteStrings";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "bioinformatics-toolkit";
-       version = "0.9.1";
-       sha256 = "1blx00zkmw85c4pp36fp6jig8yy1qsc68vn40pglm0j3lgwagv9w";
+       version = "0.9.2";
+       sha256 = "1glf8wnswn60mcyrwn6y1ma6db1k6zckjmzbm28nvr961plp108b";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson aeson-pretty attoparsec base bytestring bytestring-lexing
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "brick_0_50_1" = callPackage
+  "brick_0_51" = callPackage
     ({ mkDerivation, base, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, dlist, filepath
      , microlens, microlens-mtl, microlens-th, QuickCheck, stm
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "0.50.1";
-       sha256 = "0wv69pbs4xqfdqw9ag32fhqhmh8djxb14h8jpyblmykirlznx77y";
+       version = "0.51";
+       sha256 = "05phqqq4sb7b11maava7y9by1lz6drzzhggvb2nsxsbajlka41h8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "brittany";
        version = "0.12.1.1";
        sha256 = "0nw7ymdb7xam634w42l1xjgyvpla8grcg02aj19fscw2fn9gfh7z";
+       revision = "1";
+       editedCabalFile = "0wqg0yl3da1dgpqqv5q0ml3k0njn7pgipaac4vd9gidv3d1pyd74";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "brok";
-       version = "0.1.7.0";
-       sha256 = "1961s6ccr5x81jym34y1437pa7ml4jsxnw4gd1r496h8mh9lcm99";
+       version = "0.2.0.0";
+       sha256 = "1fsh05433gkm89j4nf9whcif0iiscxbd32q307rjm1fwsfwp9c46";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "bytes_0_16" = callPackage
+  "bytes_0_17" = callPackage
     ({ mkDerivation, base, binary, binary-orphans, bytestring, Cabal
      , cabal-doctest, cereal, containers, directory, doctest, filepath
      , hashable, mtl, scientific, text, time, transformers
···
      }:
      mkDerivation {
        pname = "bytes";
-       version = "0.16";
-       sha256 = "1m8nkviq4ckqi9v1w1fxzicdzmvb3wfxcmqmppjrrmkwawn4c6i9";
-       revision = "1";
-       editedCabalFile = "080sdihajl7fbcyp2j4mbq3zlh8jl6dsn51gk89h1r5nl3zzh3gz";
+       version = "0.17";
+       sha256 = "11gacfxcn9f3v5a1phlgi7mwwrnyh51sfsym573g6i4v2zqfrwi3";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base binary binary-orphans bytestring cereal containers hashable
···
      }:
      mkDerivation {
        pname = "bytesmith";
-       version = "0.3.3.0";
-       sha256 = "08q2wpdj3na06n7k1ig27i67csby6yy2vhrgcdpmsi1jx8as9nwh";
+       version = "0.3.4.0";
+       sha256 = "0xl7iigb260z66na22zvwif18a2rng7damvrz53r818kdqmllg4v";
        libraryHaskellDepends = [
          base byteslice bytestring contiguous primitive run-st text-short
          wide-word
···
        broken = true;
      }) {};
 
-  "cabal-rpm_2_0_0" = callPackage
+  "cabal-rpm_2_0_1" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, directory, 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.0";
-       sha256 = "1gr68l5bg2mfl6b8nbfzcinibldk271psxp5wkiw14mclyx7ln8g";
+       version = "2.0.1";
+       sha256 = "0kspqf3lsaczwgidih9f7xlgpdx9asarb3s8s3n2bwq5g68gh2l7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "capnp";
        version = "0.4.0.0";
        sha256 = "1dzabszp3nn13rmvqmdl2gimwmkdpjzd303chbi0jw8248s14bfx";
+       revision = "1";
+       editedCabalFile = "16h6xvl3xr91rfn5l9lyg2jq14mffxjnkzhva4gn4bds01g2d2jl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      , 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, vector, websockets, wuss
+     , unordered-containers, uuid, vector, websockets, wuss
      }:
      mkDerivation {
        pname = "coinbase-pro";
-       version = "0.7.2.0";
-       sha256 = "1vkw9pda8pn5kljpv6hx0mdml5yjgz354dvfv02akl81ds3r0lhq";
+       version = "0.8.0.0";
+       sha256 = "021c05qkrvgxlylvrrlb81bjxl49v5varn0fi5wqs5sda15766n3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          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
-         unagi-streams unordered-containers vector websockets wuss
+         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
-         unagi-streams unordered-containers vector websockets wuss
+         unagi-streams unordered-containers uuid vector websockets wuss
        ];
        description = "Client for Coinbase Pro";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "configuration-tools";
-       version = "0.4.1";
-       sha256 = "1c6yk6516v4ld8rmhwg4s4f3s6k40gx3dsqfrl2y9lcx3477nlj8";
-       setupHaskellDepends = [
-         base bytestring Cabal directory filepath process
-       ];
-       libraryHaskellDepends = [
-         aeson ansi-wl-pprint attoparsec base base-unicode-symbols
-         base64-bytestring bytestring Cabal case-insensitive connection
-         data-default deepseq directory dlist enclosed-exceptions filepath
-         http-client http-client-tls http-types monad-control mtl
-         network-uri optparse-applicative process profunctors semigroupoids
-         semigroups text tls transformers unordered-containers x509
-         x509-system x509-validation yaml
-       ];
-       testHaskellDepends = [
-         base base-unicode-symbols bytestring Cabal enclosed-exceptions
-         http-types monad-control mtl text transformers unordered-containers
-         wai warp warp-tls yaml
-       ];
-       description = "Tools for specifying and parsing configurations";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "configuration-tools_0_4_2" = callPackage
-    ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base
-     , base-unicode-symbols, base64-bytestring, bytestring, Cabal
-     , case-insensitive, connection, data-default, deepseq, directory
-     , dlist, enclosed-exceptions, filepath, http-client
-     , http-client-tls, http-types, monad-control, mtl, network-uri
-     , optparse-applicative, process, profunctors, semigroupoids
-     , semigroups, text, tls, transformers, unordered-containers, wai
-     , warp, warp-tls, x509, x509-system, x509-validation, yaml
-     }:
-     mkDerivation {
-       pname = "configuration-tools";
        version = "0.4.2";
        sha256 = "08wzgd38adlrgp9s8330hsp3h1jmhnlaj3fyvkxgljlmyyzlw70q";
        setupHaskellDepends = [
···
        ];
        description = "Tools for specifying and parsing configurations";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "configurator" = callPackage
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
-  "constraints_0_11_2" = callPackage
+  "constraints_0_12" = callPackage
     ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, hspec
      , hspec-discover, mtl, semigroups, transformers
      , transformers-compat, type-equality
      }:
      mkDerivation {
        pname = "constraints";
-       version = "0.11.2";
-       sha256 = "10mnhg7p5gk4i3bzldl07qkrihnvmfkgsp32w7p9i7x8cmj5akjq";
+       version = "0.12";
+       sha256 = "08q2fq2xy2ija164k5a178jjffdii57nrx2x9ddz24zh2ld56szj";
        libraryHaskellDepends = [
          base binary deepseq ghc-prim hashable mtl semigroups transformers
          transformers-compat type-equality
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.2.4.1";
-       sha256 = "0ji0vnk7k4rgib6zpid7fjqy1ggf3m88cm6j23bg0lvmj5rvml5c";
+       version = "0.2.4.2";
+       sha256 = "0zs62mn87fdrjwi1dp11hkr7nbb7v3ikxk1ph6cnjdk0di9hrr6a";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-text directory
          exceptions filepath fsnotify hashable hourglass mtl prettyprinter
···
      }:
      mkDerivation {
        pname = "daemons";
-       version = "0.2.1";
-       sha256 = "0zf9831vl1hz606nsp0yhjg46wxzvwkd3hn9shjw5akk26sddi8p";
+       version = "0.3.0";
+       sha256 = "05h03qk31lank60cd0ig9h4rf8zl6p4li5smba919lgpm89lyvy3";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "decidable_0_2_1_0" = callPackage
+  "decidable_0_3_0_0" = callPackage
     ({ mkDerivation, base, functor-products, microlens, singletons
      , vinyl
      }:
      mkDerivation {
        pname = "decidable";
-       version = "0.2.1.0";
-       sha256 = "1l307j4n9xagarbqqa48c729fs63qlzy5sqzgfyzfqwnas8yrqhx";
+       version = "0.3.0.0";
+       sha256 = "1phzfp2q82ylxj09150v1gqmk8858qjw9prhn32zjfnyzfzcg3mq";
        libraryHaskellDepends = [
          base functor-products microlens singletons vinyl
        ];
···
        pname = "dhall-bash";
        version = "1.0.27";
        sha256 = "0mmf53fqgf8g6s80g6wss86lcfkrpjc51w5givy7kg9js00d48px";
+       revision = "1";
+       editedCabalFile = "1w4hbk6xx04q0f1sxgwmp3h5s3cwc3w22vbvdxz052nhdcj3sigw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dmcc";
-       version = "1.1.0.1";
-       sha256 = "1agha3ppi1jh08pjn6s7jbfqqll0svwxpq2an69hcgl5kf01y0c7";
+       version = "1.1.0.2";
+       sha256 = "0xm5lxnaqlrsgxvcr4xhf85angv5is1rhy992frkiz75w74adzd7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "eccrypto-ed25519-bindings" = callPackage
+    ({ mkDerivation, base, bytestring, eccrypto }:
+     mkDerivation {
+       pname = "eccrypto-ed25519-bindings";
+       version = "0.1.0.0";
+       sha256 = "1yi93a9x5sl3h50cky7l9df3077kwr3grp2iw9s5iykcwi6jdzg7";
+       libraryHaskellDepends = [ base bytestring eccrypto ];
+       description = "provides \"ed25519\" API using \"eccrypto\"";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "ecdsa" = callPackage
     ({ mkDerivation, base, bytestring, crypto-api, crypto-pubkey-types
      , hecc
···
     ({ mkDerivation, base, doctest }:
      mkDerivation {
        pname = "either-list-functions";
-       version = "0.0.0.3";
-       sha256 = "1b01aj05dbx51hgyhmggh1zgcbwfvyijkxj7knqpbgpj7hymv00y";
+       version = "0.0.2.0";
+       sha256 = "04xl2xrlrmf0znic1vx521d73i6znyyjijp58h6ak0sx45kclw39";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        description = "Functions involving lists of Either";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "envy_2_1_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, mtl
+     , QuickCheck, quickcheck-instances, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "envy";
+       version = "2.1.0.0";
+       sha256 = "0s6jp2npnp0x5hndnhkjwc9bhdghzlpl0n38804afiwxai9bawy8";
+       libraryHaskellDepends = [
+         base bytestring containers mtl text time transformers
+       ];
+       testHaskellDepends = [
+         base bytestring hspec mtl QuickCheck quickcheck-instances text time
+         transformers
+       ];
+       description = "An environmentally friendly way to deal with environment variables";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "envy-extensible" = callPackage
     ({ mkDerivation, base, doctest, envy, extensible, hspec
      , hspec-discover, main-tester, QuickCheck
      }:
      mkDerivation {
        pname = "envy-extensible";
-       version = "0.1.0.0";
-       sha256 = "1m5qly9la0b3rxp8amni7nhgisg5vmp3zi76hc1586c202cnsl70";
+       version = "0.2.0.1";
+       sha256 = "0800a7drik9h3bxnkqriwjg2j31j8k3pw5fsmswnmfh4wwv2bb6v";
        libraryHaskellDepends = [ base envy extensible ];
        testHaskellDepends = [
          base doctest envy extensible hspec main-tester QuickCheck
···
      }) {};
 
   "erd" = callPackage
-    ({ mkDerivation, base, bytestring, containers, graphviz, hspec
-     , parsec, QuickCheck, raw-strings-qq, tasty, tasty-hunit, text
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , gitrev, graphviz, parsec, raw-strings-qq, tasty, tasty-hunit
+     , text, yaml
      }:
      mkDerivation {
        pname = "erd";
-       version = "0.2.0.0";
-       sha256 = "1lxqjvsmkqhqaw63r6qp6z9kjz73ki6y3vr85bjs5i0m7ff87799";
+       version = "0.2.1.0";
+       sha256 = "1p21q4x5l29mhnm17j77b4w5rqc9n4jd24czawz7p1srmzvl67hs";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring containers graphviz parsec text
+         base bytestring containers directory filepath gitrev graphviz
+         parsec raw-strings-qq text yaml
        ];
        testHaskellDepends = [
-         base bytestring containers graphviz hspec parsec QuickCheck
-         raw-strings-qq tasty tasty-hunit text
+         base bytestring containers directory filepath gitrev graphviz
+         parsec raw-strings-qq tasty tasty-hunit text yaml
        ];
        description = "An entity-relationship diagram generator from a plain text description";
        license = stdenv.lib.licenses.publicDomain;
···
      }) {};
 
   "ersatz" = callPackage
-    ({ mkDerivation, array, attoparsec, base, bytestring, Cabal
-     , cabal-doctest, containers, data-default, directory, doctest, fail
-     , filepath, lens, mtl, parsec, process, semigroups, temporary
-     , transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "ersatz";
-       version = "0.4.7";
-       sha256 = "0kddsh02yrpn7xack6xcs0c93hmf4gkmh56zip2n6q7j0xgdrl6d";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         array attoparsec base bytestring containers data-default lens mtl
-         process semigroups temporary transformers unordered-containers
-       ];
-       executableHaskellDepends = [
-         array base containers fail lens mtl parsec semigroups
-       ];
-       testHaskellDepends = [ array base directory doctest filepath mtl ];
-       description = "A monad for expressing SAT or QSAT problems using observable sharing";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "ersatz_0_4_8" = callPackage
     ({ mkDerivation, array, attoparsec, base, bytestring, Cabal
      , cabal-doctest, containers, data-default, directory, doctest, fail
      , filepath, lens, mtl, parsec, process, semigroups, temporary
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "fast-digits_0_3_0_0" = callPackage
+    ({ mkDerivation, base, digits, gauge, integer-gmp, QuickCheck
+     , smallcheck, tasty, tasty-quickcheck, tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "fast-digits";
+       version = "0.3.0.0";
+       sha256 = "1vlmjlkmv1nmw1rriafm2hzkmqd5xnwgzmvrg6xxqj1ab5sdsafs";
+       libraryHaskellDepends = [ base integer-gmp ];
+       testHaskellDepends = [
+         base digits QuickCheck smallcheck tasty tasty-quickcheck
+         tasty-smallcheck
+       ];
+       benchmarkHaskellDepends = [ base digits gauge ];
+       doHaddock = false;
+       description = "Integer-to-digits conversion";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "fast-downward" = callPackage
     ({ mkDerivation, base, containers, mtl, process, temporary, text
      , transformers
···
     ({ mkDerivation, base, doctest, first-class-families, Glob }:
      mkDerivation {
        pname = "fcf-containers";
-       version = "0.1.0";
-       sha256 = "1rvchhv59640iiwx2f9byf5klayx150aws1wz54v85bfcsxwsrac";
+       version = "0.2.0";
+       sha256 = "02ymhc7ms6k7ms966px8a4zhgsd71ncyb4c08b0x51n6v442cwmh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base first-class-families ];
        executableHaskellDepends = [ base first-class-families ];
-       testHaskellDepends = [ base doctest Glob ];
+       testHaskellDepends = [ base doctest first-class-families Glob ];
        description = "Data structures and algorithms for first-class-families";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }) {};
 
   "fclabels" = callPackage
-    ({ mkDerivation, base, criterion, HUnit, mtl, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "fclabels";
-       version = "2.0.3.3";
-       sha256 = "1q62p41bj991s7i15ciayw1v1xq8szn4bls50p65lfy2dnj7554s";
-       revision = "4";
-       editedCabalFile = "09pn1q4gjlhw956asmhzva1rhrafmn69xmd1sc80fh3c8vjd3icz";
-       libraryHaskellDepends = [ base mtl template-haskell transformers ];
-       testHaskellDepends = [
-         base HUnit mtl template-haskell transformers
-       ];
-       benchmarkHaskellDepends = [ base criterion ];
-       description = "First class accessor labels implemented as lenses";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "fclabels_2_0_4" = callPackage
     ({ mkDerivation, base, base-orphans, criterion, HUnit, mtl
      , template-haskell, transformers
      }:
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "First class accessor labels implemented as lenses";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "fclabels-monadlib" = callPackage
···
      }:
      mkDerivation {
        pname = "fgl";
-       version = "5.7.0.1";
-       sha256 = "04793yh778ck3kz1z2svnfdwwls2kisbnky4lzvf4zjfgpv7mkpz";
-       libraryHaskellDepends = [
-         array base containers deepseq transformers
-       ];
-       testHaskellDepends = [ base containers hspec QuickCheck ];
-       benchmarkHaskellDepends = [ base deepseq microbench ];
-       description = "Martin Erwig's Functional Graph Library";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "fgl_5_7_0_2" = callPackage
-    ({ mkDerivation, array, base, containers, deepseq, hspec
-     , microbench, QuickCheck, transformers
-     }:
-     mkDerivation {
-       pname = "fgl";
        version = "5.7.0.2";
        sha256 = "13zqdwj6j2y5827w3dcx8kl1gini4x938bfh4c5g5jc3b37rlnll";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base deepseq microbench ];
        description = "Martin Erwig's Functional Graph Library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "fgl-arbitrary" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "first-class-instances" = callPackage
+    ({ mkDerivation, base, Cabal, containers, hspec, hspec-discover
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "first-class-instances";
+       version = "0.1.0.0";
+       sha256 = "0d3pay7x31a5d9g4rkb0sflk97qcnpyg3fh81247b6r21gl5qbr3";
+       libraryHaskellDepends = [ base Cabal containers template-haskell ];
+       testHaskellDepends = [
+         base Cabal containers hspec hspec-discover template-haskell
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "First class typeclass instances";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "first-class-patterns" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "flat-mcmc";
-       version = "1.5.0";
-       sha256 = "1zgi69vgwss7hhv893n5z3av0byb5hiblha7k3ck4bbfmkgakkl7";
-       revision = "1";
-       editedCabalFile = "1pjkyvs4c6yx6jva08zw2b1qfhhv9q71sy806f5lddjsknnym2fn";
-       libraryHaskellDepends = [
-         base formatting mcmc-types monad-par monad-par-extras
-         mwc-probability pipes primitive text transformers vector
-       ];
-       testHaskellDepends = [ base vector ];
-       description = "Painless general-purpose sampling";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "flat-mcmc_1_5_1" = callPackage
-    ({ mkDerivation, base, formatting, mcmc-types, monad-par
-     , monad-par-extras, mwc-probability, pipes, primitive, text
-     , transformers, vector
-     }:
-     mkDerivation {
-       pname = "flat-mcmc";
        version = "1.5.1";
        sha256 = "1fi18hx6mz7qskhnnjviaghqz0vsbrvglyk16xzj3kywx70hakpb";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base vector ];
        description = "Painless general-purpose sampling";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "flat-tex" = callPackage
···
     ({ mkDerivation, base, doctest, Glob, transformers }:
      mkDerivation {
        pname = "from-sum";
-       version = "0.2.2.0";
-       sha256 = "05fppk2hkxn67xfl6kdzdp2a5mfz63dv4yx7mvr9fbdrarxrf326";
-       libraryHaskellDepends = [ base transformers ];
-       testHaskellDepends = [ base doctest Glob ];
-       description = "Canonical fromMaybeM and fromEitherM functions";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "from-sum_0_2_3_0" = callPackage
-    ({ mkDerivation, base, doctest, Glob, transformers }:
-     mkDerivation {
-       pname = "from-sum";
        version = "0.2.3.0";
        sha256 = "1rdsynimmq81y3g5c8z9yvlqhsl99hnvjq4wvdci5ql788cq4m81";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [ base doctest Glob ];
        description = "Combinators for working with Maybe and Either";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "fromhtml" = callPackage
···
 
   "front" = callPackage
     ({ mkDerivation, aeson, async, base, blaze-html, blaze-markup
-     , bytestring, conduit, fay, fay-dom, fay-websockets, mtl, stm
-     , stm-lifted, text, websockets
+     , bytestring, conduit, fay, fay-dom, fay-websockets, mtl, stm, text
+     , websockets
      }:
      mkDerivation {
        pname = "front";
-       version = "0.0.0.2";
-       sha256 = "106y0qnz5lyvxy69s24fapqkys6i373kl2v51bpkvfwq5ppax0b0";
+       version = "0.0.0.3";
+       sha256 = "0n2w3rcl20njqrxx9ws2jrw3yjrxhxzl6q916apyh07bricmmkw9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async base blaze-html blaze-markup bytestring conduit fay
-         fay-dom fay-websockets mtl stm stm-lifted text websockets
+         fay-dom fay-websockets mtl stm text websockets
        ];
        description = "A reactive frontend web framework";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "fused-effects_1_0_0_0" = callPackage
+  "fused-effects_1_0_0_1" = callPackage
     ({ mkDerivation, base, containers, gauge, hedgehog, hedgehog-fn
      , inspection-testing, markdown-unlit, mtl, tasty, tasty-hedgehog
      , tasty-hunit, transformers
      }:
      mkDerivation {
        pname = "fused-effects";
-       version = "1.0.0.0";
-       sha256 = "120jvgh35wl5vb2qad8c1dhpr1ddlbhm5b03dy9kcb7d8s89qfs6";
+       version = "1.0.0.1";
+       sha256 = "1v11m8i4ffadfiy3bxwgjcrx5z5gzxv4ciniqzv01b0jxajfkg9g";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          base containers hedgehog hedgehog-fn inspection-testing mtl tasty
···
        broken = true;
      }) {};
 
+  "fusion-plugin" = callPackage
+    ({ mkDerivation, base, ghc, syb }:
+     mkDerivation {
+       pname = "fusion-plugin";
+       version = "0.1.0";
+       sha256 = "0qns66bakz2vlvglglz3qjg8f7483sldlm25v5lph8fdkj2psrfx";
+       libraryHaskellDepends = [ base ghc syb ];
+       description = "GHC plugin to make stream fusion more predictable";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "futhark" = callPackage
     ({ mkDerivation, aeson, alex, ansi-terminal, array, base, binary
      , blaze-html, bytestring, containers, data-binary-ieee754
···
        pname = "futhark";
        version = "0.14.1";
        sha256 = "1bg0r9b0jg9j12lcc6wa684yjm58l020m9x5abpc54cghigywswj";
+       revision = "1";
+       editedCabalFile = "0iqg18jz8lgbh9iq1zgs8j9q5smzzi8w1asryz4dx8y6dl7n97p5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          sed -i "s|\"-s\"|\"\"|" ./Setup.hs
          sed -i "s|numJobs (bf bi)++||" ./Setup.hs
        '';
-       preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build:$LD_LIBRARY_PATH'';
+       preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH'';
        description = "Grammatical Framework";
        license = "unknown";
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib_8_8_2" = callPackage
+  "ghc-lib_8_8_2_20200205" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, filepath, ghc-lib-parser, ghc-prim, happy
      , hpc, pretty, process, time, transformers, unix
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "8.8.2";
-       sha256 = "0dsb41vk9agywzw7nayraq9hhi95vz6aw9yz8jgggh1an4vkg833";
+       version = "8.8.2.20200205";
+       sha256 = "13sq702fv3p8jwvsswxz51lp0h33hd1abxrrflxyqlhz84hn9lk9";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser_8_8_2" = callPackage
+  "ghc-lib-parser_8_8_2_20200205" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, filepath, ghc-prim, happy, hpc, pretty
      , process, time, transformers, unix
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "8.8.2";
-       sha256 = "0q9pxdwmzm5hr6snpbkn1d3165h0lrdncgid5aqffqwz2hc1d2z0";
+       version = "8.8.2.20200205";
+       sha256 = "17rhzlwya0v6l146hmg6z3j224sr31s2pszspwyab790pncyrxgq";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser-ex";
-       version = "8.8.3.0";
-       sha256 = "01xlp9drkwdh5n822x2pvga95lpvwa195lf9wpnx8z9v5sj2lksa";
+       version = "8.8.4.0";
+       sha256 = "17vvqk2kkh8rd7shpdzassijfrdljbgbgm955l75569chsbf5xma";
        libraryHaskellDepends = [
          base bytestring ghc-lib-parser uniplate
        ];
···
        pname = "ghc-paths";
        version = "0.1.0.12";
        sha256 = "1164w9pqnf7rjm05mmfjznz7rrn415blrkk1kjc0gjvks1vfdjvf";
+       revision = "1";
+       editedCabalFile = "1gb4hn87a78j1c2y1adi81y03irzkaxywscjkphfajsxc7f0ydw5";
        setupHaskellDepends = [ base Cabal directory ];
        libraryHaskellDepends = [ base ];
        description = "Knowledge of GHC's installation directories";
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
+  "ghc-typelits-extra_0_3_3" = callPackage
+    ({ mkDerivation, base, containers, ghc, ghc-prim
+     , ghc-tcplugins-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, integer-gmp, tasty, tasty-hunit
+     , transformers
+     }:
+     mkDerivation {
+       pname = "ghc-typelits-extra";
+       version = "0.3.3";
+       sha256 = "0gdnp7pp3v5742qs9vkg2bh1sws9bcc11z4119fdapflglqq22mc";
+       libraryHaskellDepends = [
+         base containers ghc ghc-prim ghc-tcplugins-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise integer-gmp
+         transformers
+       ];
+       testHaskellDepends = [
+         base ghc-typelits-knownnat ghc-typelits-natnormalise tasty
+         tasty-hunit
+       ];
+       description = "Additional type-level operations on GHC.TypeLits.Nat";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ghc-typelits-knownnat" = callPackage
     ({ mkDerivation, base, ghc, ghc-tcplugins-extra
      , ghc-typelits-natnormalise, tasty, tasty-hunit, tasty-quickcheck
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
-  "ghc-typelits-knownnat_0_7_1" = callPackage
+  "ghc-typelits-knownnat_0_7_2" = callPackage
     ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
      , ghc-typelits-natnormalise, tasty, tasty-hunit, tasty-quickcheck
      , template-haskell, transformers
      }:
      mkDerivation {
        pname = "ghc-typelits-knownnat";
-       version = "0.7.1";
-       sha256 = "00pfkb6iw4isfmp0jmcqsqyb84xf6b4xnljn3bmax2x8ci9vpm0c";
+       version = "0.7.2";
+       sha256 = "1wdippdn029rpd1v3mk470gyp8v13d2bna8p8q6cn7q7nhm1dhhc";
        libraryHaskellDepends = [
          base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-natnormalise
          template-haskell transformers
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
-  "ghc-typelits-natnormalise_0_7" = callPackage
+  "ghc-typelits-natnormalise_0_7_1" = callPackage
     ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra
-     , integer-gmp, tasty, tasty-hunit, template-haskell, transformers
+     , integer-gmp, syb, tasty, tasty-hunit, template-haskell
+     , transformers
      }:
      mkDerivation {
        pname = "ghc-typelits-natnormalise";
-       version = "0.7";
-       sha256 = "1rfw67hhhka3ga8v3224ain7jvdc390glz5cr7vvxm1yqs1wgwx4";
+       version = "0.7.1";
+       sha256 = "1sbwzbs3bnvyla44kcsxs6h12sdfqzbm6n0swy2scp5p271fr0i3";
        libraryHaskellDepends = [
-         base containers ghc ghc-tcplugins-extra integer-gmp transformers
+         base containers ghc ghc-tcplugins-extra integer-gmp syb
+         transformers
        ];
        testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
        description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
···
      }) {};
 
   "ghc-typelits-presburger" = callPackage
-    ({ mkDerivation, base, containers, equational-reasoning, ghc
-     , ghc-tcplugins-extra, mtl, pretty, reflection, singletons, syb
-     , transformers
+    ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra, mtl
+     , pretty, reflection, syb, transformers
      }:
      mkDerivation {
        pname = "ghc-typelits-presburger";
-       version = "0.2.0.5";
-       sha256 = "03n6ddvn6p1nk6yw141zdw60iqda7k3sbaacc9s04mmnmshvia1n";
+       version = "0.3.0.0";
+       sha256 = "1jahwmy2cywnnlvrjizak1wqih7pki9r35qazcz7mih68pd9gnhz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers equational-reasoning ghc ghc-tcplugins-extra mtl
-         pretty reflection singletons syb transformers
+         base containers ghc ghc-tcplugins-extra mtl pretty reflection syb
+         transformers
        ];
        description = "Presburger Arithmetic Solver for GHC Type-level natural numbers";
        license = stdenv.lib.licenses.bsd3;
···
      , haddock-library, hashable, haskell-lsp, haskell-lsp-types
      , hie-bios, hslogger, lens, lsp-test, mtl, network-uri
      , optparse-applicative, parser-combinators, prettyprinter
-     , prettyprinter-ansi-terminal, regex-tdfa, rope-utf16-splay
-     , safe-exceptions, shake, sorted-list, stm, syb, tasty
-     , tasty-expected-failure, tasty-hunit, text, time, transformers
-     , unix, unordered-containers, utf8-string
+     , prettyprinter-ansi-terminal, QuickCheck, quickcheck-instances
+     , regex-tdfa, rope-utf16-splay, safe-exceptions, shake, sorted-list
+     , stm, syb, tasty, tasty-expected-failure, tasty-hunit
+     , tasty-quickcheck, text, time, transformers, unix
+     , unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "0.0.6";
-       sha256 = "1vp0x4z0444zz8zaibk1r8lb0xjymdqpagm87xsf3csbzkqfhsjb";
+       version = "0.1.0";
+       sha256 = "0yb8k64wnm9dx93925ddlwy8kimd6a44m9azs9d5x6nahigi406m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [
          aeson base bytestring containers directory extra filepath ghc
-         ghc-typelits-knownnat haskell-lsp-types lens lsp-test
-         parser-combinators tasty tasty-expected-failure tasty-hunit text
+         ghc-typelits-knownnat haddock-library haskell-lsp haskell-lsp-types
+         lens lsp-test parser-combinators QuickCheck quickcheck-instances
+         rope-utf16-splay tasty tasty-expected-failure tasty-hunit
+         tasty-quickcheck text
        ];
        description = "The core of an IDE";
        license = stdenv.lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "7.20191230";
-       sha256 = "1xsd4vhiv3zkcqjh2pxhbkjx75hcalcc9bpdlfc27wzxsxyrwz12";
+       version = "7.20200204";
+       sha256 = "09jf3hbi8gvv0zwyhyyidc3mqjz9p4ji3wg9kh4f0hgx5vcwzsms";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-f-networkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
      }:
      mkDerivation {
        pname = "git-brunch";
-       version = "1.1.0.0";
-       sha256 = "0nkyq5bgq6mc27j4qrydwjyb8zhhgiyjdbpk9d1xfb0z4c817131";
+       version = "1.1.2.0";
+       sha256 = "02swvnwa5iqnrsw6r709qxy1hjp7df4i0qlhkqhshfdva6xy3376";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "graphviz";
-       version = "2999.20.0.3";
-       sha256 = "04k26zw61nfv1pkd00iaq89pgsaiym0sf4cbzkmm2k2fj5xa587g";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring colour containers directory dlist fgl filepath mtl
-         polyparse process temporary text wl-pprint-text
-       ];
-       testHaskellDepends = [
-         base containers fgl fgl-arbitrary filepath hspec QuickCheck text
-       ];
-       testSystemDepends = [ graphviz ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [ base criterion deepseq text ];
-       description = "Bindings to Graphviz for graph visualisation";
-       license = stdenv.lib.licenses.bsd3;
-     }) {inherit (pkgs) graphviz;};
-
-  "graphviz_2999_20_0_4" = callPackage
-    ({ mkDerivation, base, bytestring, colour, containers, criterion
-     , deepseq, directory, dlist, fgl, fgl-arbitrary, filepath, graphviz
-     , hspec, hspec-discover, mtl, polyparse, process, QuickCheck
-     , temporary, text, wl-pprint-text
-     }:
-     mkDerivation {
-       pname = "graphviz";
        version = "2999.20.0.4";
        sha256 = "047f6sa5rp0f2npgvdrj5irylh0raf01a6nrjj2vsf1mzb1q83xr";
        isLibrary = true;
···
        benchmarkHaskellDepends = [ base criterion deepseq text ];
        description = "Bindings to Graphviz for graph visualisation";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) graphviz;};
 
   "graql" = callPackage
···
      }:
      mkDerivation {
        pname = "hackport";
-       version = "0.6.3";
-       sha256 = "1bj4jafr81xl2dvc8ym29dnp9vmbv7njaqkkfypzvm0ws09mcvh1";
+       version = "0.6.4";
+       sha256 = "185b2mincqzla8j675lv4ydi8fvsj3ikyq4g8jivygbkcpawi5f5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        testHaskellDepends = [
          array base binary bytestring containers deepseq directory
          extensible-exceptions filepath HUnit parsec pretty process split
-         time unix xml
+         text time transformers unix xml
        ];
        description = "Hackage and Portage integration tool";
        license = "GPL";
···
      }:
      mkDerivation {
        pname = "haeredes";
-       version = "0.5.1";
-       sha256 = "1y4r487z2k6l7xi5bi1rb3rz0i7yki2j2mmpnpfdy2bba1s51a6n";
+       version = "0.5.2";
+       sha256 = "0qqz22aghl00hy240hvws3sgaw2jvhqicms0c1y76b68af1dlkyh";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          base bytestring cmdargs dns iproute parallel-io
        ];
-       testHaskellDepends = [
-         base bytestring cmdargs dns doctest filemanip iproute parallel-io
-         process
-       ];
+       testHaskellDepends = [ base doctest filemanip process ];
        description = "Confirm delegation of NS and MX records";
        license = stdenv.lib.licenses.agpl3;
      }) {};
···
     ({ mkDerivation, base, containers, random }:
      mkDerivation {
        pname = "hanabi-dealer";
-       version = "0.4.0.1";
-       sha256 = "1baxmy5lz8w8yjnaslzrmpnwx7rgqixkwbkzfb034024wlb9w0am";
+       version = "0.5.0.0";
+       sha256 = "01dhx6il56pvl9iwaxylyy4sg2gs67w2sr6svahx32lbrnyxnkp8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers random ];
···
      }) {};
 
   "happy-meta" = callPackage
-    ({ mkDerivation, array, base, containers, happy, haskell-src-meta
-     , mtl, template-haskell
+    ({ mkDerivation, array, base, containers, fail, happy
+     , haskell-src-meta, mtl, template-haskell
      }:
      mkDerivation {
        pname = "happy-meta";
-       version = "0.2.0.9";
-       sha256 = "1w3bmwnsg9714kyqxzfrbw0az4i2dqprn2hms3kbdq5984yhi9bg";
-       revision = "1";
-       editedCabalFile = "1mq8gdq11bqgii498as0078pf8s1mnawh4rvys6hjnd77iaf9nfk";
+       version = "0.2.0.10";
+       sha256 = "1w6shcydpca5g9dgnki0w2xqr9mf17xa18s8hxxm3z3dd0sp1db9";
        libraryHaskellDepends = [
-         array base containers haskell-src-meta mtl template-haskell
+         array base containers fail haskell-src-meta mtl template-haskell
        ];
        libraryToolDepends = [ happy ];
        description = "Quasi-quoter for Happy parsers";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "haskell-lsp_0_19_0_0" = callPackage
+  "haskell-lsp_0_20_0_1" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , containers, data-default, directory, filepath, hashable
      , haskell-lsp-types, hslogger, hspec, hspec-discover, lens, mtl
···
      }:
      mkDerivation {
        pname = "haskell-lsp";
-       version = "0.19.0.0";
-       sha256 = "0cjmjrcd3rg8jc6rfk73jirmvay07jps9gdjd97clxz90w3mm24i";
+       version = "0.20.0.1";
+       sha256 = "1yy9j61hlar4y8p58q8a0i3c6qmv5h9f53kk48jsvfa59c3dz92b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [
          aeson base bytestring containers data-default directory filepath
          hashable hspec lens network-uri QuickCheck quickcheck-instances
-         rope-utf16-splay sorted-list stm text
+         rope-utf16-splay sorted-list stm text unordered-containers
        ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell library for the Microsoft Language Server Protocol";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "haskell-lsp-types_0_19_0_0" = callPackage
+  "haskell-lsp-types_0_20_0_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, data-default, deepseq
      , filepath, hashable, lens, network-uri, scientific, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "haskell-lsp-types";
-       version = "0.19.0.0";
-       sha256 = "089rxcdz02hq68ihc26r7dwsn8hl7f7096vcb0dyd2jda0ganhm9";
+       version = "0.20.0.0";
+       sha256 = "09p0d4vibrm06kj8i1yq9zhnkxl87yg5085l1sy9m20z8j988waq";
        libraryHaskellDepends = [
          aeson base bytestring data-default deepseq filepath hashable lens
          network-uri scientific text unordered-containers
···
      }:
      mkDerivation {
        pname = "hasql-th";
-       version = "0.4.0.3";
-       sha256 = "0j850460d2sz6zwvawyv9913b03iqf58b737y6imgd6k7ddq82hn";
+       version = "0.4.0.4";
+       sha256 = "1kd12vw98wml58sp1dqfq58z0vjjqdssb6q7f6ngs7q6ig27kxfb";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers contravariant
          fast-builder foldl hashable hasql headed-megaparsec megaparsec
···
        pname = "hblas";
        version = "0.4.0.1";
        sha256 = "1jclawfvykdsd5b5wmqyz6fb0kx6yr626w4g86w9q1127k8l102k";
+       revision = "1";
+       editedCabalFile = "0085hyl5hcnxjf83vis34qklv6xajsk5z0mzrirgp03nzyf55l7r";
        libraryHaskellDepends = [ base primitive storable-complex vector ];
        librarySystemDepends = [ blas liblapack ];
        testHaskellDepends = [ base hspec primitive vector ];
···
        pname = "hedgehog";
        version = "1.0.2";
        sha256 = "1058d5fcv3hhvlx34a8xkg8r75p93l2yhacdbga8d4radiayy34f";
-       revision = "1";
-       editedCabalFile = "0rcga61rs098y4h44d5144qa7ismibvb44vw97ykazmz5yfg1n9l";
+       revision = "2";
+       editedCabalFile = "1qh7yaijp04li1i10cd5j6bc58fcagynxxmvs32wc8m1fvgzi05w";
        libraryHaskellDepends = [
          ansi-terminal async base bytestring concurrent-output containers
          directory erf exceptions fail lifted-async mmorph monad-control mtl
···
        broken = true;
      }) {};
 
+  "hedis-envy" = callPackage
+    ({ mkDerivation, base, envy, hedis, scientific, time }:
+     mkDerivation {
+       pname = "hedis-envy";
+       version = "0.1.0.1";
+       sha256 = "165a7pw1i1i9gxljmx03zavza5qjyir09bwk067cfr5an9razvq6";
+       libraryHaskellDepends = [ base envy hedis scientific time ];
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hedis-monadic" = callPackage
     ({ mkDerivation, base, hedis, monad-control, mtl, transformers
      , transformers-base, transformers-compat
···
      }:
      mkDerivation {
        pname = "heredocs";
-       version = "0.1.5";
-       sha256 = "1bmih3jwmx8dv128rb9w1682fp3w0f6i7hhyyakswy7a04q34ryi";
+       version = "0.1.6";
+       sha256 = "12qsa6vcdc255dx7dc4nfmgy3aam7w6qy92x4811mxx4mxrsr81r";
        libraryHaskellDepends = [
          base bytestring doctest parsec template-haskell text
        ];
···
      }) {};
 
   "hie-bios" = callPackage
-    ({ mkDerivation, base, base16-bytestring, bytestring, conduit
-     , conduit-extra, containers, cryptohash-sha1, deepseq, directory
-     , extra, file-embed, filepath, ghc, hslogger, process, tasty
-     , tasty-hunit, temporary, text, time, transformers, unix-compat
-     , unordered-containers, vector, yaml
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , conduit, conduit-extra, containers, cryptohash-sha1, deepseq
+     , directory, extra, file-embed, filepath, ghc, hslogger, process
+     , tasty, tasty-hunit, temporary, text, time, transformers
+     , unix-compat, unordered-containers, vector, yaml
      }:
      mkDerivation {
        pname = "hie-bios";
-       version = "0.3.2";
-       sha256 = "1609rvjgh1laqxl4c1bh0j3bq5yysbbaflx6hn8npr0ckq2ckvir";
+       version = "0.4.0";
+       sha256 = "1pa8wjj6sml39371f355z46304jzzwpcr62q0qzrpqq8w9017241";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base base16-bytestring bytestring conduit conduit-extra containers
-         cryptohash-sha1 deepseq directory extra file-embed filepath ghc
-         hslogger process temporary text time transformers unix-compat
-         unordered-containers vector yaml
+         aeson base base16-bytestring bytestring conduit conduit-extra
+         containers cryptohash-sha1 deepseq directory extra file-embed
+         filepath ghc hslogger process temporary text time transformers
+         unix-compat unordered-containers vector yaml
        ];
        executableHaskellDepends = [ base directory filepath ghc ];
        testHaskellDepends = [
-         base directory filepath ghc tasty tasty-hunit
+         base directory extra filepath ghc tasty tasty-hunit text
+         unordered-containers yaml
        ];
        description = "Set up a GHC API session";
        license = stdenv.lib.licenses.bsd3;
···
        license = "(BSD-2-Clause OR Apache-2.0)";
      }) {};
 
-  "hkd-default" = callPackage
-    ({ mkDerivation, aeson, base }:
-     mkDerivation {
-       pname = "hkd-default";
-       version = "1.1.0.0";
-       sha256 = "1ff8sfd68a06s7kfc85ww6w5wm7m0f70vd2bi0lbkj0r14rsn7vg";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ aeson base ];
-       description = "Apply default value for optional field of HKD";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
   "hkd-delta" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hledger-flow";
-       version = "0.12.4.0";
-       sha256 = "1j5hhh06xrdzdpzvvk8gg2mzhsmyk9xvxbpvjy0sg3mmpa27vr6f";
+       version = "0.13.0.0";
+       sha256 = "0lgjb35mpjnyqdc4lr5g2q88nhjbh4znkw9xmlc7vlf1bpa27a8a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hlint";
-       version = "2.2.9";
-       sha256 = "1six65y2x89q4a1kz5vm3pcjpwpp423h8nzp6kjka6cm5hn5ahdp";
+       version = "2.2.10";
+       sha256 = "1zna80g34zzxz0cazg0w3cqx2cmlvzd82ajyhypwp9anbc10l7h4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hoauth2_1_10_2" = callPackage
+  "hoauth2_1_11_0" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, exceptions
      , http-conduit, http-types, microlens, text, unordered-containers
      , uri-bytestring, uri-bytestring-aeson
      }:
      mkDerivation {
        pname = "hoauth2";
-       version = "1.10.2";
-       sha256 = "04kdz01pg32p1ci9rqnkkbk2ch6bgyqq9v7cbfpdxqp0hyfhv2jl";
+       version = "1.11.0";
+       sha256 = "0pf558n93gqksfgsjlvwcly2lq86adkcbqjqsq4p73kwwzs6dka8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "hpc-codecov" = callPackage
+    ({ mkDerivation, array, base, bytestring, directory, filepath, hpc
+     , tar, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "hpc-codecov";
+       version = "0.1.0.0";
+       sha256 = "1kr245qsdq60lvg1y9krpd19z9svwi2w9843b39hbv9fxzs7zcia";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring directory filepath hpc
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base directory filepath tar tasty tasty-hunit
+       ];
+       description = "Generate codecov report from hpc data";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hpc-coveralls" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, Cabal, cmdargs
      , containers, curl, directory, directory-tree, hpc, HUnit, process
···
      }:
      mkDerivation {
        pname = "hpqtypes";
-       version = "1.8.0.0";
-       sha256 = "07n4w2ylmx1swdqvd1hbrh2bch6qx54vxdzw0px6n0b01nadn2gr";
+       version = "1.8.0.1";
+       sha256 = "1zn6qzpxvpdiim12lma7viq96j3jadvlcw188iknjqyn15kri9my";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          aeson async base bytestring containers exceptions lifted-base
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.10.1.0";
-       sha256 = "13ja18jk0w3c9jzys72fddpgx74cr4p5bap6l0jckb61wbj1m6zl";
+       version = "1.10.2.0";
+       sha256 = "16x7innivjrnsamn6lrjg1a2v0wy1w6r3ariw3ncrwfpcfdmr45n";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          fields-json hpqtypes lifted-base log-base monad-control mtl safe
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Create ATS types from Haskell types";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "hs2bf" = callPackage
···
        broken = true;
      }) {};
 
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+  "hw-balancedparens_0_3_0_4" = callPackage
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
···
      }:
      mkDerivation {
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-       version = "0.3.0.3";
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+       version = "0.3.0.4";
+       sha256 = "1f25czr55c8fsb1l2ljfr93x2fp888g78ngf45xampnr6m3468j3";
        libraryHaskellDepends = [
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
···
      }:
      mkDerivation {
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-       version = "0.2.2.2";
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+       version = "0.2.2.3";
+       sha256 = "1rlw53nbhjdvjqb1f0kacnmiiwhx04az6p4mf0iv5fwxcjh94q2r";
        libraryHaskellDepends = [
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
        ];
···
        broken = true;
      }) {};
 
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+  "hw-rankselect_0_13_3_2" = callPackage
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+     , directory, doctest, doctest-discover, generic-lens, hedgehog
+     , hspec, hspec-discover, hw-balancedparens, hw-bits, hw-fingertree
+     , hw-hedgehog, hw-hspec-hedgehog, hw-prim, hw-rankselect-base, lens
+     , mmap, mtl, optparse-applicative, QuickCheck, resourcet
+     , transformers, vector
      }:
      mkDerivation {
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-       version = "0.13.3.1";
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+       version = "0.13.3.2";
+       sha256 = "1p4b5nm8mgxlc7p5gcwh6dy85xgydpbw999zv27755dbfcv9nk4v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
        ];
        testHaskellDepends = [
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
+         base directory doctest doctest-discover hedgehog hspec hw-bits
+         hw-hedgehog hw-hspec-hedgehog hw-prim hw-rankselect-base mmap
+         QuickCheck transformers vector
        ];
-       testToolDepends = [ hspec-discover ];
+       testToolDepends = [ doctest-discover hspec-discover ];
        benchmarkHaskellDepends = [
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
      , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
···
      }:
      mkDerivation {
        pname = "json-feed";
-       version = "1.0.7";
-       sha256 = "0rjszis4l0sb15v2gjiwnq6avl4bkqp186v449ms4qwbbqz11sc7";
-       libraryHaskellDepends = [
-         aeson base bytestring mime-types network-uri tagsoup text time
-       ];
-       testHaskellDepends = [
-         aeson base bytestring filepath hspec mime-types network-uri tagsoup
-         text time
-       ];
-       description = "JSON Feed";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "json-feed_1_0_8" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, filepath, hspec
-     , mime-types, network-uri, tagsoup, text, time
-     }:
-     mkDerivation {
-       pname = "json-feed";
        version = "1.0.8";
        sha256 = "1sagnnk73510vxdhqr2798k1s00jcsp6yfb689fpar360vfzwssm";
        libraryHaskellDepends = [
···
        ];
        description = "JSON Feed";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "json-fu" = callPackage
···
      }) {};
 
   "kanji" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, containers, criterion
-     , deepseq, hashable, HUnit-approx, microlens, microlens-aeson
-     , optparse-applicative, tasty, tasty-hunit, text, transformers
-     }:
-     mkDerivation {
-       pname = "kanji";
-       version = "3.4.0.2";
-       sha256 = "017j8nwmwfbkxyaxjfp75js578kv6g5k7szsc46kidbw4l68dwmy";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base containers deepseq hashable text
-       ];
-       executableHaskellDepends = [
-         aeson aeson-pretty base containers microlens microlens-aeson
-         optparse-applicative text transformers
-       ];
-       testHaskellDepends = [
-         aeson base containers HUnit-approx tasty tasty-hunit text
-       ];
-       benchmarkHaskellDepends = [ aeson base containers criterion text ];
-       description = "Perform 漢字検定 (Japan Kanji Aptitude Test) level analysis on Japanese Kanji";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "kanji_3_4_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, containers, criterion
      , deepseq, hashable, HUnit-approx, microlens, microlens-aeson
      , optparse-applicative, tasty, tasty-hunit, text, transformers
···
        benchmarkHaskellDepends = [ aeson base containers criterion text ];
        description = "Perform 漢字検定 (Japan Kanji Aptitude Test) level analysis on Japanese Kanji";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "kansas-comet" = callPackage
···
      }:
      mkDerivation {
        pname = "keys";
-       version = "3.12.2";
-       sha256 = "1mw4c0dd21hmzhidf84p6fxrin7k05l2iz8iar3m7k5vbxihlldj";
-       revision = "1";
-       editedCabalFile = "1cx5bwd32mpqdgllrkld254a8ydks196m3j9dvm3razg8mxnz2x6";
-       libraryHaskellDepends = [
-         array base comonad containers free hashable semigroupoids
-         semigroups tagged transformers transformers-compat
-         unordered-containers
-       ];
-       description = "Keyed functors and containers";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "keys_3_12_3" = callPackage
-    ({ mkDerivation, array, base, comonad, containers, free, hashable
-     , semigroupoids, semigroups, tagged, transformers
-     , transformers-compat, unordered-containers
-     }:
-     mkDerivation {
-       pname = "keys";
        version = "3.12.3";
        sha256 = "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm";
        libraryHaskellDepends = [
···
        ];
        description = "Keyed functors and containers";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "keysafe" = callPackage
···
        broken = true;
      }) {};
 
+  "kubernetes-webhook-haskell" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
+     , text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "kubernetes-webhook-haskell";
+       version = "0.2.0.0";
+       sha256 = "0yxavjq6xxia81yfw7skgdmirbq0wmlvbsklppq6a6y1m6drbyww";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring binary bytestring text
+         unordered-containers
+       ];
+       description = "Create Kubernetes Admission Webhooks in Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "kuifje" = callPackage
     ({ mkDerivation, base, boxes, containers, lens }:
      mkDerivation {
···
     ({ mkDerivation, base, hspec, servant, servant-foreign, text }:
      mkDerivation {
        pname = "lackey";
-       version = "1.0.10";
-       sha256 = "13nvrsw29l25ysln0di0bd5lrwnwwp0mkwvymdgf2kc2jg7x46dj";
-       libraryHaskellDepends = [ base servant servant-foreign text ];
-       testHaskellDepends = [ base hspec servant servant-foreign text ];
-       description = "Generate Ruby clients from Servant APIs";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "lackey_1_0_11" = callPackage
-    ({ mkDerivation, base, hspec, servant, servant-foreign, text }:
-     mkDerivation {
-       pname = "lackey";
        version = "1.0.11";
        sha256 = "0sch6xpmkb3941bfv7g3qjvgsm9z74ra4z24y22j8w264naag601";
        libraryHaskellDepends = [ base servant servant-foreign text ];
        testHaskellDepends = [ base hspec servant servant-foreign text ];
        description = "Generate Ruby clients from Servant APIs";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "lacroix" = callPackage
···
     ({ mkDerivation, alex, ansi-wl-pprint, array, base
      , composition-prelude, containers, criterion, deepseq, happy, hspec
      , hspec-dirstream, microlens, recursion, system-filepath
-     , transformers
+     , these-skinny, transformers
      }:
      mkDerivation {
        pname = "language-ats";
-       version = "1.7.7.0";
-       sha256 = "17p0wv3zbs8jj9jdcc6cg0g5snfyj418mx4b5299wddr5s99jmfi";
+       version = "1.7.7.1";
+       sha256 = "13d1hna3kgvyfihjn3639j8i1drpw65j3ksb5zh3dqi999ia6zs2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          ansi-wl-pprint array base composition-prelude containers deepseq
-         microlens recursion transformers
+         microlens recursion these-skinny transformers
        ];
        libraryToolDepends = [ alex happy ];
        testHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion ];
        description = "Parser and pretty-printer for ATS";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "language-avro" = callPackage
+    ({ mkDerivation, avro, base, filepath, hspec, megaparsec, text
+     , vector
+     }:
+     mkDerivation {
+       pname = "language-avro";
+       version = "0.1.0.0";
+       sha256 = "1nns0qlzrcmlfivv2p4qdhni6ngx3r0926z6kmybmqi3jk7wibhw";
+       libraryHaskellDepends = [
+         avro base filepath megaparsec text vector
+       ];
+       testHaskellDepends = [ avro base hspec megaparsec text vector ];
+       description = "Language definition and parser for AVRO files";
+       license = stdenv.lib.licenses.asl20;
      }) {};
 
   "language-bash" = callPackage
···
     ({ mkDerivation, base, megaparsec, text }:
      mkDerivation {
        pname = "language-protobuf";
-       version = "1.0";
-       sha256 = "1qg9c862srf7klcan53sa92ylnfx6xz8b1jqgw6rmpznfsw4h2c8";
+       version = "1.0.1";
+       sha256 = "1wxihyf320xsqi114dbl2cwylkc261d5wgd7migb1lh23gxnhhz2";
        libraryHaskellDepends = [ base megaparsec text ];
        description = "Language definition and parser for Protocol Buffers";
        license = stdenv.lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "language-puppet";
-       version = "1.4.6.1";
-       sha256 = "0w1ffflnzlcwfc4zhn1zlrdhapdniy67wy0z2pa6qgkvxv52rlxd";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson ansi-wl-pprint attoparsec base base16-bytestring bytestring
-         case-insensitive containers cryptonite directory filecache filepath
-         formatting hashable hruby hslogger http-api-data http-client lens
-         lens-aeson megaparsec memory mtl operational parsec
-         parser-combinators pcre-utils protolude random regex-pcre-builtin
-         scientific servant servant-client split stm strict-base-types text
-         time transformers unix unordered-containers vector yaml
-       ];
-       executableHaskellDepends = [
-         aeson ansi-wl-pprint async base bytestring containers Glob hslogger
-         http-client lens mtl optparse-applicative regex-pcre-builtin
-         strict-base-types text transformers unordered-containers vector
-         yaml
-       ];
-       testHaskellDepends = [
-         base Glob hslogger hspec hspec-megaparsec lens megaparsec mtl
-         pcre-utils scientific strict-base-types temporary text transformers
-         unordered-containers vector
-       ];
-       description = "Tools to parse and evaluate the Puppet DSL";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "language-puppet_1_4_6_2" = callPackage
-    ({ mkDerivation, aeson, ansi-wl-pprint, async, attoparsec, base
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     , cryptonite, directory, filecache, filepath, formatting, Glob
-     , hashable, hruby, hslogger, hspec, hspec-megaparsec, http-api-data
-     , http-client, lens, lens-aeson, megaparsec, memory, mtl
-     , operational, optparse-applicative, parsec, parser-combinators
-     , pcre-utils, protolude, random, regex-pcre-builtin, scientific
-     , servant, servant-client, split, stm, strict-base-types, temporary
-     , text, time, transformers, unix, unordered-containers, vector
-     , yaml
-     }:
-     mkDerivation {
-       pname = "language-puppet";
        version = "1.4.6.2";
        sha256 = "07rv00rpxza9pg0jg19bh5pnk065mxadb7qcxw5i822ad22b85yn";
        isLibrary = true;
···
        ];
        description = "Tools to parse and evaluate the Puppet DSL";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "language-python" = callPackage
···
        broken = true;
      }) {};
 
+  "laop" = callPackage
+    ({ mkDerivation, base, deepseq }:
+     mkDerivation {
+       pname = "laop";
+       version = "0.1.0.3";
+       sha256 = "0fhn7gl2mfm14bmqvay8wrzqcszgnh94byxr065hsxy2zq6kmyc6";
+       libraryHaskellDepends = [ base deepseq ];
+       testHaskellDepends = [ base deepseq ];
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "lapack" = callPackage
     ({ mkDerivation, base, blas-ffi, blaze-html, boxes, ChasingBottoms
      , comfort-array, data-ref, deepseq, fixed-length
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
-  "lens_4_18_1" = callPackage
-    ({ mkDerivation, array, base, base-orphans, bifunctors, bytestring
-     , Cabal, cabal-doctest, call-stack, comonad, containers
+  "lens_4_19" = callPackage
+    ({ mkDerivation, array, base, base-compat, base-orphans, bifunctors
+     , bytestring, Cabal, cabal-doctest, call-stack, comonad, containers
      , contravariant, criterion, deepseq, directory, distributive
      , doctest, exceptions, filepath, free, generic-deriving, ghc-prim
      , hashable, HUnit, kan-extensions, mtl, nats, parallel, profunctors
      , QuickCheck, reflection, semigroupoids, semigroups, simple-reflect
      , tagged, template-haskell, test-framework, test-framework-hunit
      , test-framework-quickcheck2, test-framework-th, text
-     , th-abstraction, transformers, transformers-compat, type-equality
+     , th-abstraction, transformers, transformers-compat
      , unordered-containers, vector
      }:
      mkDerivation {
        pname = "lens";
-       version = "4.18.1";
-       sha256 = "1lmxjaj32v06l12gy00rpjp2lk1cblh3k7kwklk655ss2vas61ri";
+       version = "4.19";
+       sha256 = "1696835nvzfgvkwrhka2lmjbq08dhkqpcp9iqj5ws7bws7ja3xaf";
        setupHaskellDepends = [ base Cabal cabal-doctest filepath ];
        libraryHaskellDepends = [
          array base base-orphans bifunctors bytestring call-stack comonad
          containers contravariant distributive exceptions filepath free
          ghc-prim hashable kan-extensions mtl parallel profunctors
          reflection semigroupoids tagged template-haskell text
-         th-abstraction transformers transformers-compat type-equality
+         th-abstraction transformers transformers-compat
          unordered-containers vector
        ];
        testHaskellDepends = [
···
          unordered-containers vector
        ];
        benchmarkHaskellDepends = [
-         base bytestring comonad containers criterion deepseq
+         base base-compat bytestring comonad containers criterion deepseq
          generic-deriving transformers unordered-containers vector
        ];
        description = "Lenses, Folds and Traversals";
···
        license = stdenv.lib.licenses.bsd2;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
+     }) {};
+
+  "lens-csv" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, lens }:
+     mkDerivation {
+       pname = "lens-csv";
+       version = "0.1.0.0";
+       sha256 = "1sfglf9g6ac14f85bjabbmvjijrd76asm8kzbrlvkzvv7bhiw8sk";
+       libraryHaskellDepends = [ base bytestring cassava lens ];
+       testHaskellDepends = [ base bytestring cassava lens ];
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "lens-datetime" = callPackage
···
      }:
      mkDerivation {
        pname = "libmpd";
-       version = "0.9.0.10";
-       sha256 = "0vy287mn1vk8kvij5i3hc0p02l886cpsq5dds7kl6g520si3abkb";
-       libraryHaskellDepends = [
-         attoparsec base bytestring containers data-default-class filepath
-         mtl network old-locale safe-exceptions text time utf8-string
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring containers data-default-class filepath
-         hspec mtl network old-locale QuickCheck safe-exceptions text time
-         unix utf8-string
-       ];
-       description = "An MPD client library";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "libmpd_0_9_1_0" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
-     , data-default-class, filepath, hspec, mtl, network, old-locale
-     , QuickCheck, safe-exceptions, text, time, unix, utf8-string
-     }:
-     mkDerivation {
-       pname = "libmpd";
        version = "0.9.1.0";
        sha256 = "1f1svf4dxpbqmxkq1nc11nyfm68wrh00v2wf68yzfwc6win2jhfr";
        libraryHaskellDepends = [
···
        ];
        description = "An MPD client library";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "libnix" = callPackage
···
     ({ mkDerivation, base, bytestring, conduit, resourcet }:
      mkDerivation {
        pname = "libyaml";
-       version = "0.1.1.1";
-       sha256 = "0qjq0w8gqzzg3lf53mg9avkdd6z609kaacyyzjz0rbjjks4gl1db";
+       version = "0.1.2";
+       sha256 = "1dcpbsjg6n305l07isxmavgp01lbv1qggy16acjyxjlz35pxchlg";
        libraryHaskellDepends = [ base bytestring conduit resourcet ];
        description = "Low-level, streaming YAML interface";
        license = stdenv.lib.licenses.bsd3;
···
 
   "lightstep-haskell" = callPackage
     ({ mkDerivation, async, base, bytestring, chronos, containers
-     , http-types, http2-client, http2-client-grpc
+     , deepseq, hashable, http-types, http2-client, http2-client-grpc
      , http2-grpc-proto-lens, lens, mtl, proto-lens
      , proto-lens-protobuf-types, proto-lens-runtime, random
-     , safe-exceptions, stm, text, transformers, unordered-containers
-     , wai
+     , safe-exceptions, stm, tasty, tasty-discover, tasty-hunit
+     , tasty-quickcheck, text, transformers, unordered-containers, wai
      }:
      mkDerivation {
        pname = "lightstep-haskell";
-       version = "0.5.2";
-       sha256 = "0j4dlvw4hhbawwfaxfqmh2bmhqha7902rainvbwi1xw2v73pqwdg";
+       version = "0.6.1";
+       sha256 = "0c3z44wnx67k7n7gw8zs35g79al76fbjk6z20fpvjhmk49gsaspk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         async base bytestring chronos containers http-types http2-client
-         http2-client-grpc http2-grpc-proto-lens lens mtl proto-lens
-         proto-lens-protobuf-types proto-lens-runtime random safe-exceptions
-         stm text transformers unordered-containers wai
+         async base bytestring chronos containers hashable http-types
+         http2-client http2-client-grpc http2-grpc-proto-lens lens mtl
+         proto-lens proto-lens-protobuf-types proto-lens-runtime random
+         safe-exceptions stm text transformers unordered-containers wai
        ];
        executableHaskellDepends = [ async base text ];
+       testHaskellDepends = [
+         base deepseq lens proto-lens proto-lens-protobuf-types
+         proto-lens-runtime tasty tasty-discover tasty-hunit
+         tasty-quickcheck
+       ];
+       testToolDepends = [ tasty-discover ];
        description = "LightStep OpenTracing client library";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
 
   "line-bot-sdk" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, base64-bytestring
-     , bytestring, cryptohash-sha256, errors, exceptions, free, hspec
+     , bytestring, cryptohash-sha256, deepseq, free, hspec
      , hspec-expectations, hspec-wai, http-api-data, http-client
-     , http-client-tls, http-types, monad-control, mtl, scientific
-     , servant, servant-client, servant-client-core, servant-server
-     , streaming, string-conversions, text, time, transformers
-     , transformers-base, wai, wai-extra, warp
+     , http-client-tls, http-media, http-types, mtl, scientific, servant
+     , servant-client, servant-client-core, servant-server
+     , string-conversions, text, time, transformers, wai, wai-extra
+     , warp
      }:
      mkDerivation {
        pname = "line-bot-sdk";
-       version = "0.5.0.2";
-       sha256 = "0b33z5h22mbzxa812phpi73nmilzyvdslh355802wv625br3ljq5";
+       version = "0.5.2";
+       sha256 = "1vrfq9v8lv5nwdmy7n99p7dnm10b35ng5n24ncjq54i0ci2ldi75";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base base64-bytestring bytestring cryptohash-sha256 errors
-         exceptions http-api-data http-client http-client-tls http-types
-         monad-control mtl scientific servant servant-client
-         servant-client-core servant-server streaming string-conversions
-         text time transformers transformers-base wai wai-extra
+         aeson base base64-bytestring bytestring cryptohash-sha256 deepseq
+         http-api-data http-client http-client-tls http-media http-types mtl
+         scientific servant servant-client servant-client-core
+         servant-server string-conversions text time transformers wai
        ];
        executableHaskellDepends = [
-         base servant servant-client servant-server time transformers wai
-         wai-extra warp
+         base servant servant-server transformers wai wai-extra warp
        ];
        testHaskellDepends = [
          aeson aeson-qq base base64-bytestring bytestring cryptohash-sha256
-         free hspec hspec-expectations hspec-wai http-client http-types
-         servant servant-client servant-client-core servant-server text time
-         transformers wai warp
+         deepseq free hspec hspec-expectations hspec-wai http-client
+         http-types servant servant-client servant-client-core
+         servant-server text time transformers wai warp
        ];
        description = "Haskell SDK for LINE Messaging API";
        license = stdenv.lib.licenses.bsd3;
···
        ];
        description = "Linear Algebra";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "linear_1_21" = callPackage
+    ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes
+     , bytestring, Cabal, cabal-doctest, cereal, containers, deepseq
+     , distributive, doctest, ghc-prim, hashable, HUnit, lens, random
+     , reflection, semigroupoids, semigroups, simple-reflect, tagged
+     , template-haskell, test-framework, test-framework-hunit
+     , transformers, transformers-compat, unordered-containers, vector
+     , void
+     }:
+     mkDerivation {
+       pname = "linear";
+       version = "1.21";
+       sha256 = "1i00j740fpxrbdy1kjzwjxqixk975rd0dh6jxk0da622spabym5a";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         adjunctions base base-orphans binary bytes cereal containers
+         deepseq distributive ghc-prim hashable lens random reflection
+         semigroupoids semigroups tagged template-haskell transformers
+         transformers-compat unordered-containers vector void
+       ];
+       testHaskellDepends = [
+         base binary bytestring deepseq doctest HUnit lens reflection
+         simple-reflect test-framework test-framework-hunit vector
+       ];
+       description = "Linear Algebra";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "linear-accelerate" = callPackage
···
      }:
      mkDerivation {
        pname = "log-elasticsearch";
-       version = "0.10.1.0";
-       sha256 = "10a7p0z9bqjfmc04xvqsflwqrhhnxk72kbhk62sh8l1is0i94vcs";
+       version = "0.10.2.0";
+       sha256 = "0kcixyklnak34v8vmmpw8vpm1mvf3wll6xpcdvfg1c75wc9n1hqy";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bloodhound bytestring
          deepseq http-client http-client-tls log-base semigroups text
···
      }) {};
 
   "log4hs" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, base, bytestring, containers
-     , criterion, data-default, directory, filepath, generic-lens, hspec
-     , hspec-core, lens, mtl, process, QuickCheck, template-haskell
+    ({ mkDerivation, aeson, aeson-default, aeson-qq, base, bytestring
+     , containers, criterion, directory, filepath, generic-lens, hspec
+     , hspec-core, microlens, mtl, process, QuickCheck, template-haskell
      , text, time, vformat, vformat-aeson, vformat-time, yaml
      }:
      mkDerivation {
        pname = "log4hs";
-       version = "0.8.0.0";
-       sha256 = "15a3xz9bg29ci4yfxmn7dhnblz48cf7ijl27fvqgr8j4b3m8z4hn";
+       version = "0.9.0.0";
+       sha256 = "0hr6qm721jlpz6f45rb1d6wh4y5gk0n94a0l9wflwz6vnr77147x";
        libraryHaskellDepends = [
-         aeson base bytestring containers data-default directory filepath
-         generic-lens lens mtl template-haskell text time vformat
+         aeson aeson-default base bytestring containers directory filepath
+         generic-lens microlens mtl template-haskell text time vformat
          vformat-aeson vformat-time yaml
        ];
        testHaskellDepends = [
-         aeson aeson-qq base bytestring containers data-default directory
-         filepath generic-lens hspec hspec-core lens mtl process QuickCheck
-         template-haskell text time vformat vformat-aeson vformat-time yaml
+         aeson aeson-default aeson-qq base bytestring containers directory
+         filepath generic-lens hspec hspec-core microlens mtl process
+         QuickCheck template-haskell text time vformat vformat-aeson
+         vformat-time yaml
        ];
        benchmarkHaskellDepends = [
-         aeson aeson-qq base bytestring containers criterion data-default
-         directory filepath generic-lens lens mtl template-haskell text time
-         vformat vformat-aeson vformat-time yaml
+         aeson aeson-default aeson-qq base bytestring containers criterion
+         directory filepath generic-lens microlens mtl template-haskell text
+         time vformat vformat-aeson vformat-time yaml
        ];
        description = "A python logging style log library";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "logging-effect";
-       version = "1.3.8";
-       sha256 = "0ksavyvcz0c9fadik9yksm4zskzh313srf3713migwrdza5ci5q3";
-       libraryHaskellDepends = [
-         async base exceptions free monad-control mtl prettyprinter
-         semigroups stm stm-delay text time transformers transformers-base
-         unliftio-core
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion fast-logger lifted-async monad-logger
-         prettyprinter text time
-       ];
-       description = "A mtl-style monad transformer for general purpose & compositional logging";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "logging-effect_1_3_9" = callPackage
-    ({ mkDerivation, async, base, bytestring, criterion, exceptions
-     , fast-logger, free, lifted-async, monad-control, monad-logger, mtl
-     , prettyprinter, semigroups, stm, stm-delay, text, time
-     , transformers, transformers-base, unliftio-core
-     }:
-     mkDerivation {
-       pname = "logging-effect";
        version = "1.3.9";
        sha256 = "18g0yw5k0xcpiz3chag61smjc9fi4iy99sv9sqhq8f2v61p355dr";
        libraryHaskellDepends = [
···
        ];
        description = "A mtl-style monad transformer for general purpose & compositional logging";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "logging-effect-extra" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "lsp-test_0_10_0_0" = callPackage
+  "lsp-test_0_10_1_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base
      , bytestring, conduit, conduit-parse, containers, data-default
      , Diff, directory, filepath, haskell-lsp, hspec, lens, mtl
···
      }:
      mkDerivation {
        pname = "lsp-test";
-       version = "0.10.0.0";
-       sha256 = "0fs4zq5xz42jp2x42p8nbswahfb5g0mmdwbrc8i65nx81q6fpxjg";
+       version = "0.10.1.0";
+       sha256 = "1f1ab7gn5bgdlhlayrrrhk6d8iyf971pia6hb23jjyqz9j0vl7ac";
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal async base bytestring conduit
          conduit-parse containers data-default Diff directory filepath
···
        ];
        description = "Bindings to LZ4";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "lz4-conduit" = callPackage
···
 
   "lzlib" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, criterion, directory
-     , filepath, hspec, temporary
+     , filepath, hspec, pathological-bytestrings, temporary
      }:
      mkDerivation {
        pname = "lzlib";
-       version = "0.3.3.0";
-       sha256 = "140m7rivdrak5vcg473gp3ns54xy47k2xyv5z86z2s0ncf204ak6";
+       version = "1.0.1.0";
+       sha256 = "0zajkhck36p4fgy40rsd2zsd3ja7i9fkizwix38xpwdi1ygrfjxf";
        libraryHaskellDepends = [ base bytestring ];
        libraryToolDepends = [ c2hs ];
-       testHaskellDepends = [ base bytestring directory hspec ];
+       testHaskellDepends = [
+         base bytestring directory hspec pathological-bytestrings
+       ];
        benchmarkHaskellDepends = [
          base bytestring criterion filepath temporary
        ];
···
      }:
      mkDerivation {
        pname = "mailbox-count";
-       version = "0.0.2";
-       sha256 = "1zd3vd0sj4pq8nhjn768rpfyn9a06a9c3j2fnhxsb9d800ilpvvf";
+       version = "0.0.5";
+       sha256 = "0g1kbb4pmh1vs8ddswpcmqb9fhfkhlffwp9y7r4dq5wcsdihwm8c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
          tasty-hunit
        ];
        description = "Count mailboxes in a SQL database";
-       license = stdenv.lib.licenses.gpl3;
+       license = stdenv.lib.licenses.agpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "mapalgebra" = callPackage
-    ({ mkDerivation, base, bytestring, containers, criterion, deepseq
-     , hmatrix, HUnit-approx, massiv, massiv-io, QuickCheck, tasty
-     , tasty-hunit, tasty-quickcheck, vector
+    ({ mkDerivation, base, bytestring, containers, deepseq, hmatrix
+     , HUnit-approx, massiv, massiv-io, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck, vector
      }:
      mkDerivation {
        pname = "mapalgebra";
-       version = "0.2.0";
-       sha256 = "1bz4dg7wh66zpghsdb7d7hdqj5413005m3mcfb73gl7xncf21mk5";
+       version = "0.2.1";
+       sha256 = "0ymcbq3mb46qx61zl0yfvbk65lx1cqhshnpwsf8cnwysv3b38vhl";
        libraryHaskellDepends = [
          base bytestring containers deepseq hmatrix massiv massiv-io vector
        ];
        testHaskellDepends = [
          base containers hmatrix HUnit-approx massiv QuickCheck tasty
          tasty-hunit tasty-quickcheck vector
-       ];
-       benchmarkHaskellDepends = [
-         base criterion hmatrix massiv massiv-io vector
        ];
        description = "Efficient, polymorphic Map Algebra";
        license = stdenv.lib.licenses.bsd3;
···
        libraryHaskellDepends = [
          base bytestring data-default-class deepseq directory filepath
          JuicyPixels massiv netpbm process vector
+       ];
+       description = "Import/export of Image files into massiv Arrays";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "massiv-io_0_2_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, cabal-doctest, Color
+     , data-default-class, deepseq, doctest, exceptions, filepath, hspec
+     , JuicyPixels, massiv, massiv-test, netpbm, QuickCheck, random
+     , template-haskell, unliftio, vector
+     }:
+     mkDerivation {
+       pname = "massiv-io";
+       version = "0.2.0.0";
+       sha256 = "1gypn2srqsnzmx1jd28632w34n7z4x5wadi4m7srxdhwk14vqg2m";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base bytestring Color data-default-class deepseq exceptions
+         filepath JuicyPixels massiv netpbm unliftio vector
+       ];
+       testHaskellDepends = [
+         base bytestring doctest hspec JuicyPixels massiv massiv-test
+         QuickCheck random template-haskell
        ];
        description = "Import/export of Image files into massiv Arrays";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
-  "mongoDB_2_6_0_0" = callPackage
+  "mongoDB_2_6_0_1" = callPackage
     ({ mkDerivation, array, base, base16-bytestring, base64-bytestring
      , binary, bson, bytestring, conduit, conduit-extra, containers
      , criterion, cryptohash, data-default-class, dns, fail, hashtables
···
      }:
      mkDerivation {
        pname = "mongoDB";
-       version = "2.6.0.0";
-       sha256 = "14vf47ss02hf50fd3db48jiqhw51q6fpg7ps03kx45ab1cc527kn";
+       version = "2.6.0.1";
+       sha256 = "1kradm8baaqwp4zniy9ga3a3vwqc2gcz21z0559ffja7y4d757my";
        libraryHaskellDepends = [
          array base base16-bytestring base64-bytestring binary bson
          bytestring conduit conduit-extra containers cryptohash
···
 
   "musicScroll" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, dbus, gi-gtk
-     , gi-gtk-hs, gtk3, req, stm, tagsoup, text
+     , gi-gtk-hs, gtk3, mtl, req, stm, tagsoup, text, transformers
      }:
      mkDerivation {
        pname = "musicScroll";
-       version = "0.1.1.0";
-       sha256 = "0f1i3ys1pfylb5igqwkap0k7v47a2c5vfnhc2flxw9h6aim8yh6h";
+       version = "0.1.2.0";
+       sha256 = "0n0s9vkhfwykghniillih5qgdz4cg1rn4vn86hinxaqfgzv6m96w";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         async base bytestring containers dbus gi-gtk gi-gtk-hs req stm
-         tagsoup text
+         async base bytestring containers dbus gi-gtk gi-gtk-hs mtl req stm
+         tagsoup text transformers
        ];
        executableHaskellDepends = [ base ];
        executablePkgconfigDepends = [ gtk3 ];
···
      }) {};
 
   "neat-interpolation" = callPackage
-    ({ mkDerivation, base, base-prelude, HTF, megaparsec
-     , template-haskell, text
+    ({ mkDerivation, base, megaparsec, QuickCheck, quickcheck-instances
+     , rerebase, tasty, tasty-hunit, tasty-quickcheck, template-haskell
+     , text
      }:
      mkDerivation {
        pname = "neat-interpolation";
-       version = "0.3.2.5";
-       sha256 = "09nb0bypjpfxcm71012c2xxfrq5drvd1nhdmnmhk8wc0r8254g8c";
-       libraryHaskellDepends = [
-         base base-prelude megaparsec template-haskell text
+       version = "0.3.2.6";
+       sha256 = "10k5x47i84nycl54p61l8v1bpvi7mw663vnj8nn1qjpn03anz8z2";
+       libraryHaskellDepends = [ base megaparsec template-haskell text ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
        ];
-       testHaskellDepends = [ base-prelude HTF ];
        description = "A quasiquoter for neat and simple multiline text interpolation";
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "neat-interpolation_0_5_1" = callPackage
+    ({ mkDerivation, base, megaparsec, QuickCheck, quickcheck-instances
+     , rerebase, tasty, tasty-hunit, tasty-quickcheck, template-haskell
+     , text
+     }:
+     mkDerivation {
+       pname = "neat-interpolation";
+       version = "0.5.1";
+       sha256 = "0hfyd74f83mxakahgj6q3wy2r1yg1zbsw1750k7zmwaqn3f8gzjz";
+       libraryHaskellDepends = [ base megaparsec template-haskell text ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "A quasiquoter for neat and simple multiline text interpolation";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "needle" = callPackage
     ({ mkDerivation, base, containers, haskell-src-meta, mtl, parsec
      , parsec-extra, template-haskell, text, vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "network-byte-order_0_1_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, doctest }:
+     mkDerivation {
+       pname = "network-byte-order";
+       version = "0.1.4.0";
+       sha256 = "1wm59kdvxcjhsl1y1ajmj8w8nq6qdvin6933n374za39lhkb13f9";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [ base bytestring doctest ];
+       description = "Network byte order utilities";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "network-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, network, unix }:
      mkDerivation {
···
      }) {};
 
   "network-uri" = callPackage
-    ({ mkDerivation, base, deepseq, HUnit, parsec, test-framework
-     , test-framework-hunit, test-framework-quickcheck2
-     }:
-     mkDerivation {
-       pname = "network-uri";
-       version = "2.6.1.0";
-       sha256 = "1w27zkvn39kjr9lmw9421y8w43h572ycsfafsb7kyvr3a4ihlgj2";
-       revision = "1";
-       editedCabalFile = "141nj7q0p9wkn5gr41ayc63cgaanr9m59yym47wpxqr3c334bk32";
-       libraryHaskellDepends = [ base deepseq parsec ];
-       testHaskellDepends = [
-         base HUnit test-framework test-framework-hunit
-         test-framework-quickcheck2
-       ];
-       description = "URI manipulation";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "network-uri_2_7_0_0" = callPackage
     ({ mkDerivation, base, criterion, deepseq, HUnit, parsec
      , template-haskell, test-framework, test-framework-hunit
      , test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "network-uri";
-       version = "2.7.0.0";
-       sha256 = "0sgqw1bi6dv28a3cw2kjxiy1sfjjfwdk5ikmnk1v828inlk7zwgz";
+       version = "2.6.2.0";
+       sha256 = "0fmjc4p6pnzjxyg32pp7xh4wdbpqzp0rya80mccixyracvs1q3nw";
        libraryHaskellDepends = [ base deepseq parsec template-haskell ];
        testHaskellDepends = [
          base criterion deepseq HUnit test-framework test-framework-hunit
···
        ];
        description = "URI manipulation";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "network-uri-flag" = callPackage
···
      }:
      mkDerivation {
        pname = "niv";
-       version = "0.2.12";
-       sha256 = "0lbkc49ddkxb6x3miimcd2c4ajwf7d9z0hay54n0gmz7d92ha8q0";
+       version = "0.2.13";
+       sha256 = "11znn37j15gzwg6nh6z4k5ijxyyc7gbirnrwlhh4b8868d9axjfy";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          unliftio unordered-containers
        ];
        executableHaskellDepends = [
+         aeson aeson-pretty ansi-terminal base bytestring directory
+         file-embed filepath hashable http-conduit mtl optparse-applicative
+         process profunctors pureMD5 string-qq text unliftio
+         unordered-containers
+       ];
+       testHaskellDepends = [
          aeson aeson-pretty ansi-terminal base bytestring directory
          file-embed filepath hashable http-conduit mtl optparse-applicative
          process profunctors pureMD5 string-qq tasty text unliftio
···
      }:
      mkDerivation {
        pname = "nix-diff";
-       version = "1.0.7";
-       sha256 = "0zf09wffmzkk6rbk5nx4qhygpb6m492mz422w9a71dzv1icxkbfs";
+       version = "1.0.8";
+       sha256 = "0073802yrd5f1zfhnbsll9cqcycihw9bac1psfwvcwvihsh3j413";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "numhask_0_4_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "numhask";
+       version = "0.4.0";
+       sha256 = "1wwhpsrbnaa0nmb9x31wnk66dbvajd54mflvbnifff2dkaha89x1";
+       libraryHaskellDepends = [ base ];
+       description = "numeric classes";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "numhask-array" = callPackage
     ({ mkDerivation, adjunctions, base, deepseq, distributive, doctest
      , hedgehog, hmatrix, numhask, numhask-hedgehog, numhask-prelude
···
      }:
      mkDerivation {
        pname = "numhask-array";
-       version = "0.5.0.0";
-       sha256 = "0gx2p7b7xb1x5nfp5szdvsbylqsci9bmmz5jmy86c4z13srxmkkq";
+       version = "0.5.1";
+       sha256 = "1nrk6j4kw0l09b8f7k3sx47ri6i1vy5qygl9zbhhdz8z75s0fzn8";
        libraryHaskellDepends = [
          adjunctions base deepseq distributive hmatrix numhask
          numhask-prelude protolude vector
···
      }:
      mkDerivation {
        pname = "numhask-hedgehog";
-       version = "0.3.1";
-       sha256 = "1glg0lapr0fm06z5s8k4xsi99yx3khay4ynvic3kb1xf0iqay818";
+       version = "0.3.2";
+       sha256 = "1cfvkq5v88d8zhkj8bgn18hmlg52nsprvrmyan9ndxppyzljphan";
        libraryHaskellDepends = [
          base hedgehog numhask numhask-prelude numhask-space
        ];
···
     ({ mkDerivation, base, doctest, numhask, protolude }:
      mkDerivation {
        pname = "numhask-prelude";
-       version = "0.3.2";
-       sha256 = "1884pm13wyhqwwl9n2k9wv7r7q86x4c682m78291sh6yinrymazk";
+       version = "0.3.3";
+       sha256 = "0r9qf3yrm0lf1jhiyhvgsfc8zyfsllc8xmjwdqx2vsn9vy15p7aw";
        libraryHaskellDepends = [ base numhask protolude ];
        testHaskellDepends = [ doctest ];
        description = "A numeric prelude";
···
        pname = "nvim-hs";
        version = "2.1.0.2";
        sha256 = "0amlvrh213n9cfqax5gcy7zq3fd8q9hcskhjkbayvzsyf5hhr1rn";
+       revision = "1";
+       editedCabalFile = "1v52rmk7hbdn40964r50jjz3lanfc5q8xrdqpv1wmwviw3j4rip8";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
···
      }) {};
 
   "opentelemetry" = callPackage
-    ({ mkDerivation, async, base, clock, exceptions, hashable, random
-     , tasty, tasty-discover, tasty-quickcheck, text
-     , unordered-containers
+    ({ mkDerivation, async, attoparsec, base, bytestring, clock
+     , exceptions, hashable, random, tasty, tasty-discover, tasty-hunit
+     , tasty-quickcheck, text, unordered-containers
      }:
      mkDerivation {
        pname = "opentelemetry";
-       version = "0.0.0.0";
-       sha256 = "14k1lskdan3p7pddch9h0vr56ksyb4vnkm79rn4nlv4m9ycbxs7l";
+       version = "0.0.0.2";
+       sha256 = "15x7swbr18xks8a9xf1hjwibgqxsjigcyrahbnk72p1n1gxkarjr";
        libraryHaskellDepends = [
-         base clock exceptions hashable random text unordered-containers
+         attoparsec base bytestring clock exceptions hashable random text
+         unordered-containers
        ];
        testHaskellDepends = [
-         async base tasty tasty-discover tasty-quickcheck
+         async base bytestring tasty tasty-discover tasty-hunit
+         tasty-quickcheck
        ];
        testToolDepends = [ tasty-discover ];
        license = stdenv.lib.licenses.asl20;
···
     ({ mkDerivation, base, csv, pandoc, pandoc-types, text }:
      mkDerivation {
        pname = "pandoc-csv2table";
-       version = "1.0.7";
-       sha256 = "0b6ycr50n24cjlli7jk3dh1shfsl9wqykvmdgabk1s8n2w1ps8sa";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base csv pandoc pandoc-types text ];
-       executableHaskellDepends = [ base csv pandoc pandoc-types ];
-       description = "Convert CSV to Pandoc Table Markdown";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "pandoc-csv2table_1_0_8" = callPackage
-    ({ mkDerivation, base, csv, pandoc, pandoc-types, text }:
-     mkDerivation {
-       pname = "pandoc-csv2table";
        version = "1.0.8";
        sha256 = "0sf0af2cx5fi3a2iixkjjdpzp0153hxsjzs5wwqssby39g7s24gb";
        isLibrary = true;
···
        executableHaskellDepends = [ base csv pandoc pandoc-types ];
        description = "Convert CSV to Pandoc Table Markdown";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "pandoc-emphasize-code" = callPackage
···
      }:
      mkDerivation {
        pname = "patch";
-       version = "0.0.2.0";
-       sha256 = "0c9wf996k8py90ld6353hynb96fdird7lm4kx3djaild6iiyiaal";
+       version = "0.0.3.1";
+       sha256 = "1dkms6ngr01d4gvyjbl6z30b6qz4cnxnh0y7advrc9fib0237gnl";
        libraryHaskellDepends = [
          base constraints-extras containers dependent-map dependent-sum lens
          monoidal-containers semialign semigroupoids these transformers
···
        testHaskellDepends = [ base doctest ];
        description = "Perhaps, a monad";
        license = stdenv.lib.licenses.bsd2;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "period" = callPackage
···
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {};
 
-  "persistent_2_10_5" = callPackage
+  "persistent_2_10_5_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , blaze-html, bytestring, conduit, containers, fast-logger, hspec
      , http-api-data, monad-logger, mtl, path-pieces, resource-pool
···
      }:
      mkDerivation {
        pname = "persistent";
-       version = "2.10.5";
-       sha256 = "1xrfl7yrjppgbyw5msiayn54k3my4wh77pgmlv3kmp5vybhbfjzj";
+       version = "2.10.5.1";
+       sha256 = "0q95ik7agbld7dhzbr79nqh0v5vg8hk9sl61306y7kknyyy4inbw";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-html bytestring
          conduit containers fast-logger http-api-data monad-logger mtl
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "persistent-mysql_2_10_2_2" = callPackage
+  "persistent-mysql_2_10_2_3" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
      , containers, fast-logger, hspec, HUnit, monad-logger, mysql
      , mysql-simple, persistent, persistent-qq, persistent-template
···
      }:
      mkDerivation {
        pname = "persistent-mysql";
-       version = "2.10.2.2";
-       sha256 = "1b1x673nzqdv3i2rwn4fp4ky9a49dc6vfif1xjajzwf75mffabfb";
+       version = "2.10.2.3";
+       sha256 = "0ymh1gmcslwd8fp2wq71fswjgbmjdxl2mx4xf30j71h0744r2jbf";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring conduit containers monad-logger
          mysql mysql-simple persistent resource-pool resourcet text
···
      }:
      mkDerivation {
        pname = "persistent-pagination";
-       version = "0.1.1.0";
-       sha256 = "1g2mn2gv9dygx4rrpxi81421dyyy9pdnzrdpqcb5sygcjsqi17ha";
-       libraryHaskellDepends = [
-         base conduit esqueleto foldl microlens mtl persistent
-       ];
-       testHaskellDepends = [
-         base conduit containers esqueleto hspec hspec-discover mtl
-         persistent persistent-sqlite persistent-template QuickCheck time
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Efficient and correct pagination for persistent or esqueleto queries";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "persistent-pagination_0_1_1_1" = callPackage
-    ({ mkDerivation, base, conduit, containers, esqueleto, foldl, hspec
-     , hspec-discover, microlens, mtl, persistent, persistent-sqlite
-     , persistent-template, QuickCheck, time
-     }:
-     mkDerivation {
-       pname = "persistent-pagination";
        version = "0.1.1.1";
        sha256 = "03rxynxj2xx25l1zy42f06649m57blpx4inadb2a4dgz62zzyk5q";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Efficient and correct pagination for persistent or esqueleto queries";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "persistent-parser" = callPackage
···
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {};
 
-  "persistent-template_2_8_2_1" = callPackage
+  "persistent-template_2_8_2_2" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, criterion
      , deepseq, deepseq-generics, file-embed, hspec, http-api-data
      , monad-control, monad-logger, path-pieces, persistent, QuickCheck
···
      }:
      mkDerivation {
        pname = "persistent-template";
-       version = "2.8.2.1";
-       sha256 = "1w39n6164l99k1p8fk5c9aawbps6p3cmi4xgn123qmcmc1cw0nrj";
+       version = "2.8.2.2";
+       sha256 = "1ka5s373q50q4nqn1w5jqgcvh21m89gmq7i0jcdhidkz5ynvx51k";
        libraryHaskellDepends = [
          aeson base bytestring containers http-api-data monad-control
          monad-logger path-pieces persistent template-haskell text
···
        pname = "pipes-extras";
        version = "1.0.15";
        sha256 = "1cyb05bv5xkarab3090ikpjiqm79lr46n3nalplliz8jr4x67a82";
-       revision = "1";
-       editedCabalFile = "0xrd5zwkr1c7lswzi91gxl3ndra8y9g2b4j00sszyy3w187a2zwi";
+       revision = "2";
+       editedCabalFile = "1aprq51r83v5qja9vy01s8d17bnncnvp1mw6h6maxgzh2xppim8b";
        libraryHaskellDepends = [ base foldl lens pipes transformers ];
        testHaskellDepends = [
          base HUnit pipes test-framework test-framework-hunit transformers
···
     ({ mkDerivation, base, containers }:
      mkDerivation {
        pname = "polyvariadic";
-       version = "0.3.0.3";
-       sha256 = "0zf7znslayjmcnajmsymc79f0lyyk7ph9zfczq78inirg0hv7hq1";
-       revision = "5";
-       editedCabalFile = "1pzqc1hppzlj03wr2hrlm7liq9kcf650mpsrm4chr6msq491na9c";
+       version = "0.3.0.4";
+       sha256 = "17895458cfciv5lkcd26b5a96d9mwklish8xjhn14bd2himyczx0";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base ];
        description = "Creation and application of polyvariadic functions";
···
        pname = "pretty-sop";
        version = "0.2.0.3";
        sha256 = "10vybwbkqgr3fi13c5qwwhrwns9sdj7zvlkz6vag966pk238gnxy";
+       revision = "1";
+       editedCabalFile = "04gr1aaqaq347rv5vqh93qcnbc53y55hrds73js5329z2j1gbmng";
        libraryHaskellDepends = [ base generics-sop pretty-show ];
        testHaskellDepends = [ base generics-sop pretty-show ];
        testToolDepends = [ markdown-unlit ];
···
     ({ mkDerivation, base, graphviz, prettyprinter, text }:
      mkDerivation {
        pname = "prettyprinter-graphviz";
-       version = "0.1.0.1";
-       sha256 = "1h6jr4vh60j54ajsylh41y0iskz5yjgh2879v25z1mw7vfi40kww";
+       version = "0.1.1.0";
+       sha256 = "1x69lgxkby1bvsl91j4a94f1ylsl1imll3lqqpjig7yrxn9wi9xq";
        libraryHaskellDepends = [ base graphviz prettyprinter text ];
        description = "a prettyprinter backend for graphviz";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "primitive";
        version = "0.7.0.0";
        sha256 = "0xhmin3z2vp8jina1wzxg11nqiz8x63wisv2nw2ggji8lgz48skq";
+       revision = "1";
+       editedCabalFile = "1g10dsdadv8sy9mhhwx4jknzshvxc4qx6z9lmgqy7060prlbqnn4";
        libraryHaskellDepends = [ base ghc-prim transformers ];
        testHaskellDepends = [
          base base-orphans ghc-prim QuickCheck semigroups tagged tasty
···
        broken = true;
      }) {};
 
+  "provenience" = callPackage
+    ({ mkDerivation, aeson, base, blaze-markup, containers
+     , data-default, fgl, mtl, pandoc, text, time
+     }:
+     mkDerivation {
+       pname = "provenience";
+       version = "0.1.0.1";
+       sha256 = "0z2lsyx59wk663y4p0xwl5sjrl1h3aqlqwig2xhvv9a1cf2bzzd3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base blaze-markup containers data-default fgl mtl pandoc text
+         time
+       ];
+       description = "Computations that automatically track data dependencies";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "proxied" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "quiet" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "quiet";
+       version = "0.2";
+       sha256 = "0k2y6aa5c7d0sils11m0r1nk1fmck7iq10wr35v77r6wg5rzd2qi";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Generic deriving of Read/Show with no record labels";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "quipper" = callPackage
     ({ mkDerivation, base, quipper-language, quipper-libraries
      , quipper-tools
···
   "raven-haskell" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hspec, http-conduit, mtl
      , network, random, resourcet, text, time, unordered-containers
-     , uuid
+     , uuid-types
      }:
      mkDerivation {
        pname = "raven-haskell";
-       version = "0.1.3.0";
-       sha256 = "0jd0xxrliqc85mifkqzblc3fi6xjgkwkqxijqjx42r5jc0m1qs7f";
+       version = "0.1.4.0";
+       sha256 = "136vszzvfmhpxzavl7smnbyn45w026j005cdknapxhb6v495b7qz";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit mtl network random resourcet
-         text time unordered-containers uuid
+         text time unordered-containers uuid-types
        ];
        testHaskellDepends = [
          aeson base bytestring hspec time unordered-containers
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
-  "replace-megaparsec_1_2_0_0" = callPackage
+  "replace-megaparsec_1_2_1_0" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, megaparsec, text }:
      mkDerivation {
        pname = "replace-megaparsec";
-       version = "1.2.0.0";
-       sha256 = "0s9iqx4skv4dgj126b1g8903hi2g967pka695jmhi35sdwjsqc7l";
+       version = "1.2.1.0";
+       sha256 = "1k00a6xqdk8fgcja0v0flydk3afrpdrn4cf1csin7waqkl2kwvrb";
        libraryHaskellDepends = [ base bytestring megaparsec text ];
        testHaskellDepends = [ base bytestring Cabal megaparsec text ];
        description = "Find, replace, and edit text patterns with Megaparsec parsers";
···
     ({ mkDerivation, base, Only, postgresql-simple, text, time }:
      mkDerivation {
        pname = "ribbit";
-       version = "0.4.1.0";
-       sha256 = "1pgyh7ar03k62mpn09g8qm13m1j07wq257hpva3f9sx9n5qd8z2a";
-       revision = "1";
-       editedCabalFile = "11ky88hgkys3bzsqr3sl9j685h6l97r2zccpz1ylinsrvinwnq8s";
+       version = "1.0.0.1";
+       sha256 = "0zixx1xmqc8893rczhdzcplmdcx5dx1c4ykf7rg7w8h5yvni1r0y";
        libraryHaskellDepends = [ base Only postgresql-simple text time ];
-       description = "Type-level Relational DB language";
+       description = "Type-level Relational DB combinators";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }) {};
 
   "rock" = callPackage
-    ({ mkDerivation, base, dependent-map, dependent-sum
+    ({ mkDerivation, base, containers, dependent-map, dependent-sum
      , deriving-compat, mtl, protolude, transformers
      }:
      mkDerivation {
        pname = "rock";
-       version = "0.1.0.1";
-       sha256 = "1a70c55k10algfbc77maaa8p2l16xkml6kddza52ab0vv8dn98d3";
+       version = "0.2.0.0";
+       sha256 = "0h4z2ss4g9zshxpfallmbqw121jk1dv7q5s3ww39rhglw3j4dj9k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base dependent-map dependent-sum deriving-compat mtl protolude
-         transformers
+         base containers dependent-map dependent-sum deriving-compat mtl
+         protolude transformers
        ];
        description = "A build system for incremental, parallel, and demand-driven computations";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "safe-decimal" = callPackage
-    ({ mkDerivation, base, deepseq, exceptions, hspec, hspec-discover
-     , QuickCheck, scientific
+    ({ mkDerivation, base, Cabal, cabal-doctest, deepseq, doctest
+     , exceptions, hspec, hspec-discover, QuickCheck, scientific
+     , template-haskell
      }:
      mkDerivation {
        pname = "safe-decimal";
-       version = "0.1.0.0";
-       sha256 = "10y618swfxvz38fm95i6jbki5ax6w6xxhrdizqlrbwnqdjlsj681";
-       revision = "1";
-       editedCabalFile = "0449df25rah097rsbrbkb8sb4n80yms06isg0g8mp7v8ah4ssrs3";
+       version = "0.2.0.0";
+       sha256 = "03id56ib8m7gja2g5a8d6b26cz3h3zf3f3gq2ss7paxvwvn6wfib";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base deepseq exceptions scientific ];
-       testHaskellDepends = [ base deepseq hspec QuickCheck scientific ];
+       testHaskellDepends = [
+         base deepseq doctest hspec QuickCheck scientific template-haskell
+       ];
        testToolDepends = [ hspec-discover ];
        description = "Safe and very efficient arithmetic operations on fixed decimal point numbers";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "scheduler";
        version = "1.4.2.1";
        sha256 = "074m037ksjl7kgpgfldimaadhc4f6mmv40y6cq54m9shhg7rxw1c";
+       revision = "1";
+       editedCabalFile = "0gz7mkd0nj2bxcjnn50jgyiaks5dbvpm6wy8ygp2c61nnddbv4xx";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         atomic-primops base deepseq exceptions primitive unliftio-core
+       ];
+       testHaskellDepends = [
+         base deepseq doctest genvalidity-hspec hspec mwc-random QuickCheck
+         template-haskell unliftio vector
+       ];
+       benchmarkHaskellDepends = [
+         async base criterion deepseq monad-par parallel streamly unliftio
+       ];
+       description = "Work stealing scheduler";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "scheduler_1_4_2_2" = callPackage
+    ({ mkDerivation, async, atomic-primops, base, Cabal, cabal-doctest
+     , criterion, deepseq, doctest, exceptions, genvalidity-hspec, hspec
+     , monad-par, mwc-random, parallel, primitive, QuickCheck, streamly
+     , template-haskell, unliftio, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "scheduler";
+       version = "1.4.2.2";
+       sha256 = "0mzwm7lr089hbv08c58l3ahiid8w1cysvjl9q6vb46x3wpa3fwia";
+       revision = "1";
+       editedCabalFile = "0a6xcidya383ygzmz76di3dj1c8xm6ra5zb8fp517lk50s3ly3kl";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          atomic-primops base deepseq exceptions primitive unliftio-core
···
      }:
      mkDerivation {
        pname = "sdl2";
-       version = "2.5.0.0";
-       sha256 = "1x368yhdd55b3cvx8dvj1sj6nzygzigbhrwhssjs4k0rcxlwqfw8";
+       version = "2.5.1.0";
+       sha256 = "087df61fsmfsdc7pdn6sgsp5lf20nampa41illszii5jfr13s7gw";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
 
   "secret-sharing" = callPackage
     ({ mkDerivation, base, binary, bytestring, dice-entropy-conduit
-     , finite-field, polynomial, QuickCheck, test-framework
+     , finite-field, QuickCheck, test-framework
      , test-framework-quickcheck2, vector
      }:
      mkDerivation {
        pname = "secret-sharing";
-       version = "1.0.0.3";
-       sha256 = "0q315gmfnhpzgi4r0p3li8vvrdl2a0xgh0gxdin6s3nkh6hjpbv2";
-       revision = "1";
-       editedCabalFile = "1q8r31bjvjm1j11pp9xqxwh53gi2skm6lqxcja5v8gzs7hl1kkb1";
+       version = "1.0.1.0";
+       sha256 = "16j4xz4kkcicqfl9r8831il310ns02kxwj7mga8pvssfnhzv9zpv";
        libraryHaskellDepends = [
-         base binary bytestring dice-entropy-conduit finite-field polynomial
-         vector
+         base binary bytestring dice-entropy-conduit finite-field vector
        ];
        testHaskellDepends = [
-         base QuickCheck test-framework test-framework-quickcheck2
+         base bytestring QuickCheck test-framework
+         test-framework-quickcheck2
        ];
        description = "Information-theoretic secure secret sharing";
        license = stdenv.lib.licenses.lgpl21;
···
        pname = "servant-auth-client";
        version = "0.4.0.0";
        sha256 = "1kh4kq3cc9fn49vmh304zyzn7idb4k1j0803yp7a6qc733panf9g";
-       revision = "2";
-       editedCabalFile = "0c67m1ckksnmwkya78nn9hy65xb7c4023fy7d3pp6zyq8izrp1v8";
+       revision = "3";
+       editedCabalFile = "1f6x5dja9czj78zn9n4jrfpk6hzhbif3in48f6w24i45jpmysx98";
        libraryHaskellDepends = [
          base bytestring containers servant servant-auth servant-client-core
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "servant-auth-server_0_4_5_1" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
+     , bytestring, case-insensitive, cookie, data-default-class, entropy
+     , hspec, hspec-discover, http-client, http-types, jose, lens
+     , lens-aeson, markdown-unlit, memory, monad-time, mtl, QuickCheck
+     , servant, servant-auth, servant-server, tagged, text, time
+     , transformers, unordered-containers, wai, warp, wreq
+     }:
+     mkDerivation {
+       pname = "servant-auth-server";
+       version = "0.4.5.1";
+       sha256 = "10kcxdh9ba37jra6brrg11rzmx16jmwsk0yib92l0s3mkqp9was6";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring blaze-builder bytestring
+         case-insensitive cookie data-default-class entropy http-types jose
+         lens memory monad-time mtl servant servant-auth servant-server
+         tagged text time unordered-containers wai
+       ];
+       testHaskellDepends = [
+         aeson base bytestring case-insensitive hspec http-client http-types
+         jose lens lens-aeson mtl QuickCheck servant servant-auth
+         servant-server time transformers wai warp wreq
+       ];
+       testToolDepends = [ hspec-discover markdown-unlit ];
+       description = "servant-server/servant-auth compatibility";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "servant-auth-swagger" = callPackage
     ({ mkDerivation, base, hspec, hspec-discover, lens, QuickCheck
      , servant, servant-auth, servant-swagger, swagger2, text
···
        pname = "servant-waargonaut";
        version = "0.7.0.0";
        sha256 = "0fn7ph0805n297nzi3ig9wfx27kz6bmn4r914ibx44927xifms59";
+       revision = "1";
+       editedCabalFile = "1xavy6k93ncvcnb4rp1p33gxaqbhjil6mz9qk8li1ibhyi29yjxh";
        libraryHaskellDepends = [
          base bytestring http-media lens servant text waargonaut
          wl-pprint-annotated
···
      }:
      mkDerivation {
        pname = "shake";
-       version = "0.18.4";
-       sha256 = "0vpgs6f365p1s09h30g2a6qy4y0rxi3pyxcg14kiag9k504af9i0";
+       version = "0.18.5";
+       sha256 = "03r4rapkcyy04wf7ljikjbsjc29fpydbv5zbrrkiy1dqadzvasjp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Utilities for building ATS projects with shake";
        license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
      }) {};
 
   "shake-c" = callPackage
···
      }:
      mkDerivation {
        pname = "shakespeare";
-       version = "2.0.23";
-       sha256 = "0i1k6ahpvc45z05lycxs0f70ngm8xrazp6ayyxv1bzw8q8d4bkz3";
-       libraryHaskellDepends = [
-         aeson base blaze-html blaze-markup bytestring containers directory
-         exceptions ghc-prim parsec process scientific template-haskell text
-         time transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base blaze-html blaze-markup bytestring containers directory
-         exceptions ghc-prim hspec HUnit parsec process template-haskell
-         text time transformers
-       ];
-       description = "A toolkit for making compile-time interpolated templates";
-       license = stdenv.lib.licenses.mit;
-       maintainers = with stdenv.lib.maintainers; [ psibi ];
-     }) {};
-
-  "shakespeare_2_0_24" = callPackage
-    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
-     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
-     , process, scientific, template-haskell, text, time, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "shakespeare";
        version = "2.0.24";
        sha256 = "1fpkq5av7xyffsgghj5b85i8pzpnmkfcyjawhfm5lyhqpq1g5wh3";
        libraryHaskellDepends = [
···
        ];
        description = "A toolkit for making compile-time interpolated templates";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "shwifty" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , mtl, primitive, template-haskell, text, th-abstraction, time
+     , unordered-containers, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "shwifty";
+       version = "0.0.1.0";
+       sha256 = "1xipwh2cw4n608spxg011hnmima3badz6l8biry7q1nygc6mnc9a";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers mtl primitive
+         template-haskell text th-abstraction time unordered-containers
+         uuid-types vector
+       ];
+       description = "Generate swift types from haskell types";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "si-clock" = callPackage
     ({ mkDerivation, base, bytestring, hsI2C, time, transformers }:
      mkDerivation {
···
        libraryHaskellDepends = [ base optparse-applicative ];
        description = "Simple command args parsing and execution";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "simple-cmd-args_0_1_5" = callPackage
+    ({ mkDerivation, base, optparse-applicative }:
+     mkDerivation {
+       pname = "simple-cmd-args";
+       version = "0.1.5";
+       sha256 = "097b8qv0755p0iq6bcw6ndvvvv017x9hgf6l2zvb3sgqdg9wlj88";
+       libraryHaskellDepends = [ base optparse-applicative ];
+       description = "Simple command args parsing and execution";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "simple-conduit" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "singletons-presburger" = callPackage
+    ({ mkDerivation, base, ghc, ghc-typelits-presburger, reflection
+     , singletons
+     }:
+     mkDerivation {
+       pname = "singletons-presburger";
+       version = "0.3.0.0";
+       sha256 = "06djkc6y5clv0q903i04gaq0vri3nkk307znb418y0rfdh6czzwx";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base ghc ghc-typelits-presburger reflection singletons
+       ];
+       description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "singnal" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "sized";
-       version = "0.3.0.0";
-       sha256 = "1w00s0wgbr1n2x2ariixixy07bhxiyp5728givdrz0xg63gnw1s7";
+       version = "0.3.0.1";
+       sha256 = "1f31sfimji95bip88y9vn8mdlgbrikh0xc4w6vy2ydh1902rdiks";
        libraryHaskellDepends = [
          base constraints containers deepseq equational-reasoning
          ghc-typelits-presburger hashable lens ListLike mono-traversable
···
     ({ mkDerivation, aeson, base, linear, text, vector }:
      mkDerivation {
        pname = "smoothie";
-       version = "0.4.2.9";
-       sha256 = "0kra42nh86dfp66ngr4bmb8d530nh7b9pra1vlykc0sx9b1zpjnk";
+       version = "0.4.2.10";
+       sha256 = "059r2igvqidganwn0d907f6zv9h7ggwa6hgaaxh2car3kyi7425l";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ aeson base linear text vector ];
        description = "Smooth curves via several interpolation modes";
···
      }:
      mkDerivation {
        pname = "sparse-tensor";
-       version = "0.2.1.2";
-       sha256 = "0rkq0la7l12x9ck96ra8inlz81fcj5z8sxa90sgd082jhrq7jq94";
+       version = "0.2.1.3";
+       sha256 = "1fcckwp9k3ky669ai62x26pgz0irir4ngk0m6g1659fsn3f2gdc8";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          ad base bytestring cereal containers deepseq ghc-typelits-knownnat
···
     ({ mkDerivation, base, semigroups, transformers, utility-ht }:
      mkDerivation {
        pname = "storable-record";
-       version = "0.0.4";
-       sha256 = "0hjs1km0fc9ch0i1rbycxia5w3939hk4p4md73ikgg4aipqb5zyf";
+       version = "0.0.4.1";
+       sha256 = "1waj81810ywbrzizifsrjd0n3803scl8sr248z9nlrc94fz8vg58";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ 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, network, primitive, resourcet, safe, semigroups
-     , 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.5.1.2";
-       sha256 = "1abwlcj0z17hj5h94cbg1sgqfdsdgjhgfgd2aaspsn4zdfk5bjc5";
-       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 network primitive
-         resourcet safe semigroups 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 network
-         primitive resourcet safe semigroups 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 network primitive resourcet safe semigroups
-         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 = stdenv.lib.licenses.mit;
-     }) {};
-
-  "store_0_7_1" = callPackage
-    ({ mkDerivation, array, async, base, base-orphans
-     , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
-     , clock, containers, contravariant, criterion, cryptohash, deepseq
      , directory, fail, filepath, free, ghc-prim, hashable, hspec
      , hspec-smallcheck, integer-gmp, lifted-base, monad-control
      , mono-traversable, network, primitive, resourcet, safe, semigroups
···
        ];
        description = "Fast binary serialization";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "store-core" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stratosphere_0_48_0" = callPackage
+  "stratosphere_0_49_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , hashable, hspec, hspec-discover, lens, template-haskell, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "stratosphere";
-       version = "0.48.0";
-       sha256 = "1g6z2yfafa9h1nr3kzg4mblgl7n8dmyja8zyq888m99lh4h8qdf2";
+       version = "0.49.0";
+       sha256 = "18qw7m0h9nlg0vicg3rr7dghmpdfnrpd0ayqyi60c1ifzk4ys4sf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "structs";
-       version = "0.1.2";
-       sha256 = "0myv13g48y8vn397lvg45lb942fmw4n9gs80v5nnjfvgika7qbw4";
-       revision = "2";
-       editedCabalFile = "0ma2s0by622kaq7p57g859pxha02bqrd7n86cczfb2gzcm7kqma7";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         base deepseq ghc-prim primitive template-haskell
-       ];
-       testHaskellDepends = [
-         base directory doctest filepath parallel primitive QuickCheck tasty
-         tasty-hunit tasty-quickcheck
-       ];
-       description = "Strict GC'd imperative object-oriented programming with cheap pointers";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "structs_0_1_3" = callPackage
-    ({ mkDerivation, base, Cabal, cabal-doctest, deepseq, directory
-     , doctest, filepath, ghc-prim, parallel, primitive, QuickCheck
-     , tasty, tasty-hunit, tasty-quickcheck, template-haskell
-     }:
-     mkDerivation {
-       pname = "structs";
        version = "0.1.3";
        sha256 = "1y8w44lsybzrkhnv2nrk4zpsp01hny66syibh3xwqpi06k18h2lr";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        ];
        description = "Strict GC'd imperative object-oriented programming with cheap pointers";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "structural-induction" = callPackage
···
      }:
      mkDerivation {
        pname = "taskell";
-       version = "1.9.1.0";
-       sha256 = "07hkkx71xb6k89ylis58lcv69ab1avggb4347ppzv2wxp6qljn5l";
+       version = "1.9.2.0";
+       sha256 = "1nm150ffvwmxid9jzg2r0yj995s39lsfd85rhpsbpbhprpx6wf4s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "tasty-hunit-compat" = callPackage
+    ({ mkDerivation, base, HUnit, tasty, tasty-hunit }:
+     mkDerivation {
+       pname = "tasty-hunit-compat";
+       version = "0.1.0";
+       sha256 = "0894pi60ncyfcgvnpm39mcklbqbabgln19qvf9mjcphcnxvpxlvx";
+       libraryHaskellDepends = [ base HUnit tasty tasty-hunit ];
+       description = "Tasty integration with the existing HUnit package";
+       license = stdenv.lib.licenses.mpl20;
+     }) {};
+
   "tasty-integrate" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
      , deepseq, directory, either, haskell-src-exts
···
      }:
      mkDerivation {
        pname = "tasty-lua";
-       version = "0.2.0.1";
-       sha256 = "0xlj36rrhkx312h7smx6ay20rhlhxvw2ma2ckdnzv1pvmdn6p5qx";
-       libraryHaskellDepends = [
-         base bytestring file-embed hslua tasty text
-       ];
-       testHaskellDepends = [
-         base directory filepath hslua tasty tasty-hunit
-       ];
-       description = "Write tests in Lua, integrate into tasty";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "tasty-lua_0_2_2" = callPackage
-    ({ mkDerivation, base, bytestring, directory, file-embed, filepath
-     , hslua, tasty, tasty-hunit, text
-     }:
-     mkDerivation {
-       pname = "tasty-lua";
        version = "0.2.2";
        sha256 = "0m75dffrj6ziaalrch91kzj76ki0chbf33pi7mrx0c1gzmpvn8gv";
        libraryHaskellDepends = [
···
        ];
        description = "Write tests in Lua, integrate into tasty";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "tasty-program" = callPackage
···
      }:
      mkDerivation {
        pname = "tasty-quickcheck";
-       version = "0.10.1";
-       sha256 = "0k4vvd5vmrncv1s6gdf03l4xijwlk428sb9jfx8n1zaz02971msh";
-       revision = "1";
-       editedCabalFile = "1ms8ph2vp8x1icqiw468zlpsj4pii7xjm6g3k6ikkcy7cx3vnv4s";
-       libraryHaskellDepends = [
-         base optparse-applicative QuickCheck random tagged tasty
-       ];
-       testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
-       description = "QuickCheck support for the Tasty test framework";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "tasty-quickcheck_0_10_1_1" = callPackage
-    ({ mkDerivation, base, optparse-applicative, pcre-light, QuickCheck
-     , random, tagged, tasty, tasty-hunit
-     }:
-     mkDerivation {
-       pname = "tasty-quickcheck";
        version = "0.10.1.1";
        sha256 = "098zyfl5958zikaqfyam75hv5l46pks5bnp3r7533bbmr4a60cpq";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
        description = "QuickCheck support for the Tasty test framework";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "tasty-quickcheck-laws" = callPackage
···
        license = stdenv.lib.licenses.isc;
      }) {};
 
+  "th-abstraction_0_3_2_0" = callPackage
+    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
+     mkDerivation {
+       pname = "th-abstraction";
+       version = "0.3.2.0";
+       sha256 = "0ygbky8sk0nk4jyfjf6rj1ghv83rflcfcbsmnn7rnjzks0xg7zin";
+       libraryHaskellDepends = [
+         base containers ghc-prim template-haskell
+       ];
+       testHaskellDepends = [ base containers template-haskell ];
+       description = "Nicer interface for reified information about data types";
+       license = stdenv.lib.licenses.isc;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "th-alpha" = callPackage
     ({ mkDerivation, base, containers, derive, mmorph, mtl, tasty
      , tasty-hunit, tasty-quickcheck, template-haskell, th-desugar
···
        pname = "these-skinny";
        version = "0.7.4";
        sha256 = "0hlxf94ir99y0yzm9pq8cvs7vbar4bpj1w1ibs96hrx2biwfbnkr";
-       revision = "1";
-       editedCabalFile = "057hgdbc5ch43cn5qz0kr02iws9p1l24z23pifll29iazzl1jk6c";
+       revision = "2";
+       editedCabalFile = "0q1izcz4kxrnl7sh0sxamxxq02mkxww88vr6v04pwj8alyhkd4z2";
        libraryHaskellDepends = [ base deepseq ];
        description = "A fork of the 'these' package without the dependency bloat";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "1.4.7";
-       sha256 = "01v6p4by2scn9wxyv14hal7pd7hkr7psr3kaj8xsnc924xpxmwak";
+       version = "1.4.8";
+       sha256 = "163ndsx6spicipsy52iqsrm97z6pfr4mm93d2dz7ffckbzsklmdb";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bifunctors bytestring clock colour containers deepseq hosc
···
      }:
      mkDerivation {
        pname = "type-natural";
-       version = "0.8.2.0";
-       sha256 = "1n5mavlnqjvyn1dr9iq16lyv0zhxbqab1rw7rl2i345kb1qpzini";
+       version = "0.8.3.1";
+       sha256 = "0nq54098jyrx6zz8vn0pw3kg9b6bwpxhnhxk3f5m18rpjjjjw4xs";
+       revision = "1";
+       editedCabalFile = "1nhv7wh3cgy5hhkgs3bgg3659qf3lpy8rm89ikbb0p69bbxdpmfa";
        libraryHaskellDepends = [
          base constraints equational-reasoning ghc-typelits-natnormalise
          ghc-typelits-presburger singletons template-haskell
···
     ({ mkDerivation, base, transformers }:
      mkDerivation {
        pname = "util";
-       version = "0.1.17.0";
-       sha256 = "1wyjxrnzianif6msk7qvib92lksy66hx4rkdb7sda0a4h704960c";
+       version = "0.1.17.1";
+       sha256 = "1qhx4r27sny25sykacf5xi5br4msq4335ghp5zc3fq0lii3866s7";
        libraryHaskellDepends = [ base transformers ];
        description = "Utilities";
        license = stdenv.lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "uuid-bytes" = callPackage
+    ({ mkDerivation, base, byteslice, bytesmith, HUnit
+     , natural-arithmetic, primitive, small-bytearray-builder, tasty
+     , tasty-hunit, wide-word
+     }:
+     mkDerivation {
+       pname = "uuid-bytes";
+       version = "0.1.0.1";
+       sha256 = "0gzw6dn84xg0ndkhsnqpr1qn858cr0627hkdq0rijv932b0z4yvs";
+       libraryHaskellDepends = [
+         base byteslice bytesmith natural-arithmetic primitive
+         small-bytearray-builder wide-word
+       ];
+       testHaskellDepends = [
+         base byteslice HUnit natural-arithmetic primitive tasty tasty-hunit
+         wide-word
+       ];
+       description = "UUID parsing using byteverse packages";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "uuid-crypto" = callPackage
     ({ mkDerivation, base, binary, bytestring, cryptoids
      , cryptoids-class, cryptoids-types, exceptions, uuid
···
 
   "vector" = callPackage
     ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, HUnit
-     , primitive, QuickCheck, random, template-haskell, test-framework
-     , test-framework-hunit, test-framework-quickcheck2, transformers
+     , primitive, QuickCheck, random, semigroups, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, transformers
      }:
      mkDerivation {
        pname = "vector";
-       version = "0.12.0.3";
-       sha256 = "1a756s4w759ji3als5alfxwlckh5zcmykfg9rll4mlr2knzvz8mq";
-       revision = "2";
-       editedCabalFile = "1kjs6jnbxziv1q0md2jiqic0r19ry8xlg7wdr8b52rz7yjyb08hl";
+       version = "0.12.1.2";
+       sha256 = "1g8i806ph9l789pv2k665bbxlmsbwfwzml1mi9xv683g7xl2fviv";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        testHaskellDepends = [
-         base base-orphans HUnit primitive QuickCheck random
-         template-haskell test-framework test-framework-hunit
-         test-framework-quickcheck2 transformers
+         base base-orphans HUnit primitive QuickCheck random semigroups
+         tasty tasty-hunit tasty-quickcheck template-haskell transformers
        ];
        description = "Efficient Arrays";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "versions";
-       version = "3.5.2";
-       sha256 = "0a2ymd7wmpakcrm1fz9xwmjqlka7jmd8kb6385frd36nbi9bx78h";
-       libraryHaskellDepends = [ base deepseq hashable megaparsec text ];
-       testHaskellDepends = [
-         base base-prelude checkers megaparsec microlens QuickCheck tasty
-         tasty-hunit tasty-quickcheck text
-       ];
-       description = "Types and parsers for software version numbers";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "versions_3_5_3" = callPackage
-    ({ mkDerivation, base, base-prelude, checkers, deepseq, hashable
-     , megaparsec, microlens, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, text
-     }:
-     mkDerivation {
-       pname = "versions";
        version = "3.5.3";
        sha256 = "0i883v04i1a3sjn1vx15yb3bwi9pq41z650aq3zci72vyvbhr0n7";
        libraryHaskellDepends = [ base deepseq hashable megaparsec text ];
···
        ];
        description = "Types and parsers for software version numbers";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "vflow-types" = callPackage
···
        pname = "vformat";
        version = "0.14.1.0";
        sha256 = "0wg419mqdqsi6msgy4k7jgqdqba96pmv58dpyd6ar6hq7b90na69";
+       revision = "1";
+       editedCabalFile = "074y0nkygj8klkpm3rpdp7z2yj9np9y6rzhc7i62j0mykd27h8hq";
        libraryHaskellDepends = [
          base containers exceptions template-haskell
        ];
···
        pname = "vformat-aeson";
        version = "0.1.0.1";
        sha256 = "1cj3zp5n1j86jds906r9yrhanl8xq08gk97x6i64d651pry4h11v";
+       revision = "1";
+       editedCabalFile = "1p85qlv9w11mqybcf81xix0lhbgc2bzy9gw83ywci5kmd1s7a2a5";
        libraryHaskellDepends = [
          aeson base bytestring scientific text unordered-containers vector
          vformat
···
        pname = "vformat-time";
        version = "0.1.0.0";
        sha256 = "0s3b9ryyzmvy1fpxdnxdgrpi5faz67r8immm30pv6njy741k1l36";
+       revision = "1";
+       editedCabalFile = "0i11kkr8xwrffqz6jb68xfgvsbdkfxzxmw9k1bjc42x9hidgxv47";
        libraryHaskellDepends = [ base time vformat ];
        testHaskellDepends = [ base time vformat ];
        description = "Extend vformat to time datatypes";
···
        pname = "wai-middleware-auth";
        version = "0.1.2.1";
        sha256 = "0x3x3vc2l7glvfv6xcmqq0bw4mm8w2l577zx6qhx4399b03j56a1";
+       revision = "1";
+       editedCabalFile = "06pd7qk160m17nn3v61hmcnkfwm5qy6bjr1yhx4s2vsqyqvxgbaw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "wai-middleware-auth";
        version = "0.2.1.0";
        sha256 = "16gm0r4jlmzx5qd4s03whqlc8siy139fwrb6q26a053c85n5lw0f";
+       revision = "1";
+       editedCabalFile = "14aicx9vvp5p77hxmx0zqmqmz4qgv7adr7rsvxy76k0rszz8s8d6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "withdependencies";
-       version = "0.2.5";
-       sha256 = "13xdcn9fp1nc5378vmjbjwpw4n19bnnfrgr729yh5s366f2cfiv1";
+       version = "0.3.0";
+       sha256 = "1hjld3ndafnaxwx1c6s88dc3bimbc5vwfdf6lcsq22apzh1gmdm6";
        libraryHaskellDepends = [
          base conduit containers mtl profunctors
        ];
···
     ({ mkDerivation, base, base-compat, text }:
      mkDerivation {
        pname = "wl-pprint-text";
-       version = "1.2.0.0";
-       sha256 = "0g3w92rad6x5appfb22rbzcas2ix2h0hy91sdxhq8a4a5cnlrpa0";
-       libraryHaskellDepends = [ base base-compat text ];
-       description = "A Wadler/Leijen Pretty Printer for Text values";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "wl-pprint-text_1_2_0_1" = callPackage
-    ({ mkDerivation, base, base-compat, text }:
-     mkDerivation {
-       pname = "wl-pprint-text";
        version = "1.2.0.1";
        sha256 = "030ckgzz14sv2c317g4j5g68hyq9xi40cmv0apwclw6sc6xgsvly";
        libraryHaskellDepends = [ base base-compat text ];
        description = "A Wadler/Leijen Pretty Printer for Text values";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "wlc-hs" = callPackage
···
      }:
      mkDerivation {
        pname = "yaml-light-lens";
-       version = "0.3.3.5";
-       sha256 = "11q6g00qycpr29n1yxpsgpailzk216pr3cfjy7pyrlvfpl4wx24f";
+       version = "0.3.3.6";
+       sha256 = "034dj7k0719lkhwgrz91wk2dfpxg4kvyj9ax7cpz9q6qa8jn0zp7";
        libraryHaskellDepends = [
          base bytestring bytestring-lexing containers lens yaml-light
        ];
···
      }) {};
 
   "yesod" = callPackage
-    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
-     , conduit, data-default-class, directory, fast-logger, monad-logger
-     , resourcet, semigroups, shakespeare, streaming-commons
-     , template-haskell, text, transformers, unix, unordered-containers
-     , wai, wai-extra, wai-logger, warp, yaml, yesod-core, yesod-form
-     , yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod";
-       version = "1.6.0";
-       sha256 = "0wx77nbpzdh40p1bm527kimfj48vs9d2avpvvz2w42zi3pz2y94a";
-       libraryHaskellDepends = [
-         aeson base blaze-html blaze-markup bytestring conduit
-         data-default-class directory fast-logger monad-logger resourcet
-         semigroups shakespeare streaming-commons template-haskell text
-         transformers unix unordered-containers wai wai-extra wai-logger
-         warp yaml yesod-core yesod-form yesod-persistent
-       ];
-       description = "Creation of type-safe, RESTful web applications";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "yesod_1_6_0_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit
      , data-default-class, directory, fast-logger, monad-logger
      , semigroups, shakespeare, streaming-commons, template-haskell
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-alerts" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-auth";
-       version = "1.6.8";
-       sha256 = "0d2nrzrqymbbp5hfwp7c6k6gr0vn6ladq0dl7wgwrybfx8nqgf65";
-       libraryHaskellDepends = [
-         aeson authenticate base base16-bytestring base64-bytestring binary
-         blaze-builder blaze-html blaze-markup bytestring conduit
-         conduit-extra containers cryptonite data-default email-validate
-         file-embed http-client http-client-tls http-conduit http-types
-         memory network-uri nonce persistent random safe shakespeare
-         template-haskell text time transformers unliftio unliftio-core
-         unordered-containers wai yesod-core yesod-form yesod-persistent
-       ];
-       description = "Authentication for Yesod";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "yesod-auth_1_6_8_1" = callPackage
-    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
-     , base64-bytestring, binary, blaze-builder, blaze-html
-     , blaze-markup, bytestring, conduit, conduit-extra, containers
-     , cryptonite, data-default, email-validate, file-embed, http-client
-     , http-client-tls, http-conduit, http-types, memory, network-uri
-     , nonce, persistent, random, safe, shakespeare, template-haskell
-     , text, time, transformers, unliftio, unliftio-core
-     , unordered-containers, wai, yesod-core, yesod-form
-     , yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod-auth";
        version = "1.6.8.1";
        sha256 = "1zpmcywc8qkx93y05r8zgzds8wj5sg6b5jhzi17g6fwnaha2i1qj";
        libraryHaskellDepends = [
···
        ];
        description = "Authentication for Yesod";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-auth-account" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-core";
-       version = "1.6.17";
-       sha256 = "1i31xx9ili9r9il0mqpb04pgnq67rfsfr61pw9xmc163akgdfi4l";
-       libraryHaskellDepends = [
-         aeson auto-update base blaze-html blaze-markup bytestring
-         case-insensitive cereal clientsession conduit conduit-extra
-         containers cookie deepseq fast-logger http-types memory
-         monad-logger mtl parsec path-pieces primitive random resourcet
-         shakespeare template-haskell text time transformers unix-compat
-         unliftio unordered-containers vector wai wai-extra wai-logger warp
-         word8
-       ];
-       testHaskellDepends = [
-         async base bytestring clientsession conduit conduit-extra
-         containers cookie hspec hspec-expectations http-types HUnit network
-         path-pieces random resourcet shakespeare streaming-commons
-         template-haskell text transformers unliftio wai wai-extra warp
-       ];
-       benchmarkHaskellDepends = [
-         base blaze-html bytestring gauge shakespeare text
-       ];
-       description = "Creation of type-safe, RESTful web applications";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "yesod-core_1_6_17_2" = callPackage
-    ({ mkDerivation, aeson, async, auto-update, base, blaze-html
-     , blaze-markup, bytestring, case-insensitive, cereal, clientsession
-     , conduit, conduit-extra, containers, cookie, deepseq, fast-logger
-     , gauge, hspec, hspec-expectations, http-types, HUnit, memory
-     , monad-logger, mtl, network, parsec, path-pieces, primitive
-     , random, resourcet, shakespeare, streaming-commons
-     , template-haskell, text, time, transformers, unix-compat, unliftio
-     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
-     , filepath, GLFW-b, GLUtil, lens, linear, mvc, OpenGL, pipes
-     }:
-     mkDerivation {
-       pname = "yesod-core";
        version = "1.6.17.2";
        sha256 = "0rcfksbxnwcpg5qh9vjkddv39q95mx4nxzgix51bbwa128hhzcwf";
        libraryHaskellDepends = [
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-crud" = callPackage