hackage-packages.nix: automatic Haskell package set update

This update was generated by hackage2nix v2.15.1 from Hackage revision
https://github.com/commercialhaskell/all-cabal-hashes/commit/69af61c5a25138519c1a8007ca544820648bf2c0.

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

···
        ];
        description = "Library for computer music research and education";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "EventSocket" = callPackage
···
     ({ mkDerivation, base, directory, filepath }:
      mkDerivation {
        pname = "WEditor";
-       version = "0.1.0.0";
-       sha256 = "06kg6sfs7l2zbclw7vh3d82r6x8wdxvp58k24sjmfzm41nq3j739";
+       version = "0.2.1.1";
+       sha256 = "0p0vrvg96va4jppcxr3r5m14ykb5jybn8iyj677dxpziwh5brhmq";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base directory filepath ];
        doHaddock = false;
···
     ({ mkDerivation, base, brick, microlens, vty, WEditor }:
      mkDerivation {
        pname = "WEditorBrick";
-       version = "0.1.0.0";
-       sha256 = "1im6wmpx3y6wbzg7fdyjw3zjg6c8nd1vkr49pp6m9jqr9wv8jmsg";
+       version = "0.2.0.1";
+       sha256 = "1bzrfbw14c0ad477z5s51n8181cgcxw6q93bdj1d1nrfgawq7znb";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [ base brick microlens vty WEditor ];
+       executableHaskellDepends = [ base brick vty WEditor ];
        description = "Text-editor widget with dynamic line-wrapping for use with Brick";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
+  "WEditorHyphen" = callPackage
+    ({ mkDerivation, base, directory, hyphenation, WEditor }:
+     mkDerivation {
+       pname = "WEditorHyphen";
+       version = "0.1.0.5";
+       sha256 = "05f7dh75dx27q35bcj84mn3q6w0sd6jkcilykrlad9gm5ihbbcbk";
+       libraryHaskellDepends = [ base hyphenation WEditor ];
+       testHaskellDepends = [ base directory hyphenation WEditor ];
+       description = "Language-specific hyphenation policies for WEditor";
        license = stdenv.lib.licenses.asl20;
      }) {};
 
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "apply-refact_0_6_0_0" = callPackage
+    ({ mkDerivation, base, containers, directory, filemanip, filepath
+     , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact
+     , silently, syb, tasty, tasty-expected-failure, tasty-golden
+     , temporary, transformers, unix-compat
+     }:
+     mkDerivation {
+       pname = "apply-refact";
+       version = "0.6.0.0";
+       sha256 = "0p2mqgjcqr1zcmk8zgr0yq7g8z1agsa6l493lkj6g3ya9lyhxgig";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers directory filemanip ghc ghc-exactprint mtl process
+         refact syb temporary transformers unix-compat
+       ];
+       executableHaskellDepends = [
+         base containers directory filemanip filepath ghc ghc-exactprint mtl
+         optparse-applicative process refact syb temporary transformers
+         unix-compat
+       ];
+       testHaskellDepends = [
+         base containers directory filemanip filepath ghc ghc-exactprint mtl
+         optparse-applicative process refact silently syb tasty
+         tasty-expected-failure tasty-golden temporary transformers
+         unix-compat
+       ];
+       description = "Perform refactorings specified by the refact library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "apply-refact_0_7_0_0" = callPackage
+    ({ mkDerivation, base, containers, directory, filemanip, filepath
+     , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact
+     , silently, syb, tasty, tasty-expected-failure, tasty-golden
+     , temporary, transformers, unix-compat
+     }:
+     mkDerivation {
+       pname = "apply-refact";
+       version = "0.7.0.0";
+       sha256 = "1facic5lbc9xih6w1kfr3inwvada6y98n9xgc6iv6r057zr8jfp0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers directory filemanip ghc ghc-exactprint mtl process
+         refact syb temporary transformers unix-compat
+       ];
+       executableHaskellDepends = [
+         base containers directory filemanip filepath ghc ghc-exactprint mtl
+         optparse-applicative process refact syb temporary transformers
+         unix-compat
+       ];
+       testHaskellDepends = [
+         base containers directory filemanip filepath ghc ghc-exactprint mtl
+         optparse-applicative process refact silently syb tasty
+         tasty-expected-failure tasty-golden temporary transformers
+         unix-compat
+       ];
+       description = "Perform refactorings specified by the refact library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "apply-refact" = callPackage
     ({ mkDerivation, base, containers, directory, filemanip, filepath
      , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact
···
        broken = true;
      }) {};
 
-  "aur_6_3_1" = callPackage
-    ({ mkDerivation, aeson, base, http-client, http-client-tls, servant
-     , servant-client, tasty, tasty-hunit, text
+  "aur_7_0_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-client
+     , http-client-tls, http-types, tasty, tasty-hunit, text
      }:
      mkDerivation {
        pname = "aur";
-       version = "6.3.1";
-       sha256 = "049n21n8b2qllig40fqrc72ah16d4r2ajhxxj851nkyi44fvz0ba";
+       version = "7.0.0";
+       sha256 = "1x355bd8xdg0xm4y89ciqz861chj0b6dkwq8ma7nc46acl25a18z";
        libraryHaskellDepends = [
-         aeson base http-client servant servant-client text
+         aeson base bytestring http-client http-types text
        ];
        testHaskellDepends = [
          base http-client http-client-tls tasty tasty-hunit
···
      }) {};
 
   "aura" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, algebraic-graphs, aur, base
-     , bytestring, containers, errors, filepath, generic-lens
-     , http-client, http-client-tls, http-types, language-bash
-     , megaparsec, microlens, microlens-ghc, mwc-random, network-uri
-     , nonempty-containers, optparse-applicative, paths, pretty-simple
-     , prettyprinter, prettyprinter-ansi-terminal, rio, scheduler
-     , semigroupoids, servant-client-core, stm, tasty, tasty-hunit, text
-     , these, time, transformers, typed-process, unliftio, versions
-     , witherable-class
+    ({ mkDerivation, aeson, algebraic-graphs, aur, base, bytestring
+     , containers, filepath, hashable, http-client, http-client-tls
+     , http-types, language-bash, megaparsec, microlens, network-uri
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , rio, scheduler, stm, tasty, tasty-hunit, text, time, transformers
+     , typed-process, unliftio, versions
      }:
      mkDerivation {
        pname = "aura";
-       version = "2.2.1";
-       sha256 = "01biz0slwjn9pbjfpg2lc1fywjyk9y0zvhjrbv4kx9nxnbrb7b2b";
+       version = "2.3.0";
+       sha256 = "0m0f06qbg3dn4l5di5fmidjyk9qi14ppbbgbh126naccybjj3231";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson aeson-pretty algebraic-graphs aur base bytestring containers
-         errors filepath generic-lens http-client http-types language-bash
-         megaparsec microlens microlens-ghc mwc-random network-uri
-         nonempty-containers paths prettyprinter prettyprinter-ansi-terminal
-         rio scheduler semigroupoids servant-client-core stm text these time
-         transformers typed-process unliftio versions witherable-class
+         aeson algebraic-graphs aur base bytestring containers filepath
+         hashable http-client http-types language-bash megaparsec microlens
+         network-uri prettyprinter prettyprinter-ansi-terminal rio scheduler
+         stm text time transformers typed-process unliftio versions
        ];
        executableHaskellDepends = [
-         base bytestring containers errors http-client http-client-tls
-         microlens nonempty-containers optparse-applicative paths
-         pretty-simple prettyprinter prettyprinter-ansi-terminal rio text
-         transformers typed-process versions
+         base bytestring containers http-client http-client-tls microlens
+         optparse-applicative prettyprinter prettyprinter-ansi-terminal rio
+         text transformers typed-process versions
        ];
        testHaskellDepends = [
-         base bytestring containers megaparsec microlens paths rio tasty
+         base bytestring containers megaparsec microlens rio tasty
          tasty-hunit text versions
        ];
        description = "A secure package manager for Arch Linux and the AUR";
···
     ({ mkDerivation, barbies, base, template-haskell }:
      mkDerivation {
        pname = "barbies-th";
-       version = "0.1";
-       sha256 = "1rabviwnyp4c9r6ym958nxgrjz18gdajrj1crdniyyd586giadh4";
+       version = "0.1.1";
+       sha256 = "0b8g8q1ddbsfwf1v3063wv3abpa3f90mbiwa4wgsgizflj7s1ik9";
        libraryHaskellDepends = [ barbies base template-haskell ];
        testHaskellDepends = [ barbies base ];
        description = "Create strippable HKD via TH";
···
 
   "base16" = callPackage
     ({ mkDerivation, base, base16-bytestring, bytestring, criterion
-     , deepseq, memory, random-bytestring, tasty, tasty-hunit, text
+     , deepseq, memory, primitive, random-bytestring, tasty, tasty-hunit
+     , text
      }:
      mkDerivation {
        pname = "base16";
-       version = "0.2.0.0";
-       sha256 = "0j4mk7w8bg3q3ln5lcffdvaz36frizzq82z05l699y5g25abzrx4";
-       libraryHaskellDepends = [ base bytestring text ];
+       version = "0.2.0.1";
+       sha256 = "1y7ighqi1id57kh04ks8bg8b2vvzmy25p4qgdq26y0ydfz33gmsh";
+       libraryHaskellDepends = [ base bytestring primitive text ];
        testHaskellDepends = [
          base base16-bytestring bytestring memory random-bytestring tasty
          tasty-hunit text
···
        ];
        description = "Fast base64 encoding and decoding for ByteStrings";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "base64-bytestring_1_1_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion, deepseq
+     , HUnit, QuickCheck, split, test-framework, test-framework-hunit
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "base64-bytestring";
+       version = "1.1.0.0";
+       sha256 = "1adcnkcx4nh3d59k94bkndj0wkgbvchz576qwlpaa7148a86q391";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base bytestring containers HUnit QuickCheck split test-framework
+         test-framework-hunit test-framework-quickcheck2
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers criterion deepseq
+       ];
+       description = "Fast base64 encoding and decoding for ByteStrings";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "base64-bytestring-type" = callPackage
···
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.13.1.1";
-       sha256 = "0gqlwj30rghlqsik1i7w2yrccpf7h4pm3adnq6v7dprnhfcz1pkw";
+       version = "0.13.1.2";
+       sha256 = "0jqb1jn6jdrg6pm80zhd86rwsa05rxn0675lxv0m8c2z07g5601c";
        libraryHaskellDepends = [
          base dunai MonadRandom mtl simple-affine-space transformers
        ];
-       description = "A replacement of Yampa based on Monadic Stream Functions";
+       description = "FRP Yampa replacement implemented with Monadic Stream Functions";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "binary-io" = callPackage
+    ({ mkDerivation, base, binary, bytestring, hspec, process }:
+     mkDerivation {
+       pname = "binary-io";
+       version = "0.0.1";
+       sha256 = "1w0wqi60wdfhlmif7ji47cvf5608fg1b9hh7cz657ybv1lpc6s89";
+       libraryHaskellDepends = [ base binary bytestring ];
+       testHaskellDepends = [ base binary bytestring hspec process ];
+       description = "Read and write values of types that implement Binary from and to Handles";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "binary-list" = callPackage
     ({ mkDerivation, base, binary, bytestring, criterion, deepseq
      , phantom-state, transformers
···
        testHaskellDepends = [ base bytestring ];
        description = "Binary deserialisation using strict ByteStrings";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "binary-tagged" = callPackage
···
        description = "Low level bindings to the C levmar (Levenberg-Marquardt) library";
        license = "unknown";
        hydraPlatforms = stdenv.lib.platforms.none;
-     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
+     }) {inherit (pkgs) blas; liblapack = null;};
 
   "bindings-libcddb" = callPackage
     ({ mkDerivation, base, bindings-DSL, libcddb }:
···
      }:
      mkDerivation {
        pname = "birch-beer";
-       version = "0.2.4.0";
-       sha256 = "1kiq4qq8xjw7l7mm973lxrr502fz7fybgcpzmrjiadhamjch8h9l";
+       version = "0.2.4.2";
+       sha256 = "09bk2qsq6rpa2sk817vb9w1y21rqjkj25i74cfw4rgzy2c550ffj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "bits-extra";
-       version = "0.0.1.5";
-       sha256 = "1f29jn8gxmi9nrwnrykq4z88cg8zsknbw7licmf44hlid0s5glf5";
-       libraryHaskellDepends = [ base ghc-prim vector ];
-       testHaskellDepends = [
-         base doctest doctest-discover ghc-prim hedgehog hspec hw-hedgehog
-         hw-hspec-hedgehog
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [ base criterion ghc-prim vector ];
-       description = "Useful bitwise operations";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "bits-extra_0_0_2_0" = callPackage
-    ({ mkDerivation, base, criterion, doctest, doctest-discover
-     , ghc-prim, hedgehog, hspec, hspec-discover, hw-hedgehog
-     , hw-hspec-hedgehog, vector
-     }:
-     mkDerivation {
-       pname = "bits-extra";
        version = "0.0.2.0";
        sha256 = "1c54008kinzcx93kc8vcp7wq7la662m8nk82ax76i9b0gvbkk21f";
        libraryHaskellDepends = [ base ghc-prim vector ];
···
        benchmarkHaskellDepends = [ base criterion ghc-prim vector ];
        description = "Useful bitwise operations";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "bits-extras" = callPackage
···
        pname = "bitwise";
        version = "1.0.0.1";
        sha256 = "03xyzdkyb99gvm9g5chl07rqbnm7qrxba7wgmrfmal0rkwm0ibkn";
-       revision = "2";
-       editedCabalFile = "1mnh3629kgfivjwbbqwrkcyvg6iah5pncc5jzgq3ka5cq0kg09gz";
+       revision = "3";
+       editedCabalFile = "0sx6i1b9slicisnj53sv2jbdryyqd66amcm43xxqlv5srsqqijdm";
        libraryHaskellDepends = [ array base bytestring ];
        testHaskellDepends = [ base QuickCheck ];
        benchmarkHaskellDepends = [ array base bytestring criterion ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "blaze-markup_0_8_2_5" = callPackage
+    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
+     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "blaze-markup";
+       version = "0.8.2.5";
+       sha256 = "0qbnydx79pappwd4mzmmqq0pilpkiq7f6rqmqzpi2jjyfxlbmlqv";
+       libraryHaskellDepends = [ base blaze-builder bytestring text ];
+       testHaskellDepends = [
+         base blaze-builder bytestring containers HUnit QuickCheck tasty
+         tasty-hunit tasty-quickcheck text
+       ];
+       description = "A blazingly fast markup combinator library for Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "blaze-shields" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, blaze-svg, text }:
      mkDerivation {
···
 
   "brok" = callPackage
     ({ mkDerivation, ansi-terminal, attoparsec, base, classy-prelude
-     , directory, file-embed, http-client, http-conduit, tasty
-     , tasty-discover, tasty-expected-failure, tasty-hunit, text, time
+     , connection, directory, file-embed, http-client, http-client-tls
+     , http-conduit, tasty, tasty-discover, tasty-expected-failure
+     , tasty-hunit, template-haskell, text, time
      }:
      mkDerivation {
        pname = "brok";
-       version = "0.2.0.0";
-       sha256 = "1fsh05433gkm89j4nf9whcif0iiscxbd32q307rjm1fwsfwp9c46";
+       version = "1.0.0";
+       sha256 = "07zi88xsacacqw6mg87ipic5y72vjpn9mx789bk9gk4jvd69z7x1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal attoparsec base classy-prelude directory file-embed
-         http-client http-conduit text time
+         ansi-terminal attoparsec base classy-prelude connection directory
+         file-embed http-client http-client-tls http-conduit
+         template-haskell text time
        ];
        executableHaskellDepends = [ base classy-prelude file-embed ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "butcher";
-       version = "1.3.3.0";
-       sha256 = "1zp0j5ydbnk6x3yblhs9c6z2a3bmh9fvprqhx2wk3wyvrgkwsx8h";
-       revision = "1";
-       editedCabalFile = "1jw9dvkqdq24mgxvrrz4ymlqgrqkn4648dyy22wmx06lbqzcbqam";
-       libraryHaskellDepends = [
-         base bifunctors containers deque extra free microlens microlens-th
-         mtl multistate pretty transformers unsafe void
-       ];
-       testHaskellDepends = [
-         base containers deque extra free hspec microlens microlens-th mtl
-         multistate pretty transformers unsafe
-       ];
-       description = "Chops a command or program invocation into digestable pieces";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "butcher_1_3_3_1" = callPackage
-    ({ mkDerivation, base, bifunctors, containers, deque, extra, free
-     , hspec, microlens, microlens-th, mtl, multistate, pretty
-     , transformers, unsafe, void
-     }:
-     mkDerivation {
-       pname = "butcher";
        version = "1.3.3.1";
        sha256 = "0nqn057b5g8p6nj9xpbg52swiwzncirgfmzp3l1z5d8yn641zp1n";
        libraryHaskellDepends = [
···
        ];
        description = "Chops a command or program invocation into digestable pieces";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "butter" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cache-polysemy" = callPackage
+    ({ mkDerivation, base, cache, clock, hashable, polysemy
+     , polysemy-plugin
+     }:
+     mkDerivation {
+       pname = "cache-polysemy";
+       version = "0.1.2";
+       sha256 = "1psgf0x9hjhhnn7kn954b26kxd1c94cbhgv8xd2w3nxpmv2qh0m2";
+       libraryHaskellDepends = [
+         base cache clock hashable polysemy polysemy-plugin
+       ];
+       testHaskellDepends = [
+         base cache clock hashable polysemy polysemy-plugin
+       ];
+       description = "cached hashmaps";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "cached" = callPackage
     ({ mkDerivation, base, containers, directory, doctest, filepath
      , protolude, QuickCheck, quickcheck-assertions, shake, text
···
        libraryHaskellDepends = [ base cal3d OpenGL ];
        description = "OpenGL rendering for the Cal3D animation library";
        license = "LGPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "calamity" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, concurrent-extra
+     , data-default-class, deepseq, deque, df1, di-polysemy, exceptions
+     , fmt, focus, generic-lens, generic-override
+     , generic-override-aeson, hashable, http-date, http-types, lens
+     , lens-aeson, mtl, polysemy, polysemy-plugin, reflection
+     , scientific, stm, stm-chans, stm-containers, text, text-show, time
+     , typerep-map, unordered-containers, vector, websockets
+     , wreq-patchable, wuss
+     }:
+     mkDerivation {
+       pname = "calamity";
+       version = "0.1.0.0";
+       sha256 = "0cpx7v210gyh3r5qzh704wx4fgrb913b5g4rys76jhnmp77a79wc";
+       libraryHaskellDepends = [
+         aeson async base bytestring concurrent-extra data-default-class
+         deepseq deque df1 di-polysemy exceptions fmt focus generic-lens
+         generic-override generic-override-aeson hashable http-date
+         http-types lens lens-aeson mtl polysemy polysemy-plugin reflection
+         scientific stm stm-chans stm-containers text text-show time
+         typerep-map unordered-containers vector websockets wreq-patchable
+         wuss
+       ];
+       description = "A library for writing discord bots";
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
···
        broken = true;
      }) {};
 
+  "cardano-transactions" = callPackage
+    ({ mkDerivation, ansi-terminal, base, base58-bytestring, bytestring
+     , cardano-binary, cardano-crypto, cardano-crypto-wrapper
+     , cardano-ledger, cardano-ledger-test, cardano-tx, cborg
+     , cryptonite, extra, hedgehog-quickcheck, hspec, memory
+     , optparse-applicative, process, QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "cardano-transactions";
+       version = "1.0.0";
+       sha256 = "0qzf1yf85m0fwiayjb8g09w9dxq1zyg9xwjcd9p98i3dj6722yfa";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base58-bytestring bytestring cardano-binary cardano-crypto
+         cardano-crypto-wrapper cardano-ledger cborg cryptonite extra memory
+         text
+       ];
+       executableHaskellDepends = [
+         ansi-terminal base bytestring cborg memory optparse-applicative
+         text
+       ];
+       testHaskellDepends = [
+         base bytestring cardano-crypto-wrapper cardano-ledger
+         cardano-ledger-test cborg hedgehog-quickcheck hspec process
+         QuickCheck text
+       ];
+       testToolDepends = [ cardano-tx ];
+       description = "Library utilities for constructing and signing Cardano transactions";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {cardano-binary = null; cardano-crypto = null; 
+         cardano-crypto-wrapper = null; cardano-ledger = null; 
+         cardano-ledger-test = null; cardano-tx = null;};
+
   "carettah" = callPackage
     ({ mkDerivation, base, cairo, directory, filepath, gtk
      , gtk2hs-buildtools, hcwiid, highlighting-kate, mtl, pandoc, pango
···
      }:
      mkDerivation {
        pname = "chronos";
-       version = "1.1";
-       sha256 = "0g41hchir6rxfnd8halg49y80pc9dr38k7b7cik18gqdasswwg6c";
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring hashable primitive semigroups text
-         torsor vector
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring doctest HUnit QuickCheck test-framework
-         test-framework-hunit test-framework-quickcheck2 text torsor
-       ];
-       benchmarkHaskellDepends = [
-         attoparsec base bytestring criterion deepseq old-locale QuickCheck
-         text thyme time vector
-       ];
-       description = "A performant time library";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "chronos_1_1_1" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, criterion
-     , deepseq, doctest, hashable, HUnit, old-locale, primitive
-     , QuickCheck, semigroups, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, text, thyme, time, torsor, vector
-     }:
-     mkDerivation {
-       pname = "chronos";
        version = "1.1.1";
        sha256 = "10nxhnj5y984c3mf2wkc2zl6afbph0b0vj7f722g0yp7cq4908yj";
        libraryHaskellDepends = [
···
        ];
        description = "A performant time library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "chronos-bench" = callPackage
···
      }:
      mkDerivation {
        pname = "clash-ghc";
-       version = "1.2.0";
-       sha256 = "1rv8bjs563c8r543crj69dnp1610bch3dsxb5c0wckf799l8bmpn";
+       version = "1.2.1";
+       sha256 = "0bczw02kgpiczagnv2aq2yjj0g2619gl8dzwpzsvfz5r1p8kp6f3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "clash-lib";
-       version = "1.2.0";
-       sha256 = "0w5ilrqagc7xj14ngjg0rgcc3vhkxhsrz21rgl9qhygcs1cam5j2";
+       version = "1.2.1";
+       sha256 = "1l6xibxbkfz91wkl55548wv48gba6n4pmbymb1fbhs43nx3hssil";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson ansi-terminal attoparsec base binary bytestring clash-prelude
···
      }) {};
 
   "clash-prelude" = callPackage
-    ({ mkDerivation, array, base, bifunctors, binary, bytestring
-     , constraints, containers, criterion, data-binary-ieee754
-     , data-default-class, deepseq, doctest, ghc-prim
-     , ghc-typelits-extra, ghc-typelits-knownnat
+    ({ mkDerivation, array, base, bifunctors, binary, bytestring, Cabal
+     , cabal-doctest, constraints, containers, criterion
+     , data-binary-ieee754, data-default-class, deepseq, doctest
+     , ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat
      , ghc-typelits-natnormalise, half, hashable, hint, integer-gmp
      , lens, QuickCheck, quickcheck-classes-base, recursion-schemes
      , reflection, singletons, tasty, tasty-hunit, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "clash-prelude";
-       version = "1.2.0";
-       sha256 = "181ccw3ajdfhmlwjs9jiqy10b7whsp3pcqyxw166s8rda7h3pvpj";
+       version = "1.2.1";
+       sha256 = "18smrj545fvry8wj0hvawwcwc9yf1h1nsyyl337yh7xnxq9bycsy";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          array base bifunctors binary bytestring constraints containers
          data-binary-ieee754 data-default-class deepseq ghc-prim
···
        broken = true;
      }) {};
 
+  "co-log_0_4_0_1" = callPackage
+    ({ mkDerivation, ansi-terminal, base, bytestring, chronos
+     , co-log-core, containers, contravariant, directory, filepath
+     , hedgehog, markdown-unlit, mtl, stm, text, transformers
+     , typerep-map, vector
+     }:
+     mkDerivation {
+       pname = "co-log";
+       version = "0.4.0.1";
+       sha256 = "08sqrsy55wrfc5bg5sz22hah0ix14wrxn20lka17ri17a818w9p7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal base bytestring chronos co-log-core containers
+         contravariant directory filepath mtl stm text transformers
+         typerep-map vector
+       ];
+       executableHaskellDepends = [
+         base bytestring co-log-core mtl text typerep-map
+       ];
+       executableToolDepends = [ markdown-unlit ];
+       testHaskellDepends = [ base co-log-core hedgehog ];
+       description = "Composable Contravariant Comonadic Logging Library";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "co-log-concurrent" = callPackage
+    ({ mkDerivation, base, co-log-core, stm }:
+     mkDerivation {
+       pname = "co-log-concurrent";
+       version = "0.4.0.0";
+       sha256 = "1gnfqg6c290ain7v06clxga6jj46bdry6vvsrk1dhcdqv1rvkfwz";
+       libraryHaskellDepends = [ base co-log-core stm ];
+       description = "Asynchronous backend for co-log library";
+       license = stdenv.lib.licenses.mpl20;
+     }) {};
+
   "co-log-core" = callPackage
     ({ mkDerivation, base, doctest, Glob }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mpl20;
      }) {};
 
+  "co-log-core_0_2_1_1" = callPackage
+    ({ mkDerivation, base, doctest, Glob }:
+     mkDerivation {
+       pname = "co-log-core";
+       version = "0.2.1.1";
+       sha256 = "04w8j39n1cfmzvvllbjj21w7g53lgppf5crk7n4i9hgspaxbwyik";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "Composable Contravariant Comonadic Logging Library";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "co-log-polysemy" = callPackage
     ({ mkDerivation, base, co-log-core, polysemy }:
      mkDerivation {
···
        executableHaskellDepends = [ base co-log-core polysemy ];
        description = "Composable Contravariant Comonadic Logging Library";
        license = stdenv.lib.licenses.mpl20;
+     }) {};
+
+  "co-log-polysemy_0_0_1_2" = callPackage
+    ({ mkDerivation, base, co-log-core, polysemy }:
+     mkDerivation {
+       pname = "co-log-polysemy";
+       version = "0.0.1.2";
+       sha256 = "0g1qr6akgbnqs64xammvdpqjf5n5drx4a48w7lxw7l6n7z99rr4n";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base co-log-core polysemy ];
+       executableHaskellDepends = [ base co-log-core polysemy ];
+       description = "Composable Contravariant Comonadic Logging Library";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "co-log-sys" = callPackage
···
      , bytestring, cereal, cereal-text, containers, deepseq
      , dependent-sum, ghc-prim, hashable, HUnit, monad-loops, mtl
      , random, ref-tf, reflex, template-haskell, test-framework
-     , test-framework-hunit, text, time
+     , test-framework-hunit, text, time, witherable
      }:
      mkDerivation {
        pname = "codeworld-api";
-       version = "0.4.0";
-       sha256 = "0smw8xjigq1sl3rppbhvifsrzjfbhy4d41m0rpjf1d1ahvby64ja";
+       version = "0.5.0";
+       sha256 = "17s1353jk5l93hxv7wnnf4hxzw0ds1gq16kxkf7ig985141cah1n";
        libraryHaskellDepends = [
          aeson base base64-bytestring blank-canvas bytestring cereal
          cereal-text containers deepseq dependent-sum ghc-prim hashable
          monad-loops mtl random ref-tf reflex template-haskell text time
+         witherable
        ];
        testHaskellDepends = [
          aeson base base64-bytestring blank-canvas bytestring cereal
          cereal-text containers deepseq dependent-sum ghc-prim hashable
          HUnit monad-loops mtl random ref-tf reflex template-haskell
-         test-framework test-framework-hunit text time
+         test-framework test-framework-hunit text time witherable
        ];
        description = "Graphics library for CodeWorld";
        license = stdenv.lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "configurator-pg";
-       version = "0.2.2";
-       sha256 = "0ibpsj3yf8qlcjr84i77j6llrsfpcxadqqgsqz90cwy92z5vjxrx";
+       version = "0.2.3";
+       sha256 = "0vbs52za4smxy8nag08ag2c9mjbpiw1a7ai5vd8is7db9732skfa";
        libraryHaskellDepends = [
          base containers megaparsec protolude scientific text
        ];
···
     ({ mkDerivation, base, containers, contravariant, mmorph }:
      mkDerivation {
        pname = "contracheck-applicative";
-       version = "0.1.1.0";
-       sha256 = "0lv9zq1lxnl9w77wnsywna4lh1cw7gh8ks3gwciij2x2bwlw48ns";
+       version = "0.1.2";
+       sha256 = "0vfw5fp6max40wrfkcsl0km8qpdp231b6agc16y758cg9isxbllg";
        libraryHaskellDepends = [ base containers contravariant mmorph ];
        description = "Validation types/typeclass based on the contravariance";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "cpkg";
-       version = "0.2.5.1";
-       sha256 = "08snjhmxjcsw2imglfpqggby7vn2vgbbz56d0mh4s6p73mrqnjgg";
+       version = "0.2.5.2";
+       sha256 = "1njjbvpnkjwxgsrjr3fihyvgr194mc94g2qxdq5yb1ai3sms7zsd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "crypto-classical" = callPackage
     ({ mkDerivation, base, bytestring, containers, crypto-numbers
-     , crypto-random, microlens, microlens-th, modular-arithmetic
-     , QuickCheck, text, transformers
+     , crypto-random, modular-arithmetic, QuickCheck, text, transformers
      }:
      mkDerivation {
        pname = "crypto-classical";
-       version = "0.2.1";
-       sha256 = "0mqvygx8pvvmaalqzr94nf400smq8y22shyvfhxrh69hs6q0dgw6";
+       version = "0.3.0";
+       sha256 = "1jkgdaln74sznkqr1knainpn3pbjih76rk3r7wmx28jvy57pm1b3";
        libraryHaskellDepends = [
-         base bytestring containers crypto-numbers crypto-random microlens
-         microlens-th modular-arithmetic text transformers
+         base bytestring containers crypto-numbers crypto-random
+         modular-arithmetic text transformers
        ];
-       testHaskellDepends = [ base bytestring microlens QuickCheck ];
+       testHaskellDepends = [ base bytestring QuickCheck ];
        description = "An educational tool for studying classical cryptography schemes";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        pname = "css-syntax";
        version = "0.1.0.0";
        sha256 = "02f000nzc0dhjhlp1z82q4far8ablvzalpk918lg54f63lbqdwsh";
-       revision = "1";
-       editedCabalFile = "14241m9nm3wbbhajw95gdj9mvfzf4hmrzvk2wgjvkm71mg4yhwnr";
+       revision = "4";
+       editedCabalFile = "0n3wf9yjpn29nl0f9jk3izp7d2iq00j6bp1y1v1k5vc1ycskhn5y";
        libraryHaskellDepends = [ base scientific text ];
        testHaskellDepends = [
          base directory hspec QuickCheck scientific text
···
        pname = "data-accessor-template";
        version = "0.2.1.16";
        sha256 = "15gd6xlrq5ica514m5rdcz2dl8bibdmbsmnc98ddhx491c9g5rwk";
+       revision = "1";
+       editedCabalFile = "0zz2v420zvinphs6jnngc40x7h8jn5rqj3nj8alpgfyqx59w41my";
        libraryHaskellDepends = [
          base data-accessor template-haskell utility-ht
        ];
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "data-category";
-       version = "0.7.1";
-       sha256 = "0yvrqgid8b9awm1z31cpa465jfvjq8p23k23dxg567rm191n68kz";
+       version = "0.8.1";
+       sha256 = "06m5yb7ycxr1drvv67cyb01mhghhfac9y8wf7lpmq2z55h4hflb2";
        description = "Category theory";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
     ({ mkDerivation, aeson, base, bytestring }:
      mkDerivation {
        pname = "deriving-aeson";
-       version = "0.2.3";
-       sha256 = "0cxkrsdbr2mq2i5w8762lc5cc9kyf3csscd9gmndrrdvicmq1yvv";
+       version = "0.2.4";
+       sha256 = "1wswirjqpmmzyag5y2jhys9pswl3fdrzjv69csvd655qg8iyybpb";
        libraryHaskellDepends = [ aeson base ];
        testHaskellDepends = [ aeson base bytestring ];
        description = "Type driven generic aeson instance customisation";
···
        ];
        description = "mtl flavoured typeful hierarchical structured logging for di-core";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "di-polysemy" = callPackage
+    ({ mkDerivation, base, df1, di-core, di-df1, di-handle, polysemy }:
+     mkDerivation {
+       pname = "di-polysemy";
+       version = "0.1.1.0";
+       sha256 = "08n98ivdvfb77slzbxvysy4cgvnf6jcxf0zqj1rr40rjfxaw2xcn";
+       libraryHaskellDepends = [
+         base df1 di-core di-df1 di-handle polysemy
+       ];
+       description = "DI logger wrapped for Polysemy";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "dia-base" = callPackage
···
      }:
      mkDerivation {
        pname = "dobutokO2";
-       version = "0.31.0.0";
-       sha256 = "16sk8igx7n07lkhvi5r78d15n4wmhbirall6s4zaqn8ab7sdga86";
+       version = "0.35.2.0";
+       sha256 = "1hr4l8flfjinvbdwxf3xmq3xknd19kbf3d2k23dy7y1fghd6vflh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base bytestring directory mmsyn2 mmsyn3 mmsyn6ukr mmsyn7s mmsyn7ukr
          process vector
        ];
-       description = "A program and a library to create experimental music from a mono audio and a Ukrainian text";
+       description = "Helps to create experimental music from a file (or its part) and a Ukrainian text";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
        ];
        description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "dunai_0_7_0" = callPackage
+    ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty
+     , tasty-hunit, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "dunai";
+       version = "0.7.0";
+       sha256 = "1gii02d557ak0h4sq5ra4n40y4sl88z74n6mwd0937xxlpiahwsh";
+       libraryHaskellDepends = [
+         base MonadRandom simple-affine-space transformers transformers-base
+       ];
+       testHaskellDepends = [ base tasty tasty-hunit transformers ];
+       description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "dunai-core" = callPackage
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.1.0.0";
-       sha256 = "0jkn1740adzv9jwsp6qa0sxfxg6x5cvqlss1yjwcr1chsvpk2d1m";
+       version = "0.7.0";
+       sha256 = "08pbfw10dkds8dwr913p0rikvs7vxfwyj5rdsr7njzh39fz9lqli";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
        pname = "dynamic-plot";
        version = "0.4.1.0";
        sha256 = "1nly6ra0kd72q42hiaqism94vmyg5hp4ppyd024iiq9pcbgpq7r6";
+       revision = "1";
+       editedCabalFile = "0chaa06bzf3jd55c9s6wcnl7i8j2wl55rr9g50aia4gsc47azgxr";
        libraryHaskellDepends = [
          base colour colour-space constrained-categories containers
          data-default deepseq diagrams-cairo diagrams-core diagrams-gtk
···
      }:
      mkDerivation {
        pname = "ejdb2-binding";
-       version = "0.1.0.0";
-       sha256 = "0vh40ssfrz22vdqw0lswq27rr7wpzndg5y74wjdsddy44pbgmmc9";
+       version = "0.2.0.0";
+       sha256 = "1lxyjnnwv3r05l8qc979kmrl9kk5h8mdx9ca4wx8r6plsn7b2a51";
        libraryHaskellDepends = [
          aeson base bytestring unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "encoding";
-       version = "0.8.2";
-       sha256 = "1lfh5pyc4f73870xz6dydksp5nspnzbkj4fvinhwdknhc5ii8353";
+       version = "0.8.3";
+       sha256 = "07flh8rmdbi8rhgg2jzv70yb91kkjkiidc8ww5mxjdk8av70wbj3";
        setupHaskellDepends = [
          base Cabal containers filepath ghc-prim HaXml
        ];
···
        broken = true;
      }) {};
 
+  "extended-containers" = callPackage
+    ({ mkDerivation, base, hspec, QuickCheck, transformers, vector }:
+     mkDerivation {
+       pname = "extended-containers";
+       version = "0.1.0.0";
+       sha256 = "04m3i90iljx36yc528yz6dcgcrfvzkvjvghqjp741mqvmixdjsip";
+       libraryHaskellDepends = [ base transformers vector ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       description = "Heap and Vector container types";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "extended-reals" = callPackage
     ({ mkDerivation, base, deepseq, hashable, HUnit, QuickCheck, tasty
      , tasty-hunit, tasty-quickcheck, tasty-th
···
        pname = "first-class-families";
        version = "0.8.0.0";
        sha256 = "190jl3vs7glkbm8ap90x9yzlj01yzxd818s3i0w4pz21b6d6sxav";
+       revision = "1";
+       editedCabalFile = "02z6wixk9kdgshxsz99lag29lb70kadg9wn6vsgk906wj014fv52";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest Glob ];
        description = "First class type families";
···
     ({ mkDerivation, base, bifunctors, lens, optparse-applicative }:
      mkDerivation {
        pname = "friendly";
-       version = "0.1.0.0";
-       sha256 = "0ikbfki5yvagc3xjbqwmzzp29idfviaylnan6cr39kna6fc8ajgx";
-       revision = "2";
-       editedCabalFile = "12j953w8zcix2iyqwkn08zpw1r1dd7jk8p8a3v5hs5rya1qb74si";
+       version = "0.1.0.1";
+       sha256 = "0860zmvlccdnjycmjr4wmi8ighps9dig5zik8hpj2h3z208ph8qp";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "fusion-plugin" = callPackage
-    ({ mkDerivation, base, fusion-plugin-types, ghc, syb }:
+    ({ mkDerivation, base, containers, directory, filepath
+     , fusion-plugin-types, ghc, syb, time, transformers
+     }:
      mkDerivation {
        pname = "fusion-plugin";
-       version = "0.2.0";
-       sha256 = "0fbsmlkvxxfiwajl3ihidp2xmsds4y47sbqigng9pp78lhln35am";
-       libraryHaskellDepends = [ base fusion-plugin-types ghc syb ];
+       version = "0.2.1";
+       sha256 = "08v43q428s6nw3diqaasdr0c9arrzvzvldcybj8wp2r66aw613ic";
+       libraryHaskellDepends = [
+         base containers directory filepath fusion-plugin-types ghc syb time
+         transformers
+       ];
        description = "GHC plugin to make stream fusion more predictable";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.15.4";
-       sha256 = "03q3hd8m9m8xxpd0xbxqc0r2ycybznrxr4j1mr2qkzlf49qp1y2v";
+       version = "0.15.5";
+       sha256 = "07xd67202qv1fnka0nichpspzpyzlismlwdhlq0rr6nb3xriykxn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "genvalidity-typed-uuid" = callPackage
-    ({ mkDerivation, base, genvalidity, genvalidity-hspec
-     , genvalidity-hspec-aeson, genvalidity-uuid, hspec, QuickCheck
-     , typed-uuid
-     }:
-     mkDerivation {
-       pname = "genvalidity-typed-uuid";
-       version = "0.0.0.1";
-       sha256 = "12b9pqly41kwvyqzlqs2nv882m0vvkf06bshngvhjl4ykn7almqk";
-       libraryHaskellDepends = [
-         base genvalidity genvalidity-uuid QuickCheck typed-uuid
-       ];
-       testHaskellDepends = [
-         base genvalidity genvalidity-hspec genvalidity-hspec-aeson
-         genvalidity-uuid hspec QuickCheck typed-uuid
-       ];
-       description = "Generators for Phantom-Typed version of UUID";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "genvalidity-typed-uuid_0_0_0_2" = callPackage
     ({ mkDerivation, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, genvalidity-hspec-aeson
      , genvalidity-uuid, hspec, QuickCheck, typed-uuid
···
        ];
        description = "Generators for Phantom-Typed version of UUID";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "genvalidity-unordered-containers" = callPackage
···
      }) {};
 
   "genvalidity-uuid" = callPackage
-    ({ mkDerivation, base, genvalidity, genvalidity-hspec, hspec
-     , QuickCheck, uuid, validity, validity-uuid
-     }:
-     mkDerivation {
-       pname = "genvalidity-uuid";
-       version = "0.1.0.3";
-       sha256 = "1kjvl1i4nih5yyydilwsq1mssw1ljiipi20k5pxjh5rgb4f1p520";
-       libraryHaskellDepends = [
-         base genvalidity QuickCheck uuid validity validity-uuid
-       ];
-       testHaskellDepends = [
-         base genvalidity genvalidity-hspec hspec QuickCheck uuid
-       ];
-       description = "GenValidity support for UUID";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "genvalidity-uuid_0_1_0_4" = callPackage
     ({ mkDerivation, base, criterion, genvalidity
      , genvalidity-criterion, genvalidity-hspec, hspec, QuickCheck, uuid
      , validity, validity-uuid
···
        ];
        description = "GenValidity support for UUID";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "genvalidity-vector" = callPackage
···
      }) {};
 
   "ghc-check" = callPackage
-    ({ mkDerivation, base, ghc, ghc-paths, template-haskell
-     , transformers
+    ({ mkDerivation, base, filepath, ghc, ghc-paths, process
+     , template-haskell, transformers
      }:
      mkDerivation {
        pname = "ghc-check";
-       version = "0.1.0.3";
-       sha256 = "1zrlnk3gzdb96592is2krk8qpk386bib0bpgw47yqj8qfcxqf76v";
+       version = "0.3.0.0";
+       sha256 = "19fgfkv68q1l93ql6g4xpa27pcv1v04vpfpq0rcvspp09xmcv1i4";
        libraryHaskellDepends = [
-         base ghc ghc-paths template-haskell transformers
+         base filepath ghc ghc-paths process template-haskell transformers
        ];
-       description = "Detect mismatches between compile-time and run-time versions of the ghc api";
+       description = "detect mismatches between compile-time and run-time versions of the ghc api";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "ghc-heap-view";
-       version = "0.6.1";
-       sha256 = "04lmj3ihdwcz483w2cpjs4zcpld8yk3aslkw2gl4mal3fpwf0vhx";
+       version = "0.6.2";
+       sha256 = "1wj11g24zap7r2xvp46dir54hwyki025xnkgymc73224lisc3134";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal filepath ];
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "8.8.3.20200224";
-       sha256 = "0qwv8i4x4ylixrbipxkii0zxz3j33cpahlckbn6chpp9b59bfdpa";
+       version = "8.8.3.20200412.1";
+       sha256 = "07xfj3p8w5964jv5py19p2pbcpbjcbwzpd4b46d43j80abzavgxg";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "8.8.3.20200224";
-       sha256 = "0hdn3sd4l1ph26f715i6mlqw6l6w8nnfp9jmlcwrjph14rpn1y15";
+       version = "8.8.3.20200412.1";
+       sha256 = "1bfyi3haq6qz9x5dbnjvf7m7wqrxqmv3i4kdivlh2v416d56apqd";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
···
      }:
      mkDerivation {
        pname = "ghcid";
-       version = "0.8.5";
-       sha256 = "15zj78wasix4yz8mxx5hl6x1gj364vsbwn5arp7sbq13rywhs2qy";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         ansi-terminal base cmdargs directory extra filepath process time
-       ];
-       executableHaskellDepends = [
-         ansi-terminal base cmdargs containers directory extra filepath
-         fsnotify process terminal-size time unix
-       ];
-       testHaskellDepends = [
-         ansi-terminal base cmdargs containers directory extra filepath
-         fsnotify process tasty tasty-hunit terminal-size time unix
-       ];
-       description = "GHCi based bare bones IDE";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "ghcid_0_8_6" = callPackage
-    ({ mkDerivation, ansi-terminal, base, cmdargs, containers
-     , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit
-     , terminal-size, time, unix
-     }:
-     mkDerivation {
-       pname = "ghcid";
        version = "0.8.6";
        sha256 = "00zyf8m3jj72ax7sj0c4j0yivrvj72vqfwra7hzgywf8fc2qxfv1";
        isLibrary = true;
···
        ];
        description = "GHCi based bare bones IDE";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ghcide" = callPackage
···
      }:
      mkDerivation {
        pname = "git-brunch";
-       version = "1.2.0.0";
-       sha256 = "144i3rk9mx5qf1w231zramzr0vvwf8gq4h63v234jcxdlygysy5h";
+       version = "1.3.1.0";
+       sha256 = "0k1q3f9hyyagv67mpaj1159vic4kc44nk10nswg0pql38ai5bqvx";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
   "gopro-plus" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, exceptions
      , filepath, generic-deriving, HUnit, lens, lens-aeson, mtl, random
-     , retry, tasty, tasty-hunit, tasty-quickcheck, text, time
-     , transformers, unix, unliftio, unordered-containers, vector, wreq
+     , raw-strings-qq, retry, tasty, tasty-hunit, tasty-quickcheck, text
+     , time, transformers, unix, unliftio, unordered-containers, vector
+     , wreq
      }:
      mkDerivation {
        pname = "gopro-plus";
-       version = "0.3.0.1";
-       sha256 = "1c2g8ndqwlm8nz08nm66pz3j3wqdm0cn1r03ykay4g3lig7i27za";
+       version = "0.3.1.0";
+       sha256 = "06wggkl9p69xm75f3kkajacqr54fq7vqbmyldgapfqglbzs43z7g";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions filepath
          generic-deriving lens lens-aeson mtl random retry text time
···
        ];
        testHaskellDepends = [
          aeson base bytestring containers exceptions filepath
-         generic-deriving HUnit lens lens-aeson mtl random retry tasty
-         tasty-hunit tasty-quickcheck text time transformers unix unliftio
-         unordered-containers vector wreq
+         generic-deriving HUnit lens lens-aeson mtl random raw-strings-qq
+         retry tasty tasty-hunit tasty-quickcheck text time transformers
+         unix unliftio unordered-containers vector wreq
        ];
        description = "GoPro Plus Client API";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "greskell_1_0_1_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, doctest, doctest-discover
+     , exceptions, greskell-core, hashable, hint, hspec, semigroups
+     , text, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "greskell";
+       version = "1.0.1.0";
+       sha256 = "0gknzbaldmziy7lj23g3l8q3ymxdr5vbis109j6r7zbjap1jy0in";
+       libraryHaskellDepends = [
+         aeson base exceptions greskell-core hashable semigroups text
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring doctest doctest-discover greskell-core hint
+         hspec text unordered-containers
+       ];
+       description = "Haskell binding for Gremlin graph query language";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "greskell-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, doctest
      , doctest-discover, hashable, hspec, QuickCheck, scientific
···
        license = "GPL";
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
+     }) {inherit (pkgs) blas; liblapack = null;};
 
   "hXmixer" = callPackage
     ({ mkDerivation, base, directory, gtk3, process, split, text }:
···
        broken = true;
      }) {};
 
+  "hackage-security_0_5_3_0" = callPackage
+    ({ mkDerivation, base, base16-bytestring, base64-bytestring
+     , bytestring, Cabal, containers, cryptohash-sha256, directory
+     , ed25519, filepath, ghc-prim, mtl, network, network-uri, parsec
+     , pretty, QuickCheck, tar, tasty, tasty-hunit, tasty-quickcheck
+     , template-haskell, temporary, time, transformers, zlib
+     }:
+     mkDerivation {
+       pname = "hackage-security";
+       version = "0.5.3.0";
+       sha256 = "08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v";
+       revision = "6";
+       editedCabalFile = "1xs2nkzlvkdz8g27yzfxbjdbdadfmgiydnlpn5dm77cg18r495ay";
+       libraryHaskellDepends = [
+         base base16-bytestring base64-bytestring bytestring Cabal
+         containers cryptohash-sha256 directory ed25519 filepath ghc-prim
+         mtl network network-uri parsec pretty tar template-haskell time
+         transformers zlib
+       ];
+       testHaskellDepends = [
+         base bytestring Cabal containers network-uri QuickCheck tar tasty
+         tasty-hunit tasty-quickcheck temporary time zlib
+       ];
+       description = "Hackage security library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hackage-security" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, base64-bytestring
      , bytestring, Cabal, containers, cryptohash-sha256, directory
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "haddock_2_23_1" = callPackage
+    ({ mkDerivation, base, filepath, haddock-api }:
+     mkDerivation {
+       pname = "haddock";
+       version = "2.23.1";
+       sha256 = "129lwai4609f910h7yhmmm1rbqzjla9rcg5dpzqihydsjyw5ii1s";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [ base haddock-api ];
+       testHaskellDepends = [ base filepath ];
+       doCheck = false;
+       preCheck = "unset GHC_PACKAGE_PATH";
+       description = "A documentation-generation tool for Haskell libraries";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "haddock" = callPackage
     ({ mkDerivation, base, filepath, haddock-api }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "haddock-api_2_22_0" = callPackage
-    ({ mkDerivation, array, base, bytestring, Cabal, containers
-     , deepseq, directory, filepath, ghc, ghc-boot, ghc-paths
-     , haddock-library, hspec, hspec-discover, QuickCheck, transformers
-     , xhtml
+  "haddock-api_2_23_1" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, deepseq
+     , directory, filepath, ghc, ghc-boot, ghc-paths, haddock-library
+     , hspec, hspec-discover, QuickCheck, transformers, xhtml
      }:
      mkDerivation {
        pname = "haddock-api";
-       version = "2.22.0";
-       sha256 = "149q4zlf4m7wcrr4af2n2flh0jxjsypshbc229vsj1m0kmz4z014";
+       version = "2.23.1";
+       sha256 = "14dl17ajlr8354rmc49w4fsqxmrn0dl7wps3r4iipms5nhj5bm3d";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         array base bytestring Cabal containers deepseq directory filepath
-         ghc ghc-boot ghc-paths haddock-library transformers xhtml
+         array base bytestring containers deepseq directory filepath ghc
+         ghc-boot ghc-paths haddock-library transformers xhtml
        ];
        testHaskellDepends = [
-         array base bytestring Cabal containers deepseq directory filepath
-         ghc ghc-boot ghc-paths haddock-library hspec QuickCheck
-         transformers xhtml
+         array base bytestring containers deepseq directory filepath ghc
+         ghc-boot ghc-paths haddock-library hspec QuickCheck transformers
+         xhtml
        ];
        testToolDepends = [ hspec-discover ];
        description = "A documentation-generation tool for Haskell libraries";
···
     ({ mkDerivation, base, containers, random }:
      mkDerivation {
        pname = "hanabi-dealer";
-       version = "0.8.0.0";
-       sha256 = "0rlp5s8pgn9m7yblqpnjh2z7sy88m5zh7makjfvnxlrcl0bx0c52";
+       version = "0.9.0.0";
+       sha256 = "0bh2j0iz55g633lgm9zzlgq6419p0aabcpbhq1p7gj1bf7s2l1wm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers random ];
···
      , containers, data-default, deepseq, filepath, hashable
      , haskoin-core, haskoin-node, hedis, hspec, hspec-discover
      , http-types, monad-logger, mtl, network, nqe, optparse-applicative
-     , QuickCheck, random, resourcet, rocksdb-haskell, rocksdb-query
-     , scotty, string-conversions, text, time, transformers, unliftio
+     , QuickCheck, random, rocksdb-haskell, rocksdb-query, scotty
+     , string-conversions, text, time, transformers, unliftio
      , unordered-containers, wai, warp
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.21.2";
-       sha256 = "0316bipi2y9ylac4yw1sm9xn8zid0cjr620qmhlk4cy4qhbgqfrz";
+       version = "0.22.2";
+       sha256 = "0h073f67rhp4w78lnn7vgg0v2i5p6cv1af16b80g3a55bd6mwkla";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bytestring cereal conduit containers data-default
          deepseq hashable haskoin-core haskoin-node hedis http-types
-         monad-logger mtl network nqe QuickCheck random resourcet
-         rocksdb-haskell rocksdb-query scotty string-conversions text time
-         transformers unliftio unordered-containers wai warp
+         monad-logger mtl network nqe random rocksdb-haskell rocksdb-query
+         scotty string-conversions text time transformers unliftio
+         unordered-containers wai warp
        ];
        executableHaskellDepends = [
          aeson base bytestring cereal conduit containers data-default
-         deepseq filepath hashable haskoin-core haskoin-node hedis
-         http-types monad-logger mtl network nqe optparse-applicative
-         QuickCheck random resourcet rocksdb-haskell rocksdb-query scotty
-         string-conversions text time transformers unliftio
-         unordered-containers wai warp
+         deepseq filepath hashable haskoin-core monad-logger mtl nqe
+         optparse-applicative random string-conversions text time
+         transformers unliftio unordered-containers
        ];
        testHaskellDepends = [
          aeson base bytestring cereal conduit containers data-default
          deepseq hashable haskoin-core haskoin-node hedis hspec http-types
-         monad-logger mtl network nqe QuickCheck random resourcet
-         rocksdb-haskell rocksdb-query scotty string-conversions text time
-         transformers unliftio unordered-containers wai warp
+         monad-logger mtl network nqe QuickCheck random rocksdb-haskell
+         rocksdb-query scotty string-conversions text time transformers
+         unliftio unordered-containers wai warp
        ];
        testToolDepends = [ hspec-discover ];
        description = "Storage and index for Bitcoin and Bitcoin Cash";
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
+     }) {inherit (pkgs) blas; liblapack = null;};
 
   "hblock" = callPackage
     ({ mkDerivation, aeson, base, blaze-markup, bytestring, cereal
···
 
   "hid-examples" = callPackage
     ({ mkDerivation, aeson, base, blaze-html, bytestring, cassava
-     , Chart, Chart-diagrams, data-default, directory, doctest, extra
-     , filepath, fmt, hedgehog, hint, http-client, mtl
-     , optparse-applicative, random, req, safe, safe-exceptions, split
-     , system-locale, tasty, tasty-golden, tasty-hedgehog, tasty-hspec
-     , text, time, transformers, unix-compat
+     , Chart, Chart-diagrams, containers, criterion, deepseq, directory
+     , doctest, extra, filepath, fingertree, fmt, hedgehog, hint
+     , http-client, mtl, optparse-applicative, random, req, safe
+     , safe-exceptions, split, tasty, tasty-golden, tasty-hedgehog
+     , tasty-hspec, text, time, transformers, unix-compat
      }:
      mkDerivation {
        pname = "hid-examples";
-       version = "0.4";
-       sha256 = "11r2ln131axkw31afki3jnrz1md668z0qnvx915qwyppga62rk8l";
+       version = "0.5";
+       sha256 = "1hs0cpls8x89dvv0ws1swagz92vrfcn84nw7jdaidc850168dygx";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base hedgehog safe safe-exceptions split
+         base fingertree hedgehog safe safe-exceptions split
        ];
        executableHaskellDepends = [
          aeson base blaze-html bytestring cassava Chart Chart-diagrams
-         data-default directory extra filepath fmt hedgehog hint http-client
-         mtl optparse-applicative random req safe safe-exceptions
-         system-locale text time transformers unix-compat
+         containers directory extra filepath fmt hedgehog hint http-client
+         mtl optparse-applicative random req safe safe-exceptions text time
+         transformers unix-compat
        ];
        testHaskellDepends = [
          base doctest filepath hedgehog tasty tasty-golden tasty-hedgehog
          tasty-hspec
        ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
        doHaddock = false;
        description = "Examples to accompany the book \"Haskell in Depth\"";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) liblapack;};
+     }) {liblapack = null;};
 
   "hmatrix-csv" = callPackage
     ({ mkDerivation, base, bytestring, cassava, hmatrix, vector }:
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
+     }) {inherit (pkgs) blas; liblapack = null;};
 
   "hmatrix-nipals" = callPackage
     ({ mkDerivation, base, hmatrix }:
···
      }) {};
 
   "hsebaysdk" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, http-client, http-types
-     , text, time, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "hsebaysdk";
-       version = "0.4.0.0";
-       sha256 = "00c9vwlmx4i2a436ajznv1bwaqj5lgq05gpc928vn59v27gx0f07";
-       libraryHaskellDepends = [
-         aeson base bytestring http-client http-types text time transformers
-         unordered-containers
-       ];
-       description = "Haskell eBay SDK";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hsebaysdk_0_4_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client
      , http-client-tls, http-types, text, time, transformers
      , unordered-containers
···
        ];
        description = "Haskell eBay SDK";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hsemail" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) blas; inherit (pkgs) gsl; 
-         inherit (pkgs) liblapack;};
+     }) {inherit (pkgs) blas; inherit (pkgs) gsl; liblapack = null;};
 
   "hsilop" = callPackage
     ({ mkDerivation, base, directory, filepath, haskeline, xdg-basedir
···
      }) {};
 
        pname = "limp";
-    ({ mkDerivation, base, base64-bytestring, bytestring, containers
-       pname = "limp";
-       pname = "limp";
+    ({ mkDerivation, async, base, base64-bytestring, bytestring
+     , connection, containers, directory, filepath, http-client
+     , http-client-tls, http-types, network-uri, process, text
+     , xml-conduit, zlib
      }:
      mkDerivation {
        pname = "limp";
-       version = "1.3.0.0";
-       pname = "limp";
+       version = "1.4.1.0";
+       sha256 = "1n7688m5n5f62h59jjh2w5aa4ir87ni3x9wqnkc902crsqrgj2js";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
+         async base base64-bytestring bytestring connection containers
+         directory filepath http-client http-client-tls http-types
+         network-uri process text xml-conduit zlib
        ];
+       executableHaskellDepends = [ base directory network-uri ];
        pname = "limp";
        license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "limp";
-       version = "0.3.0.5";
-       pname = "limp";
-       libraryHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-       pname = "limp";
-       ];
-       doHaddock = false;
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
        version = "0.3.1.0";
        pname = "limp";
        libraryHaskellDepends = [
···
        doHaddock = false;
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       libraryHaskellDepends = [
-       pname = "limp";
-         vector
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       pname = "limp";
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        pname = "limp";
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
        pname = "limp";
···
 
        pname = "limp";
        pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.2.0.6";
-       pname = "limp";
-       libraryHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testHaskellDepends = [ base bytestring conduit hspec ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-       pname = "limp";
-       ];
-       description = "Conduits for tokenizing streams";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
        pname = "limp";
        pname = "limp";
        pname = "limp";
···
        ];
        description = "Conduits for tokenizing streams";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-     , mtl, QuickCheck
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.2.0.0";
-       pname = "limp";
-       revision = "1";
-       pname = "limp";
-       pname = "limp";
-       testHaskellDepends = [
-       pname = "limp";
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ hspec-discover ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.0.0.7";
-       pname = "limp";
-       libraryHaskellDepends = [ base ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ doctest-discover ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.4.0";
-       pname = "limp";
-       revision = "2";
-       pname = "limp";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       executableHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
        pname = "limp";
···
 
        pname = "limp";
     ({ mkDerivation, base, binary, bytestring, criterion, deepseq
-     , generic-lens, hedgehog, hspec, hspec-discover, hw-bits
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.1.1.1";
-       pname = "limp";
-       revision = "1";
-       pname = "limp";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       executableHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-       pname = "limp";
-    ({ mkDerivation, base, binary, bytestring, criterion, deepseq
        pname = "limp";
        pname = "limp";
        pname = "limp";
···
        ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     , vector
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.2.2.3";
-       pname = "limp";
-       revision = "1";
-       pname = "limp";
-       libraryHaskellDepends = [
-       pname = "limp";
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-       pname = "limp";
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.1.1.1";
-       pname = "limp";
-       pname = "limp";
-       testHaskellDepends = [
-       pname = "limp";
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Generic finger-tree structure, with example instances";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ doctest-discover hspec-discover ];
        description = "Generic finger-tree structure, with example instances";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     , test-framework-hunit, test-framework-quickcheck2
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.1.1.3";
-       pname = "limp";
-       revision = "1";
-       pname = "limp";
-       libraryHaskellDepends = [ base deepseq ];
-       testHaskellDepends = [
-       pname = "limp";
-         test-framework test-framework-hunit test-framework-quickcheck2
-       ];
-       testToolDepends = [ hspec-discover ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ doctest-discover hspec-discover ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-     mkDerivation {
-       pname = "limp";
-       version = "0.1.0.5";
-       pname = "limp";
-       pname = "limp";
-       testHaskellDepends = [ base ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ doctest-discover ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.1.0.9";
-       pname = "limp";
-       libraryHaskellDepends = [
-       pname = "limp";
-       ];
-       pname = "limp";
-       testToolDepends = [ hspec-discover ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ doctest-discover hspec-discover ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "0.0.0.4";
-       pname = "limp";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [
-       pname = "limp";
-       ];
-       testToolDepends = [ hspec-discover ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        testToolDepends = [ doctest-discover hspec-discover ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     , optparse-applicative, text
-     }:
-     mkDerivation {
-       pname = "limp";
-       version = "2.4.1.0";
-       pname = "limp";
-       revision = "1";
-       pname = "limp";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-       pname = "limp";
-       ];
-       executableHaskellDepends = [
-       pname = "limp";
-         text
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       doHaddock = false;
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        doHaddock = false;
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
-       pname = "limp";
-    ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-     }:
-     mkDerivation {
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       ];
-       executableHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-         text vector
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       pname = "limp";
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-       pname = "limp";
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
      }) {};
 
        pname = "limp";
···
        ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-json-lens" = callPackage
···
      }) {};
 
   "hw-json-simd" = callPackage
-    ({ mkDerivation, base, bytestring, c2hs, hw-prim, lens
-     , optparse-applicative, vector
-     }:
-     mkDerivation {
-       pname = "hw-json-simd";
-       version = "0.1.0.4";
-       sha256 = "1qpk7vzya28y56qlb2fmx3ic39n9x2z8dh932rn0fp2d8n4dw8sa";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base bytestring hw-prim lens vector ];
-       libraryToolDepends = [ c2hs ];
-       executableHaskellDepends = [
-         base bytestring hw-prim lens optparse-applicative vector
-       ];
-       testHaskellDepends = [ base bytestring hw-prim lens vector ];
-       description = "SIMD-based JSON semi-indexer";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-json-simd_0_1_1_0" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, doctest, doctest-discover
      , hw-prim, lens, optparse-applicative, transformers, vector
      }:
···
        testToolDepends = [ doctest-discover ];
        description = "SIMD-based JSON semi-indexer";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-json-simple-cursor" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, directory
-     , generic-lens, hedgehog, hspec, hspec-discover, hw-balancedparens
-     , hw-bits, hw-hspec-hedgehog, hw-json-simd, hw-prim, hw-rankselect
-     , hw-rankselect-base, lens, mmap, optparse-applicative, text
-     , vector, word8
-     }:
-     mkDerivation {
-       pname = "hw-json-simple-cursor";
-       version = "0.1.0.2";
-       sha256 = "1yknymn8flni5bkfifaxmkv6b6r530ljvm6vx9m3kqwzikly9lpn";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring hw-balancedparens hw-bits hw-prim hw-rankselect
-         hw-rankselect-base vector word8
-       ];
-       executableHaskellDepends = [
-         base bytestring generic-lens hw-balancedparens hw-json-simd hw-prim
-       pname = "limp";
-         text vector
-       ];
-       testHaskellDepends = [
-         base bytestring hedgehog hspec hw-balancedparens hw-bits
-         hw-hspec-hedgehog hw-prim hw-rankselect hw-rankselect-base vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion directory mmap
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-json-simple-cursor_0_1_1_0" = callPackage
     ({ mkDerivation, base, bytestring, criterion, directory, doctest
        pname = "limp";
        pname = "limp";
···
        ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-json-standard-cursor" = callPackage
···
      }:
      mkDerivation {
        pname = "hw-json-standard-cursor";
-       version = "0.2.1.3";
-       sha256 = "1809nrw3wlbsysq3dxq9igg2yi3qafkv34jx3vn7qq5rw541qlxv";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base bits-extra bytestring hw-balancedparens hw-bits
-         hw-json-simd hw-prim hw-rankselect hw-rankselect-base mmap vector
-         word8
-       ];
-       executableHaskellDepends = [
-         base bytestring generic-lens hw-balancedparens hw-json-simd hw-prim
-       pname = "limp";
-         text vector
-       ];
-       testHaskellDepends = [
-       pname = "limp";
-         hw-balancedparens hw-bits hw-hspec-hedgehog hw-prim hw-rankselect
-       pname = "limp";
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion directory mmap
-       ];
-       pname = "limp";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-json-standard-cursor_0_2_2_0" = callPackage
-    ({ mkDerivation, array, base, bits-extra, bytestring, criterion
-     , directory, doctest, doctest-discover, generic-lens, hedgehog
-     , hspec, hspec-discover, hw-balancedparens, hw-bits
-     , hw-hspec-hedgehog, hw-json-simd, hw-prim, hw-rankselect
-     , hw-rankselect-base, lens, mmap, optparse-applicative, text
-     , vector, word8
-     }:
-     mkDerivation {
-       pname = "hw-json-standard-cursor";
        version = "0.2.2.0";
        sha256 = "0rj0p3p2b5ghyyfkzvaivzcdsmnjxvqm16n94qpwacaszyca8hny";
        isLibrary = true;
···
        ];
        pname = "limp";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-kafka-avro" = callPackage
···
      }) {};
 
   "hw-mquery" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, dlist, hedgehog, hspec
-     , hspec-discover, hw-hspec-hedgehog, lens, semigroups
-     }:
-     mkDerivation {
-       pname = "hw-mquery";
-       version = "0.2.0.2";
-       sha256 = "1vcxyin3cyc0pkhbfjyjm4r44yxk17gny5jhfg6hdlgivp150yij";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         ansi-wl-pprint base dlist lens semigroups
-       ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base dlist hedgehog hspec hw-hspec-hedgehog lens
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Monadic query DSL";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-mquery_0_2_1_0" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, dlist, doctest
      , doctest-discover, hedgehog, hspec, hspec-discover
      , hw-hspec-hedgehog, lens
···
        testToolDepends = [ doctest-discover hspec-discover ];
        description = "Monadic query DSL";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-packed-vector" = callPackage
     ({ mkDerivation, base, binary, bytestring, criterion, deepseq
-     , directory, generic-lens, hedgehog, hspec, hspec-discover, hw-bits
-     , hw-hedgehog, hw-hspec-hedgehog, hw-prim, lens
-     , optparse-applicative, vector
-     }:
-     mkDerivation {
-       pname = "hw-packed-vector";
-       version = "0.2.0.1";
-       sha256 = "12181b9fp11cdgf6xngjla9012j8rag3zcssz70x5a7xxgnwfmfc";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring deepseq hw-bits hw-prim vector
-       ];
-       executableHaskellDepends = [
-         base binary bytestring generic-lens hw-bits hw-prim lens
-       pname = "limp";
-       ];
-       testHaskellDepends = [
-         base bytestring hedgehog hspec hw-bits hw-hedgehog
-       pname = "limp";
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base criterion directory hedgehog hspec hw-prim vector
-       ];
-       description = "Packed Vector";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-packed-vector_0_2_1_0" = callPackage
-    ({ mkDerivation, base, binary, bytestring, criterion, deepseq
      , directory, doctest, doctest-discover, generic-lens, hedgehog
      , hspec, hspec-discover, hw-bits, hw-hedgehog, hw-hspec-hedgehog
      , hw-prim, lens, optparse-applicative, vector
···
        ];
        description = "Packed Vector";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-parser" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, hedgehog, hspec
-     , hspec-discover, hw-hspec-hedgehog, hw-prim, text
-     }:
-     mkDerivation {
-       pname = "hw-parser";
-       version = "0.1.0.2";
-       sha256 = "170dk943s2jbqqggxxfjxj23fbfk1532hgsrg63mr0v1ag9hlz1i";
-       libraryHaskellDepends = [
-         attoparsec base bytestring hw-prim text
-       ];
-       testHaskellDepends = [ base hedgehog hspec hw-hspec-hedgehog ];
-       testToolDepends = [ hspec-discover ];
-       description = "Simple parser support";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-parser_0_1_1_0" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, doctest
      , doctest-discover, hedgehog, hspec, hspec-discover
      , hw-hspec-hedgehog, hw-prim, text
···
        testToolDepends = [ doctest-discover hspec-discover ];
        description = "Simple parser support";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-prim" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deepseq, directory
      , doctest, doctest-discover, exceptions, ghc-prim, hedgehog, hspec
-     , hspec-discover, hw-hspec-hedgehog, mmap, QuickCheck, semigroups
-     , transformers, unliftio-core, vector
-     }:
-     mkDerivation {
-       pname = "hw-prim";
-       version = "0.6.2.40";
-       sha256 = "0vm5mcnlb5yas2z7rvzd1kzv39d3qw4bkrkfmv0i7vsdg33yb3fd";
-       revision = "3";
-       editedCabalFile = "14a8a1rfczi196nka364w6prjx1zddwf1iq265w5qcl0d1jmj679";
-       libraryHaskellDepends = [
-         base bytestring deepseq ghc-prim mmap semigroups transformers
-         unliftio-core vector
-       ];
-       testHaskellDepends = [
-         base bytestring directory doctest doctest-discover exceptions
-         hedgehog hspec hw-hspec-hedgehog mmap QuickCheck semigroups
-         transformers vector
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion mmap semigroups transformers vector
-       ];
-       description = "Primitive functions and data types";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-prim_0_6_3_0" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deepseq, directory
-     , doctest, doctest-discover, exceptions, ghc-prim, hedgehog, hspec
      , hspec-discover, hw-hspec-hedgehog, mmap, QuickCheck, transformers
      , unliftio-core, vector
      }:
···
        ];
        description = "Primitive functions and data types";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-prim-bits" = callPackage
···
      }:
      mkDerivation {
        pname = "hw-rankselect";
-       version = "0.13.3.2";
-       sha256 = "1p4b5nm8mgxlc7p5gcwh6dy85xgydpbw999zv27755dbfcv9nk4v";
-       revision = "2";
-       editedCabalFile = "13j391km170abxa74l5vda6aw1ad409p74yyxanizz97cjhjwdwb";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base deepseq hedgehog hspec hw-balancedparens hw-bits hw-fingertree
-         hw-prim hw-rankselect-base vector
-       ];
-       executableHaskellDepends = [
-         base directory generic-lens hw-bits hw-prim hw-rankselect-base lens
-         mmap mtl optparse-applicative vector
-       ];
-       testHaskellDepends = [
-         base directory doctest doctest-discover hedgehog hspec hw-bits
-         hw-hedgehog hw-hspec-hedgehog hw-prim hw-rankselect-base mmap
-         QuickCheck transformers vector
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring conduit criterion directory hw-bits hw-prim
-         hw-rankselect-base mmap resourcet vector
-       ];
-       doHaddock = false;
-       description = "Rank-select";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-rankselect_0_13_4_0" = callPackage
-    ({ mkDerivation, base, bytestring, conduit, criterion, deepseq
-     , 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 {
-       pname = "hw-rankselect";
        version = "0.13.4.0";
        sha256 = "0chk3n4vb55px943w0l3q7pxhgbvqm64vn7lkhi7k0l2dpybycp7";
        isLibrary = true;
···
        doHaddock = false;
        description = "Rank-select";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-rankselect-base" = callPackage
-    ({ mkDerivation, base, bits-extra, bitvec, criterion, hedgehog
-     , hspec, hspec-discover, hw-bits, hw-hedgehog, hw-hspec-hedgehog
-     , hw-int, hw-prim, hw-string-parse, QuickCheck, vector
-     }:
-     mkDerivation {
-       pname = "hw-rankselect-base";
-       version = "0.3.3.0";
-       sha256 = "17h4kmi9zcgm4sdpbmqh6rzygz7w0v95lfc6rmhc9a8bmmg30i5b";
-       revision = "1";
-       editedCabalFile = "03svpzjia8mbgy33lhmjhwpd6yq0n97l3fkmfnpyi3blc3yb3bd0";
-       libraryHaskellDepends = [
-         base bits-extra bitvec hw-bits hw-int hw-prim hw-string-parse
-         vector
-       ];
-       testHaskellDepends = [
-         base bits-extra bitvec hedgehog hspec hw-bits hw-hedgehog
-       pname = "limp";
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bits-extra criterion hw-bits hw-prim vector
-       ];
-       description = "Rank-select base";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-rankselect-base_0_3_4_0" = callPackage
     ({ mkDerivation, base, bits-extra, bitvec, criterion, doctest
        pname = "limp";
      , hw-hedgehog, hw-hspec-hedgehog, hw-int, hw-prim, hw-string-parse
···
        ];
        description = "Rank-select base";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-simd" = callPackage
     ({ mkDerivation, base, bits-extra, bytestring, c2hs, cassava
-     , containers, criterion, deepseq, directory, hedgehog, hspec
-     , hspec-discover, hw-bits, hw-hedgehog, hw-hspec-hedgehog, hw-prim
-     , hw-rankselect, hw-rankselect-base, lens, mmap, text, vector
-     }:
-     mkDerivation {
-       pname = "hw-simd";
-       version = "0.1.1.5";
-       sha256 = "0nhy3hi7gxbbjwh6rj4459nzbmlij2cjdg2zvdjgx3z3j5algqyb";
-       libraryHaskellDepends = [
-         base bits-extra bytestring deepseq hw-bits hw-prim hw-rankselect
-       pname = "limp";
-       ];
-       libraryToolDepends = [ c2hs ];
-       testHaskellDepends = [
-         base bits-extra bytestring deepseq directory hedgehog hspec hw-bits
-         hw-hedgehog hw-hspec-hedgehog hw-prim hw-rankselect
-         hw-rankselect-base lens text vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bits-extra bytestring cassava containers criterion deepseq
-         directory hw-bits hw-prim hw-rankselect hw-rankselect-base mmap
-         vector
-       ];
-       description = "SIMD library";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-simd_0_1_2_0" = callPackage
-    ({ mkDerivation, base, bits-extra, bytestring, c2hs, cassava
      , containers, criterion, deepseq, directory, doctest
        pname = "limp";
      , hw-hedgehog, hw-hspec-hedgehog, hw-prim, hw-rankselect
···
        ];
        description = "SIMD library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-streams" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, directory, exceptions
-     , ghc-prim, hedgehog, hspec, hspec-discover, hw-bits
-     , hw-hspec-hedgehog, hw-prim, mmap, primitive, QuickCheck
-     , semigroups, transformers, vector
-     }:
-     mkDerivation {
-       pname = "hw-streams";
-       version = "0.0.0.12";
-       sha256 = "087sn4gxhf29vg9ydx8sfq33q16cz6cmda5r63k9xdki4ba761m4";
-       revision = "1";
-       editedCabalFile = "1y5sw9mgkxwvgf91hl22p3q5kxy99phwfmx2lh87339w7d5bjdbw";
-       libraryHaskellDepends = [
-         base bytestring ghc-prim hw-bits hw-prim mmap primitive semigroups
-         transformers vector
-       ];
-       testHaskellDepends = [
-         base bytestring directory exceptions ghc-prim hedgehog hspec
-         hw-bits hw-hspec-hedgehog hw-prim mmap primitive QuickCheck
-         semigroups transformers vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion ghc-prim hw-bits hw-prim mmap primitive
-         semigroups transformers vector
-       ];
-       description = "Primitive functions and data types";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-streams_0_0_1_0" = callPackage
     ({ mkDerivation, base, bytestring, criterion, directory, doctest
      , doctest-discover, exceptions, ghc-prim, hedgehog, hspec
      , hspec-discover, hw-bits, hw-hspec-hedgehog, hw-prim, mmap
···
        ];
        description = "Primitive functions and data types";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hw-string-parse" = callPackage
···
 
   "hw-xml" = callPackage
     ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base
-     , bytestring, cereal, containers, criterion, deepseq, generic-lens
-     , ghc-prim, hedgehog, hspec, hspec-discover, hw-balancedparens
-     , hw-bits, hw-hspec-hedgehog, hw-parser, hw-prim, hw-rankselect
-     , hw-rankselect-base, lens, mmap, mtl, optparse-applicative
-     , resourcet, text, transformers, vector, word8
-     }:
-     mkDerivation {
-       pname = "hw-xml";
-       version = "0.5.0.0";
-       sha256 = "0cqrs19bd9yh67yczhhb1yf5dhcx2v6xikybd88vqwxdh51pxyyn";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         ansi-wl-pprint array attoparsec base bytestring cereal containers
-         deepseq ghc-prim hw-balancedparens hw-bits hw-parser hw-prim
-         hw-rankselect hw-rankselect-base lens mmap mtl resourcet text
-         transformers vector word8
-       ];
-       executableHaskellDepends = [
-         attoparsec base bytestring deepseq generic-lens hw-balancedparens
-         hw-bits hw-prim hw-rankselect lens mmap mtl optparse-applicative
-         resourcet text vector
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring hedgehog hspec hw-balancedparens hw-bits
-         hw-hspec-hedgehog hw-prim hw-rankselect hw-rankselect-base text
-         vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion hw-balancedparens hw-bits hw-prim mmap
-         resourcet vector
-       ];
-       description = "XML parser based on succinct data structures";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hw-xml_0_5_1_0" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base
      , bytestring, cereal, containers, criterion, deepseq, doctest
      , doctest-discover, generic-lens, ghc-prim, hedgehog, hspec
      , hspec-discover, hw-balancedparens, hw-bits, hw-hspec-hedgehog
···
        ];
        description = "XML parser based on succinct data structures";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hwall-auth-iitk" = callPackage
···
        pname = "hyraxAbif";
        version = "0.2.3.21";
        sha256 = "0ghhfv8gzs9sg13nj3mhqd24zbrkjj1dgsjz3sql6276kpa1p2kc";
-       revision = "1";
-       editedCabalFile = "0rg4wldliyaixmgcyina2cnm7l6gwpcdd2bim1q83clnfk32scar";
+       revision = "2";
+       editedCabalFile = "05fnq87n1rprz3mlw89g74b1arzhldn8yqj3la04g3r3m39fh2v1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "insert-ordered-containers";
-       version = "0.2.3";
-       sha256 = "1307v5w8lzxc1pmi5dvw1d2vmfs6z253xbr0nfzcgxfjmqvj60ik";
-       libraryHaskellDepends = [
-         aeson base base-compat hashable lens optics-core optics-extra
-         semigroupoids semigroups text transformers unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base base-compat hashable lens QuickCheck semigroupoids
-         semigroups tasty tasty-quickcheck text transformers
-         unordered-containers
-       ];
-       description = "Associative containers retaining insertion order for traversals";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "insert-ordered-containers_0_2_3_1" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, hashable, lens
-     , optics-core, optics-extra, QuickCheck, semigroupoids, semigroups
-     , tasty, tasty-quickcheck, text, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "insert-ordered-containers";
        version = "0.2.3.1";
        sha256 = "020a56280mxjk9k97q2m1424m73m1sf1ccl0wm0ci9msyw2g51za";
        libraryHaskellDepends = [
···
        ];
        description = "Associative containers retaining insertion order for traversals";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "inserts" = callPackage
···
     ({ mkDerivation, base, binary, bytestring, iproute }:
      mkDerivation {
        pname = "ip2location";
-       version = "8.2.0";
-       sha256 = "01ia5647y608xr5kqkxaamhaxs39k3x81wpj8aqzf24mirkalf23";
+       version = "8.2.1";
+       sha256 = "1ccr15yn2ska5wgwlcnfpi9w1xxkly0pwqibmdl9a1ggmwfsskv0";
        libraryHaskellDepends = [ base binary bytestring iproute ];
        description = "IP2Location Haskell package for IP geolocation";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, binary, bytestring, iproute }:
      mkDerivation {
        pname = "ip2proxy";
-       version = "2.2.0";
-       sha256 = "12j8jd0ir24xgghvmac2npf9zqfbfq7fwj1ni2xdi8p673k3d0kd";
+       version = "2.2.1";
+       sha256 = "08ywvg39n59i8p66fpapcpj722lkam7pyd38525p3w4z735d8842";
        libraryHaskellDepends = [ base binary bytestring iproute ];
        description = "IP2Proxy Haskell package for proxy detection";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, mtl, profunctors }:
      mkDerivation {
        pname = "iso-deriving";
-       version = "0.0.6";
-       sha256 = "1kcbz4dndrxhkyx67l1z4363rizbqnwnrgcw3kbm5p5zmr914v3h";
-       libraryHaskellDepends = [ base profunctors ];
+       version = "0.0.8";
+       sha256 = "1w9fvnyanzmxs7yab9qhf3k9qy1lik7y5y5gzfv3jrxzwm0hivbi";
+       libraryHaskellDepends = [ base mtl profunctors ];
        testHaskellDepends = [ base mtl ];
        description = "Deriving via arbitrary isomorphisms";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "json-autotype";
-       version = "3.0.5";
-       sha256 = "0kvbx4iyhh2r0abnswbvf862xfj08jlgvdd21xiz4zpnp2d1fx0h";
+       version = "3.1.2";
+       sha256 = "1wg1198jwgiy6yxr0msz1cvrkkv3zjx72ck3cykddy2hwx55113g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "krank" = callPackage
-    ({ mkDerivation, aeson, base, hspec, megaparsec, mtl
-     , optparse-applicative, PyF, replace-megaparsec, req
-     , safe-exceptions, text, unordered-containers, utf8-string
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec
+     , hspec-expectations, http-client, http-types, lifted-async, mtl
+     , optparse-applicative, pcre-heavy, pretty-terminal, PyF, req
+     , safe-exceptions, text, unordered-containers
      }:
      mkDerivation {
        pname = "krank";
-       version = "0.1.0";
-       sha256 = "121010sm7a2ggi1s75cy4f68z4nr2dp1i9cxq6snzbkl3dv5mmys";
+       version = "0.2.0";
+       sha256 = "0m41vyfzis6v0x7yys7xwr8yi04fydg6x2d04ispmi8mqjx0vgww";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base megaparsec mtl PyF replace-megaparsec req
-         safe-exceptions text unordered-containers utf8-string
+         aeson base bytestring containers http-client http-types
+         lifted-async mtl pcre-heavy pretty-terminal PyF req safe-exceptions
+         text unordered-containers
        ];
        executableHaskellDepends = [
-         base mtl optparse-applicative PyF safe-exceptions text
+         base containers mtl optparse-applicative pcre-heavy pretty-terminal
+         PyF text
        ];
-       testHaskellDepends = [ base hspec megaparsec PyF ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec hspec-expectations
+         http-client http-types mtl pcre-heavy PyF req safe-exceptions text
+         unordered-containers
+       ];
        description = "Krank checks your code source comments for important markers";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "language-bash";
-       version = "0.9.0";
-       sha256 = "1n4icdd478b1j0rr79qyxx2g4xm8yvsplfw3mkdsskb79zmq5gga";
+       version = "0.9.2";
+       sha256 = "0pkl0cvkxhlpx492qlklizc27xw3yax6n8h27xq3bw1vlk3c0a36";
        libraryHaskellDepends = [ base parsec prettyprinter transformers ];
        testHaskellDepends = [
          base directory filepath parsec process QuickCheck tasty
···
        libraryPkgconfigDepends = [ liblapack ];
        description = "Auto-generated interface to Fortran LAPACK";
        license = stdenv.lib.licenses.bsd3;
-     }) {inherit (pkgs) liblapack;};
+     }) {liblapack = null;};
 
   "lapack-ffi-tools" = callPackage
     ({ mkDerivation, base, bytestring, cassava, containers
···
      }:
      mkDerivation {
        pname = "launchdarkly-server-sdk";
-       version = "1.0.4";
-       sha256 = "1g2qq1ncix5n4w8bshmmwi8km3ph1ys1s31l0fa3imjmz9fsi1l1";
+       version = "2.0.0";
+       sha256 = "0dfs9nq3vcf8w2k1x51pixb4wb47rg9nzyjgfpzx6vip296ivyf7";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring
          bytestring-conversion clock containers cryptohash exceptions extra
···
          base containers deepseq hmatrix random-fu random-source vector
        ];
        description = "Yet another library for hidden Markov models";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "leb128" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, deepseq, ghc-prim
+     , QuickCheck, test-framework, test-framework-quickcheck2
+     , transformers
+     }:
+     mkDerivation {
+       pname = "leb128";
+       version = "0.1.0.0";
+       sha256 = "097xzdj1q17whnzwlpwnfapppgc4lqwmmfcv2694gzlil84rqwk7";
+       libraryHaskellDepends = [ base bytestring ghc-prim transformers ];
+       testHaskellDepends = [
+         base bytestring QuickCheck test-framework
+         test-framework-quickcheck2
+       ];
+       benchmarkHaskellDepends = [ base bytestring criterion deepseq ];
+       description = "LEB128 encoding logic for and in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "leb128-cereal" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, tasty, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "leb128-cereal";
+       version = "1.0";
+       sha256 = "1qjxcvcgdf4l1wzps7410yv3i5mi3ax17mq2f9wgbfbnm33329i7";
+       libraryHaskellDepends = [ base bytestring cereal ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "LEB128 and SLEB128 encoding";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }) {};
 
   "maquinitas-tidal" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation, base, tidal }:
      mkDerivation {
        pname = "maquinitas-tidal";
-       version = "0.2.1";
-       sha256 = "14j4469yl1ypw97m33r2v37mlqxa689ish84k7ggwjdqxj9f64n2";
-       libraryHaskellDepends = [ base ];
+       version = "0.2.4";
+       sha256 = "0apr5qkir3b6mnczi50lf3p349p1q3bl1sn4yg9dls2n3m147mf7";
+       libraryHaskellDepends = [ base tidal ];
        description = "library for MIDI control of hardware";
        license = stdenv.lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "microlens-th";
-       version = "0.4.3.4";
-       sha256 = "08cixz1840ycc1y2b8anf1pqzlhnh89i6wskixd5s5brf8jl0l79";
-       libraryHaskellDepends = [
-         base containers microlens template-haskell th-abstraction
-         transformers
-       ];
-       testHaskellDepends = [ base microlens ];
-       description = "Automatic generation of record lenses for microlens";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "microlens-th_0_4_3_5" = callPackage
-    ({ mkDerivation, base, containers, microlens, template-haskell
-     , th-abstraction, transformers
-     }:
-     mkDerivation {
-       pname = "microlens-th";
        version = "0.4.3.5";
        sha256 = "0zk5wi8wrhhs7chdsxc9sm57w3zrjr7c9v80qh53ac4p3varjgfh";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base microlens ];
        description = "Automatic generation of record lenses for microlens";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "micrologger" = callPackage
···
        ];
        description = "Simple English clause creation from arbitrary words";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "minizinc-process" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, directory
+     , hashable, process-extras, stringsearch, text
+     }:
+     mkDerivation {
+       pname = "minizinc-process";
+       version = "0.1.0.0";
+       sha256 = "0p2jb69k2n3dy47vx56pwh6pafccsm9r0nzqd60zss5fdrnxddf8";
+       libraryHaskellDepends = [
+         aeson base bytestring containers directory hashable process-extras
+         stringsearch text
+       ];
+       description = "A set of helpers to call minizinc models";
+       license = stdenv.lib.licenses.asl20;
      }) {};
 
   "minlen" = callPackage
···
     ({ mkDerivation, base, bytestring, c2hs, monad-loops, mpich }:
      mkDerivation {
        pname = "mpi-hs";
-       version = "0.7.1.0";
-       sha256 = "1xja12laj9pznwkgllgn2126g0izgv7mp267jv0ihlzy4yv2ps8m";
+       version = "0.7.1.2";
+       sha256 = "0dhhvvncmsg6rnb16pi1da4zb82hlwyia0l5xxqz6s7518q0amkh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring monad-loops ];
···
        broken = true;
      }) {inherit (pkgs) mpich;};
 
+  "mpi-hs-binary" = callPackage
+    ({ mkDerivation, base, binary, bytestring, monad-loops, mpi-hs }:
+     mkDerivation {
+       pname = "mpi-hs-binary";
+       version = "0.1.1.0";
+       sha256 = "10wlrm31drjgdviqzsvxlnj1mn1lli3n41z1xbfp0i80vmh29av3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base binary bytestring monad-loops mpi-hs
+       ];
+       executableHaskellDepends = [ base mpi-hs ];
+       testHaskellDepends = [ base ];
+       description = "MPI bindings for Haskell";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "mpi-hs-cereal" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, monad-loops, mpi-hs }:
+     mkDerivation {
+       pname = "mpi-hs-cereal";
+       version = "0.1.0.0";
+       sha256 = "1sdizjk4xpc2hdh71s9ckjhq22appqj1c9s10mwxjgb9vd7bz07b";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring cereal monad-loops mpi-hs
+       ];
+       executableHaskellDepends = [ base mpi-hs ];
+       testHaskellDepends = [ base ];
+       description = "MPI bindings for Haskell";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "mpi-hs-store" = callPackage
+    ({ mkDerivation, base, bytestring, monad-loops, mpi-hs, store }:
+     mkDerivation {
+       pname = "mpi-hs-store";
+       version = "0.1.0.0";
+       sha256 = "1afgamdbv7dq9r8jd7hn5y09rly75rhjk48da0d8hk0spcfdmnvq";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring monad-loops mpi-hs store
+       ];
+       executableHaskellDepends = [ base mpi-hs ];
+       testHaskellDepends = [ base ];
+       description = "MPI bindings for Haskell";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "mplayer-spot" = callPackage
     ({ mkDerivation, async, attoparsec, base, bytestring, conduit
      , conduit-extra, directory, filepath, process, semigroupoids
···
      }:
      mkDerivation {
        pname = "net-spider";
-       version = "0.4.2.0";
-       sha256 = "1jpqkwgi13a0hw99andw6f8jsq8isqsqlqjc42bapy97wxba2bii";
+       version = "0.4.3.0";
+       sha256 = "19cvghyj6val79bsq3sh9gpr1f94dmmikmgsdasf6a26vcxr1q4y";
        libraryHaskellDepends = [
          aeson base containers data-interval extended-reals greskell
          greskell-websocket hashable monad-logger regex-applicative
···
      }) {};
 
   "net-spider-rpl-cli" = callPackage
-    ({ mkDerivation, base, greskell, hspec, ip, monad-logger
-     , net-spider, net-spider-cli, net-spider-rpl, optparse-applicative
-     , text, time, unordered-containers
+    ({ mkDerivation, base, bytestring, fast-logger, fgl, greskell
+     , hashable, hspec, ip, monad-logger, net-spider, net-spider-cli
+     , net-spider-rpl, optparse-applicative, text, time, transformers
+     , unordered-containers
      }:
      mkDerivation {
        pname = "net-spider-rpl-cli";
-       version = "0.1.2.2";
-       sha256 = "1l8h3d3m7h48n6vn7lhzlisf6hqr311q1yjxxp2ywkyx1fn3s9pp";
+       version = "0.1.3.0";
+       sha256 = "1hgzrl3fq1vp4dh4c0jf9kndclcrzapd124b4c9xd20xgidy01fd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base greskell monad-logger net-spider net-spider-cli net-spider-rpl
-         optparse-applicative text time unordered-containers
+         base fgl greskell monad-logger net-spider net-spider-cli
+         net-spider-rpl optparse-applicative text time transformers
+         unordered-containers
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base hspec ip net-spider net-spider-cli net-spider-rpl
-         optparse-applicative
+         base bytestring fast-logger hashable hspec ip monad-logger
+         net-spider net-spider-cli net-spider-rpl optparse-applicative text
        ];
        description = "CLI executable of NetSpider.RPL.";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "ngx-export-tools-extra";
-       version = "0.4.1.0";
-       sha256 = "1jf49drs7jl5c5swy7pf2b00nawp3m2nf95941sr74c6y6g4y87d";
+       version = "0.4.1.1";
+       sha256 = "15d5dj8mdihj8m559lrfwwpb55nkkkapwd9x84jxsv6pmnh5m0qh";
        libraryHaskellDepends = [
          aeson ansi-wl-pprint base base64 binary bytestring case-insensitive
          containers ede enclosed-exceptions http-client http-types
···
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "2.1.0.2";
-       sha256 = "0amlvrh213n9cfqax5gcy7zq3fd8q9hcskhjkbayvzsyf5hhr1rn";
-       revision = "1";
-       editedCabalFile = "1v52rmk7hbdn40964r50jjz3lanfc5q8xrdqpv1wmwviw3j4rip8";
+       version = "2.1.0.3";
+       sha256 = "19834hldpywsg52144i9b372msmw5pcj7v0fwiii14pns4sf6v7v";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
···
        broken = true;
      }) {};
 
+  "openapi-typed" = callPackage
+    ({ mkDerivation, aeson, base, hspec, optics-core, optics-extra
+     , text, unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "openapi-typed";
+       version = "0.0.0.1";
+       sha256 = "06wbcd5cr2dfdj1hbzi01byfr2lvvv0sncjsbx9n6vq2anh54wkm";
+       libraryHaskellDepends = [
+         aeson base text unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base hspec optics-core optics-extra text unordered-containers
+         yaml
+       ];
+       description = "Types for OpenAPI";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "opench-meteo" = callPackage
     ({ mkDerivation, aeson, base, data-default, text, time }:
      mkDerivation {
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
-  "opentelemetry_0_2_0" = callPackage
-    ({ mkDerivation, async, base, bytestring, clock, directory
-     , exceptions, hashable, random, stm, tasty, tasty-discover
-     , tasty-hunit, tasty-quickcheck, text, unordered-containers
+  "opentelemetry_0_3_0" = callPackage
+    ({ mkDerivation, base, bytestring, exceptions }:
+     mkDerivation {
+       pname = "opentelemetry";
+       version = "0.3.0";
+       sha256 = "1mgq84ixi8hxhgim5d5mx6v1zc1sqrp8cffzw14rly3sfhdi1k0m";
+       libraryHaskellDepends = [ base bytestring exceptions ];
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "opentelemetry-extra" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, clock, containers
+     , directory, exceptions, filepath, ghc-events, hashable
+     , http-client, http-client-tls, http-types, opentelemetry, random
+     , scientific, splitmix, stm, tasty, tasty-discover, tasty-hunit
+     , tasty-quickcheck, text, unordered-containers
      }:
      mkDerivation {
-       pname = "opentelemetry";
-       version = "0.2.0";
-       sha256 = "1nxkghxwjkgvdk6xhpssa7aifryn6rr0agbhyc0ybf2c76r1pr8b";
+       pname = "opentelemetry-extra";
+       version = "0.3.0";
+       sha256 = "00998jr520qmr9ii96r04bspfh8cdxwk951y02ic01higqjkx6xp";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring clock directory exceptions hashable random stm text
+         aeson async base bytestring clock containers directory exceptions
+         filepath ghc-events hashable http-client http-client-tls http-types
+         opentelemetry random scientific splitmix stm text
          unordered-containers
        ];
+       executableHaskellDepends = [
+         async base clock exceptions filepath http-client http-client-tls
+         opentelemetry text
+       ];
        testHaskellDepends = [
-         async base bytestring tasty tasty-discover tasty-hunit
+         base bytestring opentelemetry tasty tasty-discover tasty-hunit
          tasty-quickcheck
        ];
        testToolDepends = [ tasty-discover ];
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "opentelemetry-http-client" = callPackage
···
      }) {};
 
   "opentelemetry-lightstep" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, exceptions
-     , http-client, http-client-tls, http-types, network, opentelemetry
-     , scientific, stm, text, unordered-containers
+    ({ mkDerivation, aeson, async, base, bytestring, clock, containers
+     , exceptions, filepath, ghc-events, http-client, http-client-tls
+     , http-types, network, opentelemetry, opentelemetry-extra
+     , scientific, splitmix, stm, text, unordered-containers
      }:
      mkDerivation {
        pname = "opentelemetry-lightstep";
-       version = "0.2.0";
-       sha256 = "03fv2lgwkqngp26rdrk2fzvnccdgjc7xsv3sl3adb3xwzppkn0xh";
+       version = "0.3.0";
+       sha256 = "0kfvls8alc8wq0habl4snvhvd3a808z07san1sbvwp215frxycy9";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          aeson async base bytestring exceptions http-client http-client-tls
-         http-types network opentelemetry scientific stm text
-         unordered-containers
+         http-types network opentelemetry opentelemetry-extra scientific stm
+         text unordered-containers
+       ];
+       executableHaskellDepends = [
+         async base bytestring clock containers exceptions filepath
+         ghc-events http-client http-types opentelemetry opentelemetry-extra
+         splitmix text unordered-containers
        ];
-       testHaskellDepends = [ async base opentelemetry ];
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {};
 
   "opentelemetry-wai" = callPackage
-    ({ mkDerivation, base, http-types, opentelemetry, text, wai }:
+    ({ mkDerivation, base, bytestring, http-types, opentelemetry, text
+     , wai
+     }:
      mkDerivation {
        pname = "opentelemetry-wai";
-       version = "0.2.0";
-       sha256 = "1n27g8xjij05g7xxx8z50k39nmclhm707xs2pfqy830zdq1ldfl4";
-       libraryHaskellDepends = [ base http-types opentelemetry text wai ];
+       version = "0.3.0";
+       sha256 = "0x2a3s1xdc66ww8p8nkpwblvhv9hng64baij3wvbcbn2n1lls531";
+       libraryHaskellDepends = [
+         base bytestring http-types opentelemetry text wai
+       ];
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "ormolu_0_0_4_0" = callPackage
+  "ormolu_0_0_5_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, dlist, exceptions
      , filepath, ghc-lib-parser, gitrev, hspec, hspec-discover, mtl
      , optparse-applicative, path, path-io, syb, text
      }:
      mkDerivation {
        pname = "ormolu";
-       version = "0.0.4.0";
-       sha256 = "1x3fdhnpbf7xd0h85909smr5nv2qz4fbljvvzmsk8ph653j5js1k";
+       version = "0.0.5.0";
+       sha256 = "1sf22silpj89sldd7wanlr34nsv77bq0cf4i0q1x2r20pz7s4w4m";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }) {};
 
   "overloaded" = callPackage
-    ({ mkDerivation, base, bin, bytestring, containers, fin
-     , generic-lens, ghc, HUnit, lens, optics-core, ral, record-hasfield
-     , singleton-bool, sop-core, split, syb, symbols, tasty, tasty-hunit
-     , text, time, vec
+    ({ mkDerivation, assoc, base, bin, boring, bytestring, constraints
+     , containers, fin, generic-lens-lite, ghc, hmatrix, HUnit, lens
+     , optics-core, QuickCheck, ral, record-hasfield, singleton-bool
+     , sop-core, split, syb, symbols, tasty, tasty-hunit
+     , tasty-quickcheck, text, time, vec
      }:
      mkDerivation {
        pname = "overloaded";
-       version = "0.2";
-       sha256 = "1kp3vbdfwp9caicmj2k1qznbsn844pm75sy8ywwm86334f08vshk";
+       version = "0.2.1";
+       sha256 = "1qa2xq2hf792ivi92mimznwj86x9y1dpwz7rwcz99zvfk7a3hsis";
        libraryHaskellDepends = [
-         base bin bytestring containers fin ghc optics-core ral
+         assoc base bin bytestring containers fin ghc optics-core ral
          record-hasfield sop-core split syb symbols text time vec
        ];
        testHaskellDepends = [
-         base bin bytestring containers fin generic-lens HUnit lens
-         optics-core ral record-hasfield singleton-bool sop-core symbols
-         tasty tasty-hunit text time vec
+         assoc base bin boring bytestring constraints containers fin
+         generic-lens-lite hmatrix HUnit lens optics-core QuickCheck ral
+         record-hasfield singleton-bool sop-core symbols tasty tasty-hunit
+         tasty-quickcheck text time vec
        ];
        doHaddock = false;
        description = "Overloaded pragmas as a plugin";
···
     ({ mkDerivation, base, directory, filepath, parallel-io }:
      mkDerivation {
        pname = "par-traverse";
-       version = "0.2.0.0";
-       sha256 = "1cbanrhaad3fq2kkpdkb3rh7c8qrc1v7by8v6mg4lrgghdx3msk8";
+       version = "0.2.1.0";
+       sha256 = "0rmv6wyisdg4srzjykikqqigfji6x5zn1cz2v3cyl0dms4yr4lig";
        libraryHaskellDepends = [ base directory filepath parallel-io ];
        description = "Traverse a directory in parallel";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "penntreebank-megaparsec" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover
+     , megaparsec, mtl, text, transformers
+     }:
+     mkDerivation {
+       pname = "penntreebank-megaparsec";
+       version = "0.1.0";
+       sha256 = "1wjwwpb1i10kasqxn9gkn34cpyjs83znmr6ps5sjr0zhqyg3dk3j";
+       libraryHaskellDepends = [
+         base containers megaparsec mtl transformers
+       ];
+       testHaskellDepends = [
+         base containers hspec megaparsec mtl text transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Parser combinators for trees in the Penn Treebank format";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "penny" = callPackage
     ({ mkDerivation, action-permutations, anonymous-sums, base
      , bytestring, cereal, containers, contravariant, either, matchers
···
      }:
      mkDerivation {
        pname = "perceptual-hash";
-       version = "0.1.3.3";
-       sha256 = "15f36b1xv5lq7gw7nd10mmhfyi935v07rdq04vzl2msdd6cn0j3d";
+       version = "0.1.3.5";
+       sha256 = "0f36sy9ixwbx55m3634lr0hrhllj68wv5jilzq0xik2171g3rx2p";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        broken = true;
      }) {};
 
+  "popkey" = callPackage
+    ({ mkDerivation, base, bitvec, bytestring, containers, hspec
+     , hspec-discover, hw-bits, hw-prim, hw-rankselect
+     , hw-rankselect-base, profunctors, QuickCheck, store, text, vector
+     }:
+     mkDerivation {
+       pname = "popkey";
+       version = "0.0.0.1";
+       sha256 = "1gplzbbj6whmxchxr78zv32ixlf79sjgdz950jixl7z9p5pdrki7";
+       libraryHaskellDepends = [
+         base bitvec bytestring containers hw-bits hw-prim hw-rankselect
+         hw-rankselect-base profunctors store text vector
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Static key-value storage backed by poppy";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "poppler" = callPackage
     ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers
      , gdk-pixbuf, glib, gtk, gtk2, gtk2hs-buildtools, mtl, pango
···
     ({ mkDerivation, ghc-prim }:
      mkDerivation {
        pname = "prim";
-       version = "0.1.0.2";
-       sha256 = "0pq9mjvifbj3h6pi024kjias3vlzn6nw7g684bf5z58cg51cmckg";
+       version = "0.1.0.6";
+       sha256 = "187pzlgkyg64azwrr2q896wy4i5zrryjbp9ldg9hm5lgyv782vr2";
        libraryHaskellDepends = [ ghc-prim ];
        description = "An ergonomic but conservative interface to ghc-prim";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "protolude_0_3_0" = callPackage
+    ({ mkDerivation, array, async, base, bytestring, containers
+     , deepseq, ghc-prim, hashable, mtl, mtl-compat, stm, text
+     , transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "protolude";
+       version = "0.3.0";
+       sha256 = "1b6wprbwfdjyvds2bm6na0fbqgzdkj5ikkk33whbkyh3krd3i0s0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array async base bytestring containers deepseq ghc-prim hashable
+         mtl mtl-compat stm text transformers transformers-compat
+       ];
+       description = "A small prelude";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "protolude-lifted" = callPackage
     ({ mkDerivation, async, base, lifted-async, lifted-base, protolude
      }:
···
 
   "push-notify-apn" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring
-     , containers, data-default, hspec, http2, http2-client
-     , optparse-applicative, random, semigroups, text, time, tls, x509
-     , x509-store
+     , containers, data-default, hspec, http2, http2-client, lifted-base
+     , mtl, optparse-applicative, random, resource-pool, semigroups
+     , text, time, tls, x509, x509-store
      }:
      mkDerivation {
        pname = "push-notify-apn";
-       version = "0.2.0.0";
-       sha256 = "0lkdjpgd04b7jxcrqvn395bhdac0ms0jbxdigd1xpvj6d9w7f9x3";
+       version = "0.2.0.1";
+       sha256 = "1p33nwazxk4kk52vw6i8rrsgy8i3bzn0klp56bv6nj1751z3mzbj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base base16-bytestring binary bytestring containers
-         data-default http2 http2-client random semigroups text time tls
-         x509 x509-store
+         data-default http2 http2-client lifted-base mtl random
+         resource-pool semigroups text time tls x509 x509-store
        ];
        executableHaskellDepends = [
          base bytestring optparse-applicative semigroups text
···
 
   "quadratic-irrational" = callPackage
     ({ mkDerivation, arithmoi, base, containers, directory, doctest
-     , filepath, mtl, numbers, QuickCheck, tasty, tasty-quickcheck
-     , transformers
-     }:
-     mkDerivation {
-       pname = "quadratic-irrational";
-       version = "0.1.0";
-       sha256 = "0kfgvixvcawfhw4vv0zg2r0d6hrlak01q9isqc3n3lc63qaifxgy";
-       revision = "1";
-       editedCabalFile = "11snayb371lpsz7p74sbbl3kq0i3i2vnp852x8vw482v48kld5vl";
-       libraryHaskellDepends = [ arithmoi base containers transformers ];
-       testHaskellDepends = [
-         arithmoi base directory doctest filepath mtl numbers QuickCheck
-         tasty tasty-quickcheck
-       ];
-       description = "An implementation of quadratic irrationals";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "quadratic-irrational_0_1_1" = callPackage
-    ({ mkDerivation, arithmoi, base, containers, directory, doctest
      , filepath, integer-roots, mtl, numbers, QuickCheck, tasty
      , tasty-quickcheck, transformers
      }:
···
        ];
        description = "An implementation of quadratic irrationals";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "quandl-api" = callPackage
···
      }:
      mkDerivation {
        pname = "quarantimer";
-       version = "1.20200326";
-       sha256 = "1q0rraxq1gv86chi64ijxxkx4dm8w9v2610wj58315bap3d3m91c";
+       version = "1.20200422";
+       sha256 = "1wcf9rh6543pv1dpf55jk12x6zsak29izy94q1l4hc31w32gi8xz";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "9.0.10";
-       sha256 = "19xivp6hh6sz8wcn18y481pwxbggnw6dgbwdjiy42571q20gmzbw";
+       version = "9.1.1";
+       sha256 = "11q115yfjjafq2dyn88xc6xnynqw2i6yn7g9n8yy9qaa8jpgibzz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "recursion-schemes-ix" = callPackage
+    ({ mkDerivation, base, containers, hspec, mtl, QuickCheck
+     , singlethongs
+     }:
+     mkDerivation {
+       pname = "recursion-schemes-ix";
+       version = "0.1.0.0";
+       sha256 = "1hg0ggba40n1455nd85wb6h2fr3hixf69a3d75a6g5dcahaqh39n";
+       libraryHaskellDepends = [ base singlethongs ];
+       testHaskellDepends = [
+         base containers hspec mtl QuickCheck singlethongs
+       ];
+       description = "Recursion schemes over indexed Functors";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "recursive-line-count" = callPackage
     ({ mkDerivation, base, bytestring, containers, filepath, gtk, mtl
      , process
···
      }:
      mkDerivation {
        pname = "reflex-fsnotify";
-       version = "0.2.0.0";
-       sha256 = "0nxi3zjwwq36212qncpxi7rn30lgh0zy4swz10wxm55zb480dm8m";
+       version = "0.2.1.0";
+       sha256 = "1ym220myy521j4lm0wrjydg18ya5fw71j0mv3md35vmn18n6r0d4";
        libraryHaskellDepends = [
          base containers directory filepath fsnotify reflex
        ];
···
      }:
      mkDerivation {
        pname = "regex-pcre-builtin";
-       version = "0.95.1.1.8.43";
-       sha256 = "1akis4b9jp4a0qbwnpwm0nzlg76kb54wn2vlicc6yb4qha210fsd";
-       libraryHaskellDepends = [
-         array base bytestring containers regex-base text
-       ];
-       description = "PCRE Backend for \"Text.Regex\" (regex-base)";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "regex-pcre-builtin_0_95_1_2_8_43" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, regex-base
-     , text
-     }:
-     mkDerivation {
-       pname = "regex-pcre-builtin";
        version = "0.95.1.2.8.43";
        sha256 = "1bxn8d3g9w1a5q5vcz744yx019d2rd79i07qcjq4jqkjafni1bml";
        libraryHaskellDepends = [
···
        ];
        description = "PCRE Backend for \"Text.Regex\" (regex-base)";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "regex-pcre-text" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "resourcet_1_2_4" = callPackage
+    ({ mkDerivation, base, containers, exceptions, hspec, mtl
+     , primitive, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "resourcet";
+       version = "1.2.4";
+       sha256 = "017v0r9qk4d7dd04dc03ghghyk1d4qj82gligyzg5fdz2rkg8i8x";
+       libraryHaskellDepends = [
+         base containers exceptions mtl primitive transformers unliftio-core
+       ];
+       testHaskellDepends = [ base exceptions hspec transformers ];
+       description = "Deterministic allocation and freeing of scarce resources";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "respond" = callPackage
     ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
      , data-default-class, exceptions, fast-logger, formatting, HList
···
     ({ mkDerivation, base, dunai, gloss, rhine }:
      mkDerivation {
        pname = "rhine-gloss";
-       version = "0.6.0";
-       sha256 = "1kfy993872iq93fc5bn6bz0xx13afbb5piwxyw8jdjp146jp2380";
+       version = "0.6.0.1";
+       sha256 = "1j3sbdlfn6hkksfxa5nw874pm9yxmc8hy14msjfsl3g3y0d501bh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base dunai gloss rhine ];
···
     ({ mkDerivation, base, Only, postgresql-simple, text, time }:
      mkDerivation {
        pname = "ribbit";
-       version = "1.1.0.0";
-       sha256 = "1pmg7ii6mpl22hlgmripwp44cz4pwp2yqa4z32f21lfr0y9slz8j";
+       version = "1.1.0.1";
+       sha256 = "076m5w4w08z8migb0v8vb6lybs06x1bfvxqfi9g633lz464hyi9v";
        libraryHaskellDepends = [ base Only postgresql-simple text time ];
        description = "Type-level Relational DB combinators";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "ridley";
-       version = "0.3.1.3";
-       sha256 = "0j7wvzk2x3xpvwwfkz1bll9awfrlbn1lcl50hm582plnl2pgddq0";
+       version = "0.3.1.4";
+       sha256 = "120yqfrkp4ziz8yn6xgzzhdszrvq1dk1szzh3q2m8w36c0g2qdhy";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          async base containers ekg-core ekg-prometheus-adapter inline-c
···
      }:
      mkDerivation {
        pname = "safecopy";
-       version = "0.10.2";
-       sha256 = "0x8j27qmvqk009q2jhs1a6rdi81xvgp76bwnbp0y8yvzynjcaagk";
-       libraryHaskellDepends = [
-         array base bytestring cereal containers generic-data old-time
-         template-haskell text time transformers vector
-       ];
-       testHaskellDepends = [
-         array base bytestring cereal containers HUnit lens lens-action
-         QuickCheck quickcheck-instances tasty tasty-quickcheck
-         template-haskell time vector
-       ];
-       description = "Binary serialization with version control";
-       license = stdenv.lib.licenses.publicDomain;
-     }) {};
-
-  "safecopy_0_10_3" = callPackage
-    ({ mkDerivation, array, base, bytestring, cereal, containers
-     , generic-data, HUnit, lens, lens-action, old-time, QuickCheck
-     , quickcheck-instances, tasty, tasty-quickcheck, template-haskell
-     , text, time, transformers, vector
-     }:
-     mkDerivation {
-       pname = "safecopy";
        version = "0.10.3";
        sha256 = "142ghv6pa3y0s7x141x9f9r5sn0315vvkfw6f7lgnndlncs5y354";
        libraryHaskellDepends = [
···
        ];
        description = "Binary serialization with version control";
        license = stdenv.lib.licenses.publicDomain;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "safecopy-migrate" = callPackage
···
   "sak" = callPackage
     ({ mkDerivation, base, brotli, bytestring, bz2, cpphs, directory
      , filepath, lz4-hs, lzlib, lzma, optparse-applicative, parallel-io
-       pname = "limp";
+     , snappy-lazy, zlib, zstd
      }:
      mkDerivation {
        pname = "sak";
-       version = "0.1.2.3";
-       sha256 = "0ydc5ykkhxxvzcwncf0rvn3zk2gid7r0dwai63r3vsvp7mn2jg8g";
-       revision = "1";
-       editedCabalFile = "01xf0f5q458wgg8jndcimgpqmwvgvxlpf5cf7gb14v2y3vw2hzfj";
+       version = "0.1.2.4";
+       sha256 = "0gj0w8c4j43586k474ncjk4ldgjx5rbw36g5lacbn13lf3fid2ck";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
          base brotli bytestring bz2 directory filepath lz4-hs lzlib lzma
-         optparse-applicative parallel-io zlib zstd
+         optparse-applicative parallel-io snappy-lazy zlib zstd
        ];
        executableToolDepends = [ cpphs ];
        description = "Compression command-line tool";
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "scalpel_0_6_2" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, data-default
+     , http-client, http-client-tls, scalpel-core, tagsoup, text
+     }:
+     mkDerivation {
+       pname = "scalpel";
+       version = "0.6.2";
+       sha256 = "04hhvk0yjxha3yg6n9fxivrz97hpjjiiblnj0bvs5myax1ggkjch";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive data-default http-client
+         http-client-tls scalpel-core tagsoup text
+       ];
+       description = "A high level web scraping library for Haskell";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "scalpel-core" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion
      , data-default, fail, HUnit, pointedlist, regex-base, regex-tdfa
···
        benchmarkHaskellDepends = [ base criterion tagsoup text ];
        description = "A high level web scraping library for Haskell";
        license = stdenv.lib.licenses.asl20;
+     }) {};
+
+  "scalpel-core_0_6_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion
+     , data-default, fail, HUnit, mtl, pointedlist, regex-base
+     , regex-tdfa, tagsoup, text, transformers, vector
+     }:
+     mkDerivation {
+       pname = "scalpel-core";
+       version = "0.6.2";
+       sha256 = "07mjff8aqwabx8yhq8bd7jpnarkkrjqss8h8s2wkfmfj808fllmf";
+       libraryHaskellDepends = [
+         base bytestring containers data-default fail mtl pointedlist
+         regex-base regex-tdfa tagsoup text transformers vector
+       ];
+       testHaskellDepends = [ base HUnit regex-base regex-tdfa tagsoup ];
+       benchmarkHaskellDepends = [ base criterion tagsoup text ];
+       description = "A high level web scraping library for Haskell";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "scan" = callPackage
···
      }:
      mkDerivation {
        pname = "sdl2";
-       version = "2.5.1.0";
-       sha256 = "087df61fsmfsdc7pdn6sgsp5lf20nampa41illszii5jfr13s7gw";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring exceptions linear StateVar text transformers vector
-       ];
-       librarySystemDepends = [ SDL2 ];
-       libraryPkgconfigDepends = [ SDL2 ];
-       testHaskellDepends = [ base deepseq linear vector weigh ];
-       description = "Both high- and low-level bindings to the SDL library (version 2.0.6+).";
-       license = stdenv.lib.licenses.bsd3;
-     }) {inherit (pkgs) SDL2;};
-
-  "sdl2_2_5_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, exceptions, linear
-     , SDL2, StateVar, text, transformers, vector, weigh
-     }:
-     mkDerivation {
-       pname = "sdl2";
        version = "2.5.2.0";
        sha256 = "18cgckkq4yj0xwj3pmsfsqxazl7rcmb3f7b45kv9nwvjwyqi0hcw";
        isLibrary = true;
···
        testHaskellDepends = [ base deepseq linear vector weigh ];
        description = "Both high- and low-level bindings to the SDL library (version 2.0.6+).";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) SDL2;};
 
   "sdl2-cairo" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "serialise-uuid" = callPackage
+    ({ mkDerivation, base, bytestring, cborg, serialise, tasty
+     , tasty-hunit, tasty-quickcheck, uuid-types
+     }:
+     mkDerivation {
+       pname = "serialise-uuid";
+       version = "0.1";
+       sha256 = "0sw1vim04yflkznxkcdcljrns1nb6v0zjvwkx5spbb5dc0gk12v5";
+       libraryHaskellDepends = [
+         base bytestring cborg serialise uuid-types
+       ];
+       testHaskellDepends = [
+         base bytestring serialise tasty tasty-hunit tasty-quickcheck
+         uuid-types
+       ];
+       description = "Encode and decode UUID values in CBOR using uuid-types, cborg and serialise";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "serialize-instances" = callPackage
     ({ mkDerivation, base, cereal, hashable, semigroups
      , unordered-containers
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "servant-docs-simple" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hspec
+     , hspec-core, prettyprinter, raw-strings-qq, servant, text
+     }:
+     mkDerivation {
+       pname = "servant-docs-simple";
+       version = "0.1.0.0";
+       sha256 = "11591njaavchmlmdzwql7n3klfs6il1c1q4rd5h8n84krsah3y4r";
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring prettyprinter servant text
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base bytestring hspec hspec-core prettyprinter
+         raw-strings-qq servant text
+       ];
+       description = "Generate documentation via TypeRep for Servant API";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "servant-ede" = callPackage
     ({ mkDerivation, aeson, base, bytestring, ede, either, filepath
      , http-media, http-types, semigroups, servant, servant-server, text
···
      }:
      mkDerivation {
        pname = "servant-elm";
-       version = "0.7.1";
-       sha256 = "1r24hqv4xs1k280a0c3lcmfjrywh0663hh8xi8fpzlmsgmn2s464";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base directory elm-bridge lens servant servant-foreign text
-         wl-pprint-text
-       ];
-       testHaskellDepends = [
-         aeson base Diff elm-bridge hspec HUnit servant servant-client text
-       ];
-       description = "Automatically derive Elm functions to query servant webservices";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "servant-elm_0_7_2" = callPackage
-    ({ mkDerivation, aeson, base, Diff, directory, elm-bridge, hspec
-     , HUnit, lens, servant, servant-client, servant-foreign, text
-     , wl-pprint-text
-     }:
-     mkDerivation {
-       pname = "servant-elm";
        version = "0.7.2";
        sha256 = "1hn7qkz4aw5snc4lbprbshzr3dagfry1bms0fx9bfif61312swqy";
        isLibrary = true;
···
        ];
        description = "Automatically derive Elm functions to query servant webservices";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "servant-errors" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "serverless-haskell_0_10_5" = callPackage
+    ({ mkDerivation, aeson, aeson-casing, amazonka-core
+     , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive
+     , hspec, hspec-discover, http-types, iproute, lens, network
+     , network-simple, raw-strings-qq, text, time, unix
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "serverless-haskell";
+       pname = "limp";
+       sha256 = "187pah3k88vp27k1imwj1mqxavd9zykms3is517xrp209ldx5kw1";
+       libraryHaskellDepends = [
+         aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
+         bytestring case-insensitive http-types iproute lens network
+         network-simple text time unix unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
+         bytestring case-insensitive hspec hspec-discover http-types iproute
+         lens network network-simple raw-strings-qq text time unix
+         unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Deploying Haskell code onto AWS Lambda using Serverless";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "serversession" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , containers, data-default, hashable, hspec, nonce, path-pieces
···
        broken = true;
      }) {};
 
+  "singlethongs" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "singlethongs";
+       version = "0.1";
+       sha256 = "14f7nnlw4hwvv767qgm6cb3ywijm9gyzjprr0i4ffa04r283mm3q";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base ];
+       description = "Like singletons, but much smaller";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "singleton-bool" = callPackage
     ({ mkDerivation, base, dec }:
      mkDerivation {
···
        testHaskellDepends = [ base doctest Glob ];
        description = "Sized list";
        license = stdenv.lib.licenses.mpl20;
+     }) {};
+
+  "slist_0_1_1_0" = callPackage
+    ({ mkDerivation, base, doctest, Glob }:
+     mkDerivation {
+       pname = "slist";
+       version = "0.1.1.0";
+       sha256 = "046v580i8kxx9fpsvavwpydyfsffky3m735c45dafixrkbhjz55d";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "Sized list";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "sloane" = callPackage
···
        broken = true;
      }) {};
 
+  "snappy-lazy" = callPackage
+    ({ mkDerivation, base, binary, bytestring, snappy, snappy-framing
+     }:
+     mkDerivation {
+       pname = "snappy-lazy";
+       version = "0.1.0.0";
+       sha256 = "02c2zxlzs5p29rsjj3vsnc2hdamr40is7fzybq6mf5rl9nkicggh";
+       libraryHaskellDepends = [
+         base binary bytestring snappy snappy-framing
+       ];
+       description = "Lazy bytestring compression and decompression";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "sndfile-enumerators" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, filepath
      , iteratee, listlike-instances, MonadCatchIO-transformers
···
      }) {};
 
   "souffle-haskell" = callPackage
-    ({ mkDerivation, base, hspec, mtl, souffle, template-haskell, text
+    ({ mkDerivation, base, deepseq, directory, filepath, free, hspec
+     , mtl, process, souffle, template-haskell, temporary, text
      , type-errors-pretty, vector
      }:
      mkDerivation {
        pname = "souffle-haskell";
-       version = "0.1.0";
-       sha256 = "0m8p9fx4avv4kf4hbr248rk9k3vixzkx4gqmcslfra3d79akjyad";
+       version = "0.2.0";
+       sha256 = "0c67z5wrfi3pp5fyvl8k4j1r8h7ziy6hj5zrwrpf550p3a04chrm";
        libraryHaskellDepends = [
-         base mtl template-haskell text type-errors-pretty vector
+         base deepseq directory filepath free mtl process template-haskell
+         temporary text type-errors-pretty vector
        ];
        libraryToolDepends = [ souffle ];
        testHaskellDepends = [
-         base hspec mtl template-haskell text type-errors-pretty vector
+         base deepseq directory filepath free hspec mtl process
+         template-haskell temporary text type-errors-pretty vector
        ];
        testToolDepends = [ souffle ];
        description = "Souffle Datalog bindings for Haskell";
···
      }:
      mkDerivation {
        pname = "squeal-postgresql";
-       version = "0.6.0.1";
-       sha256 = "1c8lsi3qjl1zp0hfhmrv5r6pqsvcilx3g1aw49rrvjrj9xlbbvws";
+       version = "0.6.0.2";
+       sha256 = "0798aw0ahjdjczz5i8n1dwix8vzd0ccl7cbf473x5mxn549nh0qm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stratosphere_0_51_0" = callPackage
+  "stratosphere_0_52_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , hashable, hspec, hspec-discover, lens, template-haskell, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "stratosphere";
-       version = "0.51.0";
-       sha256 = "053q621zw2c0nf08qc232mnh1cn4qxyzshayis6siqabdnjlqnk2";
+       version = "0.52.0";
+       sha256 = "1js5rb5f0p7ryja5slpxjpvqfq4f72bw9f66ysd70cjvw3zf3hbh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "streamly_0_7_2" = callPackage
+    ({ mkDerivation, atomic-primops, base, containers, deepseq
+     , directory, exceptions, fusion-plugin-types, ghc, ghc-prim, heaps
+     , hspec, lockfree-queue, monad-control, mtl, network, primitive
+     , QuickCheck, random, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "streamly";
+       version = "0.7.2";
+       sha256 = "007i3rfza0v8zy34lq9ipq2biarg82prmd1vxr5f2zz5xln37wrm";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         atomic-primops base containers deepseq directory exceptions
+         fusion-plugin-types ghc-prim heaps lockfree-queue monad-control mtl
+         network primitive transformers transformers-base
+       ];
+       testHaskellDepends = [
+         base containers exceptions ghc hspec mtl QuickCheck random
+         transformers
+       ];
+       description = "Beautiful Streaming, Concurrent and Reactive Composition";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "streamly-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, filepath
      , gauge, hspec, hspec-discover, quickcheck-instances, random
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "stripe-concepts_1_0_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, text }:
+     mkDerivation {
+       pname = "stripe-concepts";
+       version = "1.0.2.2";
+       sha256 = "18dqw3fkviysazx1iy2ljnk6ngpck83ld0msnn8pn68l4qvvhl4r";
+       libraryHaskellDepends = [ base bytestring text ];
+       description = "Types for the Stripe API";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "stripe-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, mtl, text, time
      , transformers, unordered-containers
···
      }:
      mkDerivation {
        pname = "stripe-scotty";
-       version = "1.0.0.0";
-       sha256 = "195v1a3sl5skz2jr71r1b4za033s6hib7ld59f4fdrfdr5658sbs";
-       revision = "1";
-       editedCabalFile = "0c3r39217650yjxxs1523ywvyiirrh2f209gl4hfznyigkx2kg41";
+       version = "1.0.0.2";
+       sha256 = "1dvmagbxgmlf7970rwf0cjdk8fcpxkl1isiki1bpq4zd07cjnsfv";
        libraryHaskellDepends = [
          aeson base bytestring http-types scotty stripe-concepts
          stripe-signature text unordered-containers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "stripe-signature_1_0_0_2" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring, cryptonite
+     , memory, stripe-concepts, text
+     }:
+     mkDerivation {
+       pname = "stripe-signature";
+       version = "1.0.0.2";
+       sha256 = "1jjn4znk22993dpzwdqndnsyn4k76v7zqgm7j7dhvlgiwak6yxh6";
+       libraryHaskellDepends = [
+         base base16-bytestring bytestring cryptonite memory stripe-concepts
+         text
+       ];
+       testHaskellDepends = [ base bytestring text ];
+       description = "Verification of Stripe webhook signatures";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "stripe-tests" = callPackage
     ({ mkDerivation, aeson, base, bytestring, free, hspec, hspec-core
      , mtl, random, stripe-core, text, time, transformers
···
      }:
      mkDerivation {
        pname = "stripe-wreq";
-       version = "1.0.1.0";
-       sha256 = "0i5d0c9zha4v9361p92kq5bpma5dq5aqdkqdrghwpzx0pppfpx3y";
+       version = "1.0.1.2";
+       sha256 = "0hjk9d0xlg2a6nc2rmc19fmifcyrdj5m69100fy5xkq6brcqxjz1";
        libraryHaskellDepends = [
          aeson base bytestring lens stripe-concepts text
          unordered-containers wreq
···
      }:
      mkDerivation {
        pname = "stylist";
-       version = "1.2.0.0";
-       sha256 = "1b3kz8kp2dda4f0vghbaxc6y29r39k197fzphy4av8p6vxgp2ka0";
+       version = "2.0.0.0";
+       sha256 = "1xb2vl4xjbgd52nqm378r43z4xlgzscfy9a7mqp522av3b4v61x7";
        libraryHaskellDepends = [
          async base css-syntax hashable network-uri text
          unordered-containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "swagger2_2_6" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
+     , bytestring, Cabal, cabal-doctest, containers, cookie, doctest
+     , generics-sop, Glob, hashable, hspec, hspec-discover, http-media
+     , HUnit, insert-ordered-containers, lens, mtl, network, optics-core
+     , optics-th, QuickCheck, quickcheck-instances, scientific
+     , template-haskell, text, time, transformers, transformers-compat
+     , unordered-containers, utf8-string, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "swagger2";
+       version = "2.6";
+       sha256 = "0vkhikxf1gpspc9qjgnvz3glb01bd54bnc5kraac7dyn8cxzwak8";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson aeson-pretty base base-compat-batteries bytestring containers
+         cookie generics-sop hashable http-media insert-ordered-containers
+         lens mtl network optics-core optics-th QuickCheck scientific
+         template-haskell text time transformers transformers-compat
+         unordered-containers uuid-types vector
+       ];
+       testHaskellDepends = [
+         aeson base base-compat-batteries bytestring containers doctest Glob
+         hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck
+         quickcheck-instances template-haskell text time
+         unordered-containers utf8-string vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Swagger 2.0 data model";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "swapper" = callPackage
     ({ mkDerivation, base, binary, bytestring, deepseq, happstack-data
      , happstack-state, parallel, tokyocabinet
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "systemd_2_3_0" = callPackage
+    ({ mkDerivation, base, bytestring, network, transformers, unix }:
+     mkDerivation {
+       pname = "systemd";
+       version = "2.3.0";
+       sha256 = "1fa65j996snrdq83kh3jzzs2dsf2ddsscx596p03ykgknz1q1f16";
+       libraryHaskellDepends = [
+         base bytestring network transformers unix
+       ];
+       testHaskellDepends = [ base network unix ];
+       description = "Systemd facilities (Socket activation, Notify)";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "systemstats" = callPackage
     ({ mkDerivation, base, micrologger, optparse-applicative, statgrab
      , text, text-format, transformers
···
      }:
      mkDerivation {
        pname = "taskwarrior";
-       version = "0.1.2.3";
-       sha256 = "02vavv0ddx82h7xa3nky3s54fz8pnar8kgzssz83f08brw35qdjb";
+       version = "0.2.0.0";
+       sha256 = "1sljpsafyh2kxga7p9dz0nsvqlsmbd399xlgmncnyfh0z9cii7pw";
        libraryHaskellDepends = [
          aeson base bytestring process random text time unordered-containers
          uuid
···
   "tasty-golden" = callPackage
        pname = "limp";
      , directory, filepath, mtl, optparse-applicative, process, tagged
-     , tasty, tasty-hunit, temporary
-     }:
-     mkDerivation {
-       pname = "tasty-golden";
-       version = "2.3.3";
-       sha256 = "07sk9hw41am2xcpfkzy1jv43wlyxkdd4ajwk8rw2jabva91kv68x";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         async base bytestring containers deepseq directory filepath mtl
-         optparse-applicative process tagged tasty temporary
-       ];
-       testHaskellDepends = [
-         base directory filepath process tasty tasty-hunit temporary
-       ];
-       description = "Golden tests support for tasty";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "tasty-golden_2_3_3_1" = callPackage
-       pname = "limp";
-     , directory, filepath, mtl, optparse-applicative, process, tagged
      , tasty, tasty-hunit, temporary, text
      }:
      mkDerivation {
···
        ];
        description = "Golden tests support for tasty";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "tasty-groundhog-converters" = callPackage
···
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.2.0";
-       sha256 = "1aafj27zj69hvzxv58cz7h8pjbc9c74hmg92swg2sy8ai1rcb34a";
-       revision = "1";
-       editedCabalFile = "1li6b3m9glhfg8agr9h0mrbxpr8zr46l57mzjfdqndm248ddbklv";
+       version = "0.3.0";
+       sha256 = "196zb03nj37qfmxgn5lagjdl759bgmnr1vsh26dbbv1zsmlp0pva";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "telegram-raw-api" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, connection
-     , deriving-aeson, generic-lens, http-client, http-client-tls
-     , http-media, lens, servant, servant-client, servant-client-core
-     , servant-multipart, telegram-types, text
+    ({ mkDerivation, aeson, base, bytestring, deriving-aeson
+     , generic-lens, hashable, http-client, http-client-tls, http-media
+     , lens, servant, servant-client, servant-client-core
+     , servant-multipart, telegram-types, text, time
      }:
      mkDerivation {
        pname = "telegram-raw-api";
-       version = "0.1.0";
-       sha256 = "0afj22mwxsqdb95m1lb03h4fssyfwsrvi2qdm2bajkvlgaz3h8zh";
+       version = "0.3.0";
+       sha256 = "0dlazp70jpffpbpdlbyzv7s33jr1ff8z4xjhvkgqyhs23mzi46rc";
        libraryHaskellDepends = [
-         aeson base bytestring connection deriving-aeson generic-lens
+         aeson base bytestring deriving-aeson generic-lens hashable
          http-media lens servant servant-client servant-multipart
-         telegram-types text
+         telegram-types text time
        ];
        testHaskellDepends = [
-         aeson base bytestring connection deriving-aeson generic-lens
+         aeson base bytestring deriving-aeson generic-lens hashable
          http-client http-client-tls http-media lens servant servant-client
-         servant-client-core servant-multipart telegram-types text
+         servant-client-core servant-multipart telegram-types text time
        ];
        description = "Servant bindings to the Telegram bot API";
        license = stdenv.lib.licenses.bsd3;
···
   "telegram-types" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deriving-aeson, filepath
      , generic-lens, lens, mime-types, open-union, servant
-     , servant-multipart, text
+     , servant-multipart, text, time
      }:
      mkDerivation {
        pname = "telegram-types";
-       version = "0.1.0";
-       sha256 = "19xrmqcgv5dih9vfxp5dvzzxsfs3x3rsz0ncw9x6xxzbmiirbc0k";
+       version = "0.4.0";
+       sha256 = "1giv1d713rfdc8svcba2ws8mv6g957f7v1dm3qr9p8082nry2llm";
        libraryHaskellDepends = [
          aeson base bytestring deriving-aeson filepath generic-lens lens
-         mime-types open-union servant servant-multipart text
+         mime-types open-union servant servant-multipart text time
        ];
        testHaskellDepends = [
          aeson base bytestring deriving-aeson filepath generic-lens lens
-         mime-types open-union servant servant-multipart text
+         mime-types open-union servant servant-multipart text time
        ];
        description = "Types used in Telegram bot API";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, time }:
      mkDerivation {
        pname = "tempi";
-       version = "1.0.0.0";
-       sha256 = "14sap7m01f0l8hkh63qidkivji3y3ivhfkvyq881dn5zs9iajq2l";
+       version = "1.0.1.1";
+       sha256 = "126j3bph2b7wsn7gvckx7b6sj69djcr57m4yzbdc895mq5zga88j";
        libraryHaskellDepends = [ base time ];
        description = "For representing musical tempi";
        license = stdenv.lib.licenses.bsd3;
···
        ];
        description = "TensorFlow bindings";
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {libtensorflow = null;};
 
   "tensorflow-core-ops" = callPackage
···
        ];
        description = "Haskell wrappers for Core Tensorflow Ops";
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "tensorflow-logging" = callPackage
···
        ];
        description = "TensorBoard related functionality";
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "tensorflow-mnist" = callPackage
···
        ];
        description = "Code generation for TensorFlow operations";
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "tensorflow-ops" = callPackage
···
        ];
        description = "Friendly layer around TensorFlow bindings";
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "tensorflow-proto" = callPackage
···
        libraryToolDepends = [ protobuf ];
        description = "TensorFlow protocol buffers";
        license = stdenv.lib.licenses.asl20;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) protobuf;};
 
   "tensorflow-records" = callPackage
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
+  "texmath_0_12_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, pandoc-types, parsec, process, syb, temporary, text
+     , utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.12.0.2";
+       sha256 = "116i1f1qnkraygf05lpw7vg3h6zk8lh14k4i2yx6prb649d2iv1g";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec syb text xml
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath process temporary text
+         utf8-string xml
+       ];
+       description = "Conversion between formats used to represent mathematics";
+       license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "texrunner" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , HUnit, io-streams, lens, mtl, process, semigroups, temporary
···
        ];
        description = "Text formatting";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "text-format-heavy" = callPackage
···
      }) {};
 
   "th-lift-instances" = callPackage
-    ({ mkDerivation, base, bytestring, containers, QuickCheck
-     , template-haskell, text, th-lift, transformers, vector
-     }:
-     mkDerivation {
-       pname = "th-lift-instances";
-       version = "0.1.15";
-       sha256 = "07x8rclsn355zsacgh9xk97j6n13d3457rwcpbwrw5lmq8qz3c13";
-       libraryHaskellDepends = [
-         base bytestring containers template-haskell text th-lift
-         transformers vector
-       ];
-       testHaskellDepends = [
-         base bytestring containers QuickCheck template-haskell text vector
-       ];
-       description = "Lift instances for template-haskell for common data types";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "th-lift-instances_0_1_16" = callPackage
     ({ mkDerivation, base, bytestring, containers, QuickCheck
      , template-haskell, text, th-lift, transformers, vector
      }:
···
        ];
        description = "Lift instances for template-haskell for common data types";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "th-nowq" = callPackage
···
      }:
      mkDerivation {
        pname = "th-orphans";
-       version = "0.13.9";
-       sha256 = "1xj1gssv77hdx1r3ndg8k49v3ipj3a6r7crkyvx13jrps3m6ng1z";
-       revision = "1";
-       editedCabalFile = "100gpi0np50vxlapyl6d05w8ss9l2gqacn28i228hsvhvrxxwjdy";
-       libraryHaskellDepends = [
-         base mtl template-haskell th-lift th-lift-instances th-reify-many
-       ];
-       testHaskellDepends = [
-         base bytestring ghc-prim hspec template-haskell th-lift
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Orphan instances for TH datatypes";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "th-orphans_0_13_10" = callPackage
-    ({ mkDerivation, base, bytestring, ghc-prim, hspec, hspec-discover
-     , mtl, template-haskell, th-lift, th-lift-instances, th-reify-many
-     }:
-     mkDerivation {
-       pname = "th-orphans";
        version = "0.13.10";
        sha256 = "0a69jrvialwg9g1h3j729jahl47h9ar5xxjqbi3pxyfc94v5fcs4";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Orphan instances for TH datatypes";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "th-pprint" = callPackage
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "1.4.8";
-       sha256 = "163ndsx6spicipsy52iqsrm97z6pfr4mm93d2dz7ffckbzsklmdb";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bifunctors bytestring clock colour containers deepseq hosc
-         mwc-random network parsec primitive random text transformers vector
-       ];
-       testHaskellDepends = [ base containers microspec parsec ];
-       benchmarkHaskellDepends = [ base criterion weigh ];
-       description = "Pattern language for improvised music";
-       license = stdenv.lib.licenses.gpl3;
-     }) {};
-
-  "tidal_1_4_9" = callPackage
-    ({ mkDerivation, base, bifunctors, bytestring, clock, colour
-     , containers, criterion, deepseq, hosc, microspec, mwc-random
-     , network, parsec, primitive, random, text, transformers, vector
-     , weigh
-     }:
-     mkDerivation {
-       pname = "tidal";
        version = "1.4.9";
        sha256 = "0np32jnvqmnnqy166a17i367c5j5xc9mniqzr0x76wk7mb5zlwzj";
        enableSeparateDataOutput = true;
···
        benchmarkHaskellDepends = [ base criterion weigh ];
        description = "Pattern language for improvised music";
        license = stdenv.lib.licenses.gpl3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "tidal-midi" = callPackage
···
        ];
        description = "A pure Haskell parser and renderer for binary Olson timezone files";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "timezone-olson_0_2_0" = callPackage
+    ({ mkDerivation, base, binary, bytestring, extensible-exceptions
+     , time, timezone-series
+     }:
+     mkDerivation {
+       pname = "timezone-olson";
+       version = "0.2.0";
+       sha256 = "0b9vh27b9nz803yhd93d5z63bs370lvn4vkdajxaak9clxlw6mwg";
+       libraryHaskellDepends = [
+         base binary bytestring extensible-exceptions time timezone-series
+       ];
+       description = "A pure Haskell parser and renderer for binary Olson timezone files";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "timezone-olson-th" = callPackage
···
        license = stdenv.lib.licenses.mpl20;
      }) {};
 
+  "type-errors-pretty_0_0_1_1" = callPackage
+    ({ mkDerivation, base, doctest, Glob }:
+     mkDerivation {
+       pname = "type-errors-pretty";
+       version = "0.0.1.1";
+       sha256 = "1z6rqah3qnvnlckcw3xhsp4yyfd21harw6kzqbz20y6k7a22jlf0";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "Combinators for writing pretty type errors easily";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "type-fun" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "typerep-map_0_3_3_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, deepseq
+     , dependent-map, dependent-sum, ghc-prim, ghc-typelits-knownnat
+     , hedgehog, hspec, hspec-hedgehog, primitive, vector
+     }:
+     mkDerivation {
+       pname = "typerep-map";
+       version = "0.3.3.0";
+       sha256 = "0j7f7k0knpdsh41p0bzg7yv32nz684s3vrxc8pig5ckmmadc4mh4";
+       libraryHaskellDepends = [
+         base containers deepseq ghc-prim primitive vector
+       ];
+       testHaskellDepends = [
+         base ghc-typelits-knownnat hedgehog hspec hspec-hedgehog
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq dependent-map dependent-sum
+         ghc-typelits-knownnat
+       ];
+       doHaddock = false;
+       description = "Efficient implementation of a dependent map with types as keys";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {};
+
   "types-compat" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }) {};
 
   "unicode-tricks" = callPackage
-    ({ mkDerivation, base, data-default, QuickCheck, text }:
+    ({ mkDerivation, base, data-default, hspec, hspec-discover
+     , QuickCheck, text
+     }:
      mkDerivation {
        pname = "unicode-tricks";
-       version = "0.5.0.0";
-       sha256 = "0zbsph58w6lfc2357zkl46nm0y08bh3d29ihz6jgpvzi6cxgf5fl";
+       version = "0.7.0.0";
+       sha256 = "0lwpdqzprm0s7dgn5pvb6plklr45s4qqa0cbash296zcx8195imx";
        libraryHaskellDepends = [ base data-default QuickCheck text ];
+       testHaskellDepends = [ base hspec ];
+       testToolDepends = [ hspec-discover ];
        description = "Functions to work with unicode blocks more convenient";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        libraryHaskellDepends = [ base containers validity ];
        description = "Validity instances for containers";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "validity-containers_0_5_0_3" = callPackage
+    ({ mkDerivation, base, containers, validity }:
+     mkDerivation {
+       pname = "validity-containers";
+       version = "0.5.0.3";
+       sha256 = "064sd52y3cmfz9j1yhfz6wsm3993mnh9xgyzy6jzd4cdfmh19sdd";
+       libraryHaskellDepends = [ base containers validity ];
+       description = "Validity instances for containers";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "validity-path" = callPackage
···
        ];
        description = "webfont generator";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "webkit" = callPackage
···
      }) {};
 
   "with-utf8" = callPackage
-    ({ mkDerivation, base, deepseq, hedgehog, HUnit, safe-exceptions
-     , tasty, tasty-discover, tasty-hedgehog, tasty-hunit, temporary
-     , text, unix
+    ({ mkDerivation, base, deepseq, directory, hedgehog, HUnit
+     , safe-exceptions, tasty, tasty-discover, tasty-hedgehog
+     , tasty-hunit, temporary, text, unix
      }:
      mkDerivation {
        pname = "with-utf8";
-       version = "1.0.0.0";
-       sha256 = "06xznaszw7d6rznvzhzw3y4z31b4vx4djms85rq4qsbpfbdrh2zc";
+       version = "1.0.1.0";
+       sha256 = "07b3zpdnaqvp7ipbjnq17is5a70l2bncjqxlnhixpq91bbsczlrp";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [ base safe-exceptions text ];
+       executableHaskellDepends = [ base directory ];
        testHaskellDepends = [
          base deepseq hedgehog HUnit safe-exceptions tasty tasty-hedgehog
          tasty-hunit temporary text unix
···
        sha256 = "16xls71aby6jqc1frhwnlfvz1iwj1ms0rw9xzif02sn84470gn36";
        revision = "1";
        editedCabalFile = "0gz674sb266hv6si9l79c3bv7n2nbssl1262c24in79sk27887gb";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson attoparsec authenticate-oauth base base16-bytestring
+         bytestring case-insensitive containers cryptonite exceptions
+         ghc-prim hashable http-client http-client-tls http-types lens
+         lens-aeson memory mime-types psqueues template-haskell text time
+         time-locale-compat unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base base64-bytestring bytestring
+         case-insensitive containers directory doctest filepath hashable
+         http-client http-types HUnit lens lens-aeson network-info
+         QuickCheck snap-core snap-server temporary test-framework
+         test-framework-hunit test-framework-quickcheck2 text time
+         transformers unix-compat unordered-containers uuid vector
+       ];
+       description = "An easy-to-use HTTP client library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "wreq-patchable" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec
+     , authenticate-oauth, base, base16-bytestring, base64-bytestring
+     , bytestring, Cabal, cabal-doctest, case-insensitive, containers
+     , cryptonite, directory, doctest, exceptions, filepath, ghc-prim
+     , hashable, http-client, http-client-tls, http-types, HUnit, lens
+     , lens-aeson, memory, mime-types, network-info, psqueues
+     , QuickCheck, snap-core, snap-server, template-haskell, temporary
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , text, time, time-locale-compat, transformers, unix-compat
+     , unordered-containers, uuid, vector
+     }:
+     mkDerivation {
+       pname = "wreq-patchable";
+       version = "1.0.0.0";
+       sha256 = "0dj1cq8jmvwk12r5b5hmlj5m9hbhkhjz8bm3zxahwqap5kbi7c1c";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
      }:
      mkDerivation {
        pname = "xml-conduit-stylist";
-       version = "1.1.0.0";
-       sha256 = "0bj6mcd4k6wlrzizf3j2mnmbbl624k0xcsfrz9c3wpvdxb9iyqsr";
+       version = "1.2.0.0";
+       sha256 = "140ydh4yzafdiksh149jxvbjsd4r7bvfdh620bawqwnnc5dpk01q";
        libraryHaskellDepends = [
          base containers css-syntax network-uri stylist text
          unordered-containers xml-conduit