hackage-packages.nix: automatic Haskell package set update

This update was generated by hackage2nix v2.8-11-g68a143c from Hackage revision
https://github.com/commercialhaskell/all-cabal-hashes/commit/ddb65ce29d524bd944fdcce7a0edbb634632b799.

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

···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "Hoed_0_4_1" = callPackage
+    ({ mkDerivation, array, base, bytestring, cereal, clock, containers
+     , deepseq, directory, libgraph, process, QuickCheck, regex-tdfa
+     , semigroups, strict, template-haskell, terminal-size, uniplate
+     , vector
+     }:
+     mkDerivation {
+       pname = "Hoed";
+       version = "0.4.1";
+       sha256 = "14d4wypx75xmhb81f4lplvw04f5hjc97ncgzv4s07vd09bal8kq7";
+       libraryHaskellDepends = [
+         array base bytestring cereal clock containers deepseq directory
+         libgraph process QuickCheck regex-tdfa semigroups strict
+         template-haskell terminal-size uniplate vector
+       ];
+       testHaskellDepends = [ base process QuickCheck ];
+       homepage = "https://github.com/MaartenFaddegon/Hoed";
+       description = "Lightweight algorithmic debugging";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "HoleyMonoid" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        homepage = "https://github.com/vshabanov/HsOpenSSL";
        description = "Partial OpenSSL binding for Haskell";
        license = stdenv.lib.licenses.publicDomain;
+     }) {inherit (pkgs) openssl;};
+
+  "HsOpenSSL_0_11_4_12" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, integer-gmp, network
+     , openssl, time
+     }:
+     mkDerivation {
+       pname = "HsOpenSSL";
+       version = "0.11.4.12";
+       sha256 = "18hmbjg15rlpnqq95z2d2xskj5l0hcv5mp9hb16jb26rcdi54sim";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [
+         base bytestring integer-gmp network time
+       ];
+       librarySystemDepends = [ openssl ];
+       testHaskellDepends = [ base bytestring ];
+       homepage = "https://github.com/vshabanov/HsOpenSSL";
+       description = "Partial OpenSSL binding for Haskell";
+       license = stdenv.lib.licenses.publicDomain;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) openssl;};
 
   "HsOpenSSL-x509-system" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "acme-cuteboy" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "acme-cuteboy";
+       version = "0.1.0.0";
+       sha256 = "1x21mvm1n6cka07c3d3w8ycp84gx58af1nvpsfcaa7sccj13jvj9";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       executableHaskellDepends = [ base ];
+       homepage = "https://github.com/chessai/acme-cuteboy";
+       description = "Maybe gives you a cute boy";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "acme-cutegirl" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        ];
        homepage = "https://github.com/FPBrno/aeson-parsec-picky";
        description = "Alternative JSON parser based on Parsec and Aeson";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "aeson-picker" = callPackage
+    ({ mkDerivation, aeson, base, hspec, lens, lens-aeson, text }:
+     mkDerivation {
+       pname = "aeson-picker";
+       version = "0.1.0.0";
+       sha256 = "1976cf67y0077gd1s13vrfws5w5mcak94dc6ygnl1pir6ysanaf7";
+       libraryHaskellDepends = [ aeson base lens lens-aeson text ];
+       testHaskellDepends = [ base hspec text ];
+       homepage = "https://github.com/ozzzzz/aeson-picker#readme";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "ansi-terminal_0_8" = callPackage
+  "ansi-terminal_0_8_0_1" = callPackage
     ({ mkDerivation, base, colour }:
      mkDerivation {
        pname = "ansi-terminal";
-       version = "0.8";
-       sha256 = "1gg2xy800vzj2xixx8ifis1z027v34xj1a3792v0y8b7kmypgwlb";
+       version = "0.8.0.1";
+       sha256 = "0na61wyqn686qvzy5xbi3c8i1ba5ps6qlwnkkigzhj3c2xf3bm0v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base colour ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "ats-pkg" = callPackage
+    ({ mkDerivation, base, bytestring, composition-prelude, dhall
+     , directory, filemanip, http-client, http-client-tls, lens
+     , optparse-applicative, parallel-io, process, shake, shake-ext, tar
+     , temporary, text, unix, zlib
+     }:
+     mkDerivation {
+       pname = "ats-pkg";
+       version = "1.2.0.7";
+       sha256 = "1lsyxdkb6nb10gsn2hf40kd8m5fgmggsnm0dy3sgnx2w4gywjmjz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring composition-prelude dhall directory filemanip
+         http-client http-client-tls lens optparse-applicative parallel-io
+         process shake shake-ext tar temporary text unix zlib
+       ];
+       executableHaskellDepends = [ base ];
+       homepage = "https://github.com/vmchale/ats-pkg#readme";
+       description = "Package manager for ATS";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "attempt" = callPackage
     ({ mkDerivation, base, failure }:
      mkDerivation {
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "belka" = callPackage
+    ({ mkDerivation, aeson, aeson-value-parser, attoparsec, base
+     , base-prelude, base64-bytestring, bug, bytestring
+     , case-insensitive, hashable, http-client, http-client-tls
+     , http-media, http-types, iri, json-bytes-builder, mtl, potoki
+     , potoki-core, ptr, QuickCheck, quickcheck-instances, rerebase
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck, text
+     , transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "belka";
+       version = "0.8";
+       sha256 = "1827pjvw13a2zk69rq98sddg70rp9hzjy79jkkc0xa4c6s7y5fny";
+       libraryHaskellDepends = [
+         aeson aeson-value-parser attoparsec base base-prelude
+         base64-bytestring bug bytestring case-insensitive hashable
+         http-client http-client-tls http-media http-types iri
+         json-bytes-builder mtl potoki potoki-core ptr semigroups text
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         bug iri potoki QuickCheck quickcheck-instances rerebase tasty
+         tasty-hunit tasty-quickcheck
+       ];
+       homepage = "https://github.com/nikita-volkov/belka";
+       description = "HTTP client DSL";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "bench" = callPackage
     ({ mkDerivation, base, criterion, optparse-applicative, process
      , silently, text, turtle
···
        homepage = "http://github.com/Gabriel439/bench";
        description = "Command-line benchmark tool";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "bench_1_0_8" = callPackage
+    ({ mkDerivation, base, criterion, optparse-applicative, process
+     , silently, text, turtle
+     }:
+     mkDerivation {
+       pname = "bench";
+       version = "1.0.8";
+       sha256 = "18lyjkyz1yynnln92ihn9g28w2s2xmahaqg1lr1cr2v3kpv8ilvl";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base criterion optparse-applicative process silently text turtle
+       ];
+       homepage = "http://github.com/Gabriel439/bench";
+       description = "Command-line benchmark tool";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "benchmark-function" = callPackage
···
      }) {};
 
   "bizzlelude" = callPackage
-    ({ mkDerivation, base, containers, directory, text }:
+    ({ mkDerivation, base-noprelude, containers, directory, text }:
      mkDerivation {
        pname = "bizzlelude";
-       version = "1.0.4";
-       sha256 = "0vaw51cn9lmnd6pxb8kjf9k6lxzxwzv0nmgr7j1h8b6qbchf2i3q";
-       libraryHaskellDepends = [ base containers directory text ];
+       version = "1.1.0";
+       sha256 = "1vpdh9fm4jrl7zkzp8wh8ng3x6glwk3h88fbjmajz6qpqw3z2w4h";
+       libraryHaskellDepends = [
+         base-noprelude containers directory text
+       ];
        homepage = "http://github.com/TheBizzle";
        description = "A lousy Prelude replacement by a lousy dude";
        license = stdenv.lib.licenses.bsd3;
···
        homepage = "https://github.com/bitemyapp/bloodhound";
        description = "ElasticSearch client library for Haskell";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "bloodhound_0_15_0_1" = callPackage
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
+     , data-default-class, errors, exceptions, generics-sop, hashable
+     , hspec, http-client, http-types, mtl, mtl-compat, network-uri
+     , QuickCheck, quickcheck-properties, scientific, semigroups
+     , temporary, text, time, transformers, unix-compat
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "bloodhound";
+       version = "0.15.0.1";
+       sha256 = "0g85fp2vppx6p1zbx506jnsfcik8q7nmc98fwrhcckgvkbdpi2v8";
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring containers data-default-class
+         exceptions hashable http-client http-types mtl mtl-compat
+         network-uri scientific semigroups text time transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers errors exceptions generics-sop
+         hspec http-client http-types mtl network-uri QuickCheck
+         quickcheck-properties semigroups temporary text time unix-compat
+         unordered-containers vector
+       ];
+       homepage = "https://github.com/bitemyapp/bloodhound";
+       description = "ElasticSearch client library for Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "bloodhound-amazonka-auth" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "brick-skylighting" = callPackage
+    ({ mkDerivation, base, brick, containers, skylighting, text, vty }:
+     mkDerivation {
+       pname = "brick-skylighting";
+       version = "0.1";
+       sha256 = "189qpq2cg45binlb9nq43h05g97ch56855xlz2givxw8psb0kb1i";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base brick containers skylighting text vty
+       ];
+       executableHaskellDepends = [ base brick skylighting text vty ];
+       homepage = "https://github.com/jtdaugherty/brick-skylighting/";
+       description = "Show syntax-highlighted text in your Brick UI";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "bricks" = callPackage
     ({ mkDerivation, base, containers, doctest, hedgehog, parsec
      , template-haskell, text
···
      }) {};
 
   "cabal-plan" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, base-orphans
-     , base16-bytestring, bytestring, containers, directory, filepath
-     , text, vector
+    ({ mkDerivation, aeson, ansi-terminal, base, base-compat
+     , base-orphans, base16-bytestring, bytestring, containers
+     , directory, filepath, mtl, optparse-applicative, parsec, text
+     , vector
      }:
      mkDerivation {
        pname = "cabal-plan";
        version = "0.3.0.0";
        sha256 = "1axi3a60zq08d760w2x6akmszad599kij0r8zmlq8pin9mmmggls";
+       configureFlags = [ "-fexe" ];
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base base-compat base-orphans base16-bytestring bytestring
          containers directory filepath text vector
+       ];
+       executableHaskellDepends = [
+         ansi-terminal base base-compat bytestring containers mtl
+         optparse-applicative parsec text vector
        ];
        description = "Library and utiltity for processing cabal's plan.json file";
        license = stdenv.lib.licenses.gpl3;
···
      }) {};
 
   "cabal2spec" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
-     , haskell98, old-locale, process, tar, time, unix, Unixutils, zlib
+    ({ mkDerivation, base, Cabal, filepath, optparse-applicative, tasty
+     , tasty-golden, time
      }:
      mkDerivation {
        pname = "cabal2spec";
-       version = "1.0";
-       sha256 = "08y8rwj86n7f3bqfv2ximlx8qas12zspiz6ix8gg01whsry43nsj";
-       isLibrary = false;
+       version = "2.0.0";
+       sha256 = "16xvv9qg1rxxnb9mdymx574kx6awhrn855x59ihl27bzp2q2pa53";
+       isLibrary = true;
        isExecutable = true;
+       libraryHaskellDepends = [ base Cabal filepath time ];
        executableHaskellDepends = [
-         base bytestring Cabal directory filepath haskell98 old-locale
-         process tar time unix Unixutils zlib
+         base Cabal filepath optparse-applicative
        ];
-       homepage = "https://fedorahosted.org/cabal2spec/";
-       description = "Generates RPM Spec files from cabal files";
-       license = "GPL";
+       testHaskellDepends = [ base Cabal filepath tasty tasty-golden ];
+       homepage = "https://github.com/peti/cabal2spec";
+       description = "Convert Cabal files into rpm spec files";
+       license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
 
   "cassava-records" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, cassava, containers
-     , foldl, HUnit, lens, pptable, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, text, unordered-containers
-     , vector
+     , foldl, HUnit, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
+     , template-haskell, text, unordered-containers, vector
      }:
      mkDerivation {
        pname = "cassava-records";
-       version = "0.1.0.1";
-       sha256 = "0j089vmjckdcvkbzr1w156kgxz9k94flja45xndsf602c7r21382";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.1.0.4";
+       sha256 = "13dgcqrlvcqifgisfk80f9siwzzbk96jhhbrnmrpmg95270k5y0i";
        libraryHaskellDepends = [
          attoparsec base bytestring cassava foldl template-haskell text
          unordered-containers vector
        ];
-       executableHaskellDepends = [
-         attoparsec base bytestring cassava foldl lens pptable
-         template-haskell text unordered-containers vector
-       ];
        testHaskellDepends = [
          attoparsec base bytestring cassava containers foldl HUnit
          QuickCheck tasty tasty-hunit tasty-quickcheck template-haskell text
···
        pname = "cayley-client";
        version = "0.4.1";
        sha256 = "11q92jbc4sgvif6akd5vvsdj3ncx0xhwk0mimyc55m4m7srjdplq";
+       libraryHaskellDepends = [
+         aeson attoparsec base binary bytestring exceptions http-client
+         http-conduit lens lens-aeson mtl text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ aeson base hspec unordered-containers ];
+       homepage = "https://github.com/MichelBoucey/cayley-client";
+       description = "A Haskell client for the Cayley graph database";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "cayley-client_0_4_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
+     , exceptions, hspec, http-client, http-conduit, lens, lens-aeson
+     , mtl, text, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "cayley-client";
+       version = "0.4.2";
+       sha256 = "1pzsr7jcqsi27mnxgq4y5np4ysig29cmk27iqp0m73xj5fiss6z8";
        libraryHaskellDepends = [
          aeson attoparsec base binary bytestring exceptions http-client
          http-conduit lens lens-aeson mtl text transformers
···
        homepage = "https://github.com/GaloisInc/cereal";
        description = "A binary serialization library";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "cereal_0_5_5_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, ghc-prim
+     , QuickCheck, test-framework, test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "cereal";
+       version = "0.5.5.0";
+       sha256 = "08k8y6nf3n8h8gzw4a44mssy7rhgpmfj28lhczjz4vgszc7k55qb";
+       libraryHaskellDepends = [
+         array base bytestring containers ghc-prim
+       ];
+       testHaskellDepends = [
+         base bytestring QuickCheck test-framework
+         test-framework-quickcheck2
+       ];
+       homepage = "https://github.com/GaloisInc/cereal";
+       description = "A binary serialization library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "cereal-conduit" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "chatwork_0_1_3_0" = callPackage
+    ({ mkDerivation, aeson, aeson-casing, base, bytestring, connection
+     , data-default-class, hspec, http-api-data, http-client
+     , http-client-tls, http-types, req, servant-server, text, warp
+     }:
+     mkDerivation {
+       pname = "chatwork";
+       version = "0.1.3.0";
+       sha256 = "1b6s5f2v4qc19l2psbpwlx6nyq0285mpfl25gfv4p9xrsdmqcyr4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-casing base bytestring connection data-default-class
+         http-api-data http-client http-client-tls http-types req text
+       ];
+       executableHaskellDepends = [
+         aeson aeson-casing base bytestring connection data-default-class
+         http-api-data http-client http-client-tls http-types req text
+       ];
+       testHaskellDepends = [
+         aeson aeson-casing base bytestring connection data-default-class
+         hspec http-api-data http-client http-client-tls http-types req
+         servant-server text warp
+       ];
+       homepage = "https://github.com/matsubara0507/chatwork#readme";
+       description = "The ChatWork API in Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "cheapskate" = callPackage
     ({ mkDerivation, base, blaze-html, bytestring, containers
      , data-default, deepseq, mtl, syb, text, uniplate, xss-sanitize
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cmdargs_0_10_20" = callPackage
+    ({ mkDerivation, base, filepath, process, template-haskell
+     , transformers
+     }:
+     mkDerivation {
+       pname = "cmdargs";
+       version = "0.10.20";
+       sha256 = "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base filepath process template-haskell transformers
+       ];
+       executableHaskellDepends = [
+         base filepath process template-haskell transformers
+       ];
+       homepage = "https://github.com/ndmitchell/cmdargs#readme";
+       description = "Command line argument processing";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "cmdargs-browser" = callPackage
     ({ mkDerivation, base, bytestring, cmdargs, directory, filepath
      , http-types, process, text, transformers, wai, wai-handler-launch
···
     ({ mkDerivation, base, containers, transformers, vector }:
      mkDerivation {
        pname = "compactable";
-       version = "0.1.0.3";
-       sha256 = "0zcazqwmyd458iv0j572fc8p13lbb57kdpfviqx2qlwmicb7i8z7";
+       version = "0.1.0.4";
+       sha256 = "1xf13k0syj8ssjgf2snddkgljwxpb4gpl0di9hsf1iy1wcx6pgh6";
        libraryHaskellDepends = [ base containers transformers vector ];
-       description = "A generalization for containers that can be stripped of Nothings";
+       description = "A typeclass for structures which can be catMaybed, filtered, and partitioned";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "composition-prelude";
-       version = "1.1.0.0";
-       sha256 = "12wiwbpkh663xmdvw4rhf605vlghnl1gmq55zaqdpwymqzb0y5f4";
+       version = "1.1.0.2";
+       sha256 = "1r6i0b9kphx8pmmlkna50gdsqwsmsc538nxhax3imxydi2lhxsdd";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/vmchale/composition-prelude#readme";
        description = "Higher-order function combinators";
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
+  "concurrent-output_1_10_2" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
+     , process, stm, terminal-size, text, transformers, unix
+     }:
+     mkDerivation {
+       pname = "concurrent-output";
+       version = "1.10.2";
+       sha256 = "02kfg61f7lm8796n4pdi7yvscg8n869vhl9i6rd9rpyb4l9myzd1";
+       libraryHaskellDepends = [
+         ansi-terminal async base directory exceptions process stm
+         terminal-size text transformers unix
+       ];
+       description = "Ungarble output from several threads or commands";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "concurrent-rpc" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
     ({ mkDerivation, base, extra, hspec, lens, parsec, text }:
      mkDerivation {
        pname = "config-parser";
-       version = "1.1.0.1";
-       sha256 = "1v3lqq8bnp2s9zyfpa9jq80wwbnsx3mww82xmwc3yi4mvw7vnmc1";
+       version = "1.2.0.0";
+       sha256 = "1jmb8c2ksxp9gfryymg100hjfn5kfshi95a1533d6h18ypqd5zb3";
        libraryHaskellDepends = [ base parsec text ];
        testHaskellDepends = [ base extra hspec lens parsec text ];
        homepage = "https://github.com/protoben/config-parser";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "containers_0_5_10_2" = callPackage
+  "containers_0_5_11_0" = callPackage
     ({ mkDerivation, array, base, ChasingBottoms, criterion, deepseq
      , ghc-prim, HUnit, QuickCheck, random, test-framework
      , test-framework-hunit, test-framework-quickcheck2, transformers
      }:
      mkDerivation {
        pname = "containers";
-       version = "0.5.10.2";
-       sha256 = "08wc6asnyjdvabqyp15lsbccqwbjy77zjdhwrbg2q9xyj3rgwkm0";
+       version = "0.5.11.0";
+       sha256 = "0j29w09kvcn1c0yi4clmrdbgs2gqmpxs2m7q80ib2ix1smm25kaq";
        libraryHaskellDepends = [ array base deepseq ghc-prim ];
        testHaskellDepends = [
          array base ChasingBottoms deepseq ghc-prim HUnit QuickCheck
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "control-dotdotdot";
-       version = "0.1.0.0";
-       sha256 = "0wacfs0s0dy2vzj8yxm3zqsjc93fm8m4iiw5x92wpiz2z2lm3k8d";
+       version = "0.1.0.1";
+       sha256 = "0rwi5zwvqn18g7qyp9aw51w3yzkqbff9g7rcqdk1l871fvq8qhha";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/erisco/control-dotdotdot";
        description = "Haskell operator `g ... f = \x1 .. xn -> g (f x1 .. xn)`.";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cubicbezier_0_6_0_5" = callPackage
+    ({ mkDerivation, base, containers, fast-math, integration, matrices
+     , microlens, microlens-mtl, microlens-th, mtl, parsec, tasty
+     , tasty-hunit, vector, vector-space
+     }:
+     mkDerivation {
+       pname = "cubicbezier";
+       version = "0.6.0.5";
+       sha256 = "0n17nr20skrds3b9gzy0v86jgnqz8zbds796n9cl0z6rh9bq5jf5";
+       libraryHaskellDepends = [
+         base containers fast-math integration matrices microlens
+         microlens-mtl microlens-th mtl vector vector-space
+       ];
+       testHaskellDepends = [ base parsec tasty tasty-hunit ];
+       description = "Efficient manipulating of 2D cubic bezier curves";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "cubicspline" = callPackage
     ({ mkDerivation, base, hmatrix, safe }:
      mkDerivation {
···
        homepage = "https://github.com/koterpillar/current-locale";
        description = "Get the current system locale in System.Locale format";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "curry" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "curry";
+       version = "0.0.0.0";
+       sha256 = "09kwv72pww29xhp4sp7czp3pgjdggzs5ggj8cmzng8xzzgsgd1dv";
+       libraryHaskellDepends = [ base ];
+       description = "Curry types";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "curry-base" = callPackage
···
     ({ mkDerivation, base, containers }:
      mkDerivation {
        pname = "data-foldapp";
-       version = "0.1.0.0";
-       sha256 = "0m2rwai52q712fxkpk4k23cc8x9dx87c8wwwsg9w5y5pxq78csn8";
+       version = "0.1.1.0";
+       sha256 = "1415cf59wkf1599qcqmrpn9m4v9br3d763v1809mwg9bm2310x65";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/erisco/data-foldapp";
        description = "Fold function applications. Framework for variadic functions.";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "diagrams-builder_0_8_0_2" = callPackage
+    ({ mkDerivation, base, base-orphans, bytestring, cmdargs
+     , diagrams-cairo, diagrams-lib, diagrams-postscript
+     , diagrams-rasterific, diagrams-svg, directory, exceptions
+     , filepath, hashable, haskell-src-exts, haskell-src-exts-simple
+     , hint, JuicyPixels, lens, mtl, split, svg-builder, transformers
+     }:
+     mkDerivation {
+       pname = "diagrams-builder";
+       version = "0.8.0.2";
+       sha256 = "1jr98sza6bhzq9myfb9f2p8lfbs9qcxck67h2hvxisgpvmy0gjn2";
+       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base-orphans cmdargs diagrams-lib directory exceptions
+         filepath hashable haskell-src-exts haskell-src-exts-simple hint
+         lens mtl split transformers
+       ];
+       executableHaskellDepends = [
+         base bytestring cmdargs diagrams-cairo diagrams-lib
+         diagrams-postscript diagrams-rasterific diagrams-svg directory
+         filepath JuicyPixels lens svg-builder
+       ];
+       homepage = "http://projects.haskell.org/diagrams";
+       description = "hint-based build service for the diagrams graphics EDSL";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "diagrams-cairo" = callPackage
     ({ mkDerivation, array, base, bytestring, cairo, colour, containers
      , data-default-class, diagrams-core, diagrams-lib, filepath
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "dns_3_0_1" = callPackage
+    ({ mkDerivation, async, attoparsec, auto-update, base
+     , base64-bytestring, binary, bytestring, conduit, conduit-extra
+     , containers, cryptonite, doctest, hspec, iproute, mtl, network
+     , psqueues, QuickCheck, safe, time, word8
+     }:
+     mkDerivation {
+       pname = "dns";
+       version = "3.0.1";
+       sha256 = "1aq8n0qglvx134fl8ry1liw7kpw7flm631s9qb7is7bw510wgdd6";
+       libraryHaskellDepends = [
+         async attoparsec auto-update base base64-bytestring binary
+         bytestring conduit conduit-extra containers cryptonite iproute mtl
+         network psqueues safe time
+       ];
+       testHaskellDepends = [
+         base bytestring doctest hspec iproute QuickCheck word8
+       ];
+       testTarget = "spec";
+       description = "DNS library in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "dnscache" = callPackage
     ({ mkDerivation, base, bytestring, containers, contstuff, dns
      , iproute, time
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "docker_0_5_0_0" = callPackage
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
+     , conduit-combinators, conduit-extra, connection, containers
+     , data-default-class, directory, exceptions, filemanip, filepath
+     , http-client, http-client-tls, http-conduit, http-types, lens
+     , lens-aeson, monad-control, mtl, network, process, QuickCheck
+     , resourcet, scientific, tar, tasty, tasty-hunit, tasty-quickcheck
+     , temporary, text, time, tls, transformers, transformers-base
+     , unordered-containers, uuid, vector, x509, x509-store, x509-system
+     , zlib
+     }:
+     mkDerivation {
+       pname = "docker";
+       version = "0.5.0.0";
+       sha256 = "1zaypbnk0dk5bwr8zxq5bmq5aqzgcgl0sqvxqq115ia863m0d1wv";
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring conduit conduit-combinators
+         conduit-extra containers data-default-class directory exceptions
+         filemanip filepath http-client http-conduit http-types
+         monad-control mtl network resourcet scientific tar temporary text
+         time tls transformers transformers-base unordered-containers uuid
+         vector x509 x509-store x509-system zlib
+       ];
+       testHaskellDepends = [
+         aeson base bytestring connection containers directory http-client
+         http-client-tls http-types lens lens-aeson process QuickCheck tasty
+         tasty-hunit tasty-quickcheck text transformers unordered-containers
+         vector
+       ];
+       homepage = "https://github.com/denibertovic/docker-hs";
+       description = "An API client for docker written in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "docker-build-cacher" = callPackage
     ({ mkDerivation, base, containers, foldl, language-docker
      , system-filepath, text, turtle
···
     ({ mkDerivation, base, type-level-sets }:
      mkDerivation {
        pname = "effect-monad";
-       version = "0.7.0.0";
-       sha256 = "05jlh86hfxawkbckvw2f2xj8yc36w2hr1w3l6q75359mwa7bp7fy";
+       version = "0.8.1.0";
+       sha256 = "0lrx586ij1c09hv1rj14l2xi3papzdg8496kas6czdld0kfj8kw1";
        libraryHaskellDepends = [ base type-level-sets ];
-       description = "Embeds effect systems into Haskell using graded monads";
+       description = "Embeds effect systems and program logics into Haskell using graded monads and parameterised monads";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "email-validate_2_3_2_1" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, doctest, hspec
+     , QuickCheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "email-validate";
+       version = "2.3.2.1";
+       sha256 = "0qvxysiap3r4mi3xff5nsk9qv6diqxfgwj186bypbamzvzlz0lav";
+       libraryHaskellDepends = [
+         attoparsec base bytestring template-haskell
+       ];
+       testHaskellDepends = [ base bytestring doctest hspec QuickCheck ];
+       homepage = "https://github.com/Porges/email-validate-hs";
+       description = "Email address validation";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "email-validate-json" = callPackage
     ({ mkDerivation, aeson, base, email-validate, text }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "extensible_0_4_7_1" = callPackage
+    ({ mkDerivation, base, comonad, constraints, deepseq, ghc-prim
+     , hashable, lens, monad-skeleton, mtl, primitive, profunctors
+     , QuickCheck, semigroups, StateVar, tagged, template-haskell
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "extensible";
+       version = "0.4.7.1";
+       sha256 = "04gb1havami26mkwdr9vbqs28r1rc9ggd9xxcaf6zw9s5z2hvr5a";
+       libraryHaskellDepends = [
+         base comonad constraints deepseq ghc-prim hashable monad-skeleton
+         mtl primitive profunctors QuickCheck semigroups StateVar tagged
+         template-haskell transformers vector
+       ];
+       testHaskellDepends = [ base lens QuickCheck template-haskell ];
+       homepage = "https://github.com/fumieval/extensible";
+       description = "Extensible, efficient, optics-friendly data types and effects";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "extensible-data" = callPackage
     ({ mkDerivation, base, data-lens, hashable, template-haskell
      , unordered-containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "filepath_1_4_1_2" = callPackage
+  "filepath_1_4_2" = callPackage
     ({ mkDerivation, base, QuickCheck }:
      mkDerivation {
        pname = "filepath";
-       version = "1.4.1.2";
-       sha256 = "1hrbi7ckrkqzw73ziqiyh00xp28c79pk0jrj1vqiq5nwfs3hryvv";
+       version = "1.4.2";
+       sha256 = "0bnryq00xbcsswxmahl42x85bfh23mxsap0gq8q0dm1v67ij7a0q";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        homepage = "https://github.com/haskell/filepath#readme";
···
      }) {};
 
   "folgerhs" = callPackage
-    ({ mkDerivation, base, xml }:
+    ({ mkDerivation, array, base, containers, gloss
+     , optparse-applicative, xml
+     }:
      mkDerivation {
        pname = "folgerhs";
-       version = "0.1.0.1";
-       sha256 = "0kn89abvbk7faynhsyg177rayxddvwnkgsjb5cng8044n9glw9sb";
+       version = "0.3.0.2";
+       sha256 = "0dxig93mf29778sq71wz913d405g07dzkpbjp8cm4xsz1p86xryh";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base xml ];
-       executableHaskellDepends = [ base xml ];
-       homepage = "https://github.com/SU-LOSP/tools#readme";
+       libraryHaskellDepends = [ array base containers gloss xml ];
+       executableHaskellDepends = [
+         array base containers gloss optparse-applicative xml
+       ];
+       homepage = "https://github.com/SU-LOSP/folgerhs#readme";
        description = "Toolset for Folger Shakespeare Library's XML annotated plays";
        license = stdenv.lib.licenses.gpl3;
      }) {};
···
      }) {};
 
   "freelude" = callPackage
-    ({ mkDerivation, array, base, containers, doctest, indextype
-     , transformers
+    ({ mkDerivation, array, base, bytestring, containers, doctest
+     , indextype, text, transformers
      }:
      mkDerivation {
        pname = "freelude";
-       version = "0.1.0.1";
-       sha256 = "0a16vbm17dvvfk9wp8y9df8qypy14vld4yq20hh273p2cdxx5p2n";
+       version = "0.3.1.0";
+       sha256 = "1rz7xpffyw4nl7iaxfmhzzmn7kyvv8rfh4wvv2d02i2ihfykirxs";
        libraryHaskellDepends = [
-         array base containers indextype transformers
+         array base bytestring containers indextype text transformers
        ];
        testHaskellDepends = [
-         array base containers doctest indextype transformers
+         array base bytestring containers doctest indextype text
+         transformers
        ];
        homepage = "https://github.com/clintonmead/freelude#readme";
        description = "A generalisation of the Category->Functor->Applicative->Monad hierarchy and more";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "geos" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, geos_c, hspec, mtl
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "geos";
+       version = "0.1.0.0";
+       sha256 = "02r9c063kkqalyadfqwhhwfb42kky7nkfp5k968l1qidyx6aha5j";
+       libraryHaskellDepends = [
+         base bytestring cassava mtl transformers vector
+       ];
+       librarySystemDepends = [ geos_c ];
+       testHaskellDepends = [ base bytestring cassava hspec mtl vector ];
+       testSystemDepends = [ geos_c ];
+       description = "Bindings for GEOS";
+       license = stdenv.lib.licenses.mit;
+     }) {geos_c = null;};
+
   "getemx" = callPackage
     ({ mkDerivation, base, curl, directory, filepath, haskell98, hxt
      , mtl, old-locale, process, time
···
        description = "backs up everything github knows about a repository, to the repository";
        license = stdenv.lib.licenses.gpl3;
      }) {inherit (pkgs) git;};
+
+  "github-data" = callPackage
+    ({ mkDerivation, aeson, aeson-compat, base, base-compat
+     , base16-bytestring, binary, binary-orphans, bytestring, containers
+     , deepseq, deepseq-generics, exceptions, hashable, http-client
+     , http-types, iso8601-time, network-uri, text, time, tls
+     , transformers, transformers-compat, unordered-containers, vector
+     , vector-instances
+     }:
+     mkDerivation {
+       pname = "github-data";
+       version = "0.18";
+       sha256 = "1rqnjw8cz4xby1gbc9w8wpk1z0vg8wsm8jq7qz0ncjrm8manii5p";
+       libraryHaskellDepends = [
+         aeson aeson-compat base base-compat base16-bytestring binary
+         binary-orphans bytestring containers deepseq deepseq-generics
+         exceptions hashable http-client http-types iso8601-time network-uri
+         text time tls transformers transformers-compat unordered-containers
+         vector vector-instances
+       ];
+       homepage = "https://github.com/strake/github.hs";
+       description = "Access to the GitHub API, v3";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
 
   "github-post-receive" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hamilton_0_1_0_2" = callPackage
+    ({ mkDerivation, ad, ansi-wl-pprint, base, comonad, containers
+     , free, hmatrix, hmatrix-gsl, optparse-applicative
+     , typelits-witnesses, vector, vector-sized, vty
+     }:
+     mkDerivation {
+       pname = "hamilton";
+       version = "0.1.0.2";
+       sha256 = "1fhwvimqim9jj33wps42wsbwjz28h3waqn7wrwhqci307xbcib0m";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ad base comonad free hmatrix hmatrix-gsl typelits-witnesses
+         vector-sized
+       ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base containers hmatrix optparse-applicative vector
+         vector-sized vty
+       ];
+       homepage = "https://github.com/mstksg/hamilton";
+       description = "Physics on generalized coordinate systems using Hamiltonian Mechanics and AD";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hamlet" = callPackage
     ({ mkDerivation, base, shakespeare }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hedgehog-corpus" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "hedgehog-corpus";
+       version = "0.1.0";
+       sha256 = "1whrszkd03d9a86vqnp38sq8gs2hfdc39wxcf5c12w3767c9qmn3";
+       libraryHaskellDepends = [ base ];
+       homepage = "https://github.com/tmcgilchrist/hedgehog-corpus";
+       description = "hedgehog-corpus";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hedgehog-gen-json" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, exceptions
      , hedgehog, lens, protolude, regex-genex, regex-posix, scientific
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hlist" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "hlist";
+       version = "0.0.0.0";
+       sha256 = "128y1l4bjyrsvx188mx58x8a98j7jk931h0nv5bprpxjkc71c32k";
+       libraryHaskellDepends = [ base ];
+       description = "Heterogeneous list";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hlogger" = callPackage
     ({ mkDerivation, base, old-locale, time }:
      mkDerivation {
···
     ({ mkDerivation, base, doctest, hmatrix, nlopt-haskell, vector }:
      mkDerivation {
        pname = "hmatrix-nlopt";
-       version = "0.1.0.0";
-       sha256 = "12h2svm2x3bc9ivii90f8cr4npwpagchazlmgj36x381aqradsf2";
+       version = "0.1.1.0";
+       sha256 = "1fgicpzi811ifdyrc8gzd8dgb0f14lw92rdidmbps3yisczysz29";
        libraryHaskellDepends = [ base hmatrix nlopt-haskell vector ];
        testHaskellDepends = [ base doctest ];
        homepage = "https://github.com/peddie/hmatrix-nlopt";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hnix_0_4_0" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, containers, criterion
+     , data-fix, deepseq, deriving-compat, parsers, regex-tdfa
+     , regex-tdfa-text, semigroups, tasty, tasty-hunit, tasty-th, text
+     , transformers, trifecta, unordered-containers
+     }:
+     mkDerivation {
+       pname = "hnix";
+       version = "0.4.0";
+       sha256 = "0rgx97ckv5zvly6x76h7nncswfw0ik4bhnlj8n5bpl4rqzd7d4fd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-wl-pprint base containers data-fix deepseq deriving-compat
+         parsers regex-tdfa regex-tdfa-text semigroups text transformers
+         trifecta unordered-containers
+       ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base containers data-fix deepseq
+       ];
+       testHaskellDepends = [
+         base containers data-fix tasty tasty-hunit tasty-th text
+       ];
+       benchmarkHaskellDepends = [ base containers criterion text ];
+       homepage = "http://github.com/jwiegley/hnix";
+       description = "Haskell implementation of the Nix language";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hnn" = callPackage
     ({ mkDerivation, base, binary, bytestring, hmatrix, mwc-random
      , random, vector, vector-binary-instances, zlib
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hpio_0_9_0_3" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , doctest, exceptions, filepath, hlint, hspec, monad-control
+     , monad-logger, mtl, optparse-applicative, protolude, QuickCheck
+     , text, transformers, transformers-base, unix, unix-bytestring
+     }:
+     mkDerivation {
+       pname = "hpio";
+       version = "0.9.0.3";
+       sha256 = "0cz7dxxxxfr142gr3hrq1k1x8axdgvyw7bsjsd1v9spka2i03rcd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers directory exceptions filepath
+         monad-control monad-logger mtl protolude QuickCheck text
+         transformers transformers-base unix unix-bytestring
+       ];
+       executableHaskellDepends = [
+         async base exceptions mtl optparse-applicative protolude text
+         transformers
+       ];
+       testHaskellDepends = [
+         base containers directory doctest exceptions filepath hlint hspec
+         protolude QuickCheck
+       ];
+       homepage = "https://github.com/quixoftic/hpio#readme";
+       description = "Monads for GPIO in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hplayground" = callPackage
     ({ mkDerivation, base, containers, data-default, haste-compiler
      , haste-perch, monads-tf, transformers
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "hruby_0_3_4_4" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, QuickCheck
-     , ruby, scientific, stm, text, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "hruby";
-       version = "0.3.4.4";
-       sha256 = "08997g32rnmwznzywf1k0bmki0kbcwss9s4lka6s501l54gp1ij9";
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring scientific stm text
-         unordered-containers vector
-       ];
-       librarySystemDepends = [ ruby ];
-       testHaskellDepends = [
-         aeson attoparsec base QuickCheck text vector
-       ];
-       description = "Embed a Ruby intepreter in your Haskell program !";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {inherit (pkgs) ruby;};
-
   "hruby" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, QuickCheck
      , ruby, scientific, stm, text, unordered-containers, vector
···
      }:
      mkDerivation {
        pname = "hsdev";
-       version = "0.3.0.1";
-       sha256 = "02wwwxbr6ymmxw3g0m47bxm82mdh755f8jr6vjcbmdb60bqn9lrn";
+       version = "0.3.0.3";
+       sha256 = "03silw148f3wr62j5zdyy1qq6jmsmfhijmghcv0bf7sgv0lgaycv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "http-client_0_5_8" = callPackage
+  "http-client_0_5_9" = callPackage
     ({ mkDerivation, array, async, base, base64-bytestring
      , blaze-builder, bytestring, case-insensitive, containers, cookie
      , deepseq, directory, exceptions, filepath, ghc-prim, hspec
···
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.5.8";
-       sha256 = "13khi2vsx2la0s4pvysdfharjnbway7nbv1fcw4bjld8crbpwb68";
-       revision = "1";
-       editedCabalFile = "023gnif575iaq25af2d4dwcppagnph74ig3xdsda1fp1k5cwif9q";
+       version = "0.5.9";
+       sha256 = "0bccpvinzc7z5v83grjzvd3g3kdz2q5h2206l7x9jh4bvz9prblf";
        libraryHaskellDepends = [
          array base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie deepseq exceptions filepath
···
        pname = "imprint";
        version = "0.0.1.0";
        sha256 = "0f56zy6ay6wvcvqfplvc3gckngxngxm9r62h1w36lxm74xy8544v";
+       revision = "1";
+       editedCabalFile = "13418pfcsanj7cl651v4qqbypgjkrpld2gs560kpw3k2lj6w4wa0";
        libraryHaskellDepends = [ base binary bytestring constraints ];
        testHaskellDepends = [ base binary constraints hspec ];
        homepage = "https://github.com/mrkkrp/imprint";
···
      }:
      mkDerivation {
        pname = "impure-containers";
-       version = "0.4.2";
-       sha256 = "04g7xsa9mylfcjahlr3d81k8cvf0fi4rg8wkk2x4z6hmidy5s4kg";
+       version = "0.4.3";
+       sha256 = "003r3ppwdwndg8q84bnh299f04b88bhnxxl65nbrz9xl77lfz2y0";
        libraryHaskellDepends = [
          base containers ghc-prim hashable primitive vector
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "invertible_0_2_0_3" = callPackage
+    ({ mkDerivation, base, haskell-src-meta, invariant, lens
+     , partial-isomorphisms, QuickCheck, semigroupoids, template-haskell
+     , transformers, TypeCompose
+     }:
+     mkDerivation {
+       pname = "invertible";
+       version = "0.2.0.3";
+       sha256 = "0pckhl1nv6w66k3ll9q1bwbmzl2rpbwk6c3xkm7dscxzjzw43qwf";
+       libraryHaskellDepends = [
+         base haskell-src-meta invariant lens partial-isomorphisms
+         semigroupoids template-haskell transformers TypeCompose
+       ];
+       testHaskellDepends = [ base QuickCheck transformers ];
+       description = "bidirectional arrows, bijective functions, and invariant functors";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "invertible-hlist" = callPackage
     ({ mkDerivation, base, HList, invertible }:
      mkDerivation {
···
        pname = "ip";
        version = "1.1.1";
        sha256 = "150gbl7589w1a1imqn8qh5g9ar68bkkx0ifiab5zf0gvxgkiz4jd";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring hashable primitive text vector
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring doctest HUnit QuickCheck
+         quickcheck-classes test-framework test-framework-hunit
+         test-framework-quickcheck2 text
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring criterion text
+       ];
+       homepage = "https://github.com/andrewthad/haskell-ip#readme";
+       description = "Library for IP and MAC addresses";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "ip_1_1_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, criterion
+     , doctest, hashable, HUnit, primitive, QuickCheck
+     , quickcheck-classes, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text, vector
+     }:
+     mkDerivation {
+       pname = "ip";
+       version = "1.1.2";
+       sha256 = "16vjbcrjpvs4wh89r4k3d5hpkklvcvrk50qjnx67bsi2jjhcn0aj";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring hashable primitive text vector
        ];
···
        homepage = "https://github.com/ndmitchell/js-jquery#readme";
        description = "Obtain minified jQuery code";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "js-jquery_3_3_1" = callPackage
+    ({ mkDerivation, base, HTTP }:
+     mkDerivation {
+       pname = "js-jquery";
+       version = "3.3.1";
+       sha256 = "16q68jzbs7kp07dnq8cprdcc8fd41rim38039vg0w4x11lgniq70";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HTTP ];
+       doCheck = false;
+       homepage = "https://github.com/ndmitchell/js-jquery#readme";
+       description = "Obtain minified jQuery code";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "jsaddle" = callPackage
···
      }:
      mkDerivation {
   "nlopt-haskell" = callPackage
-       version = "0.1.0.3";
-  "nlopt-haskell" = callPackage
+       version = "0.1.1.2";
+       sha256 = "0cy5rk1b3blk8gwbnbmiiml0myccxgj127y0kzglfqwazal9i45g";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
   "nlopt-haskell" = callPackage
···
        ];
   "nlopt-haskell" = callPackage
   "nlopt-haskell" = callPackage
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "language-js" = callPackage
+    ({ mkDerivation, base, hspec, parsec }:
+     mkDerivation {
+       pname = "language-js";
+       version = "0.2.0";
+       sha256 = "0j87w6sqyl67ad9qar2q240kbzksds3a301cdykjfa3n6a0r81z1";
+       libraryHaskellDepends = [ base parsec ];
+       testHaskellDepends = [ base hspec parsec ];
+       homepage = "https://github.com/diasbruno/language-js#readme";
+       description = "javascript parser for es6 and es7";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        homepage = "https://github.com/maoe/lifted-async";
        description = "Run lifted IO operations asynchronously and wait for their results";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "lifted-async_0_9_3_3" = callPackage
+    ({ mkDerivation, async, base, constraints, criterion, deepseq
+     , HUnit, lifted-base, monad-control, mtl, tasty, tasty-hunit
+     , tasty-th, transformers-base
+     }:
+     mkDerivation {
+       pname = "lifted-async";
+       version = "0.9.3.3";
+       sha256 = "1gqd4ih72mky1s97120yx9gmabaxb1l54b3jwijsl8fxng5djdxf";
+       libraryHaskellDepends = [
+         async base constraints lifted-base monad-control transformers-base
+       ];
+       testHaskellDepends = [
+         async base HUnit lifted-base monad-control mtl tasty tasty-hunit
+         tasty-th
+       ];
+       benchmarkHaskellDepends = [ async base criterion deepseq ];
+       homepage = "https://github.com/maoe/lifted-async";
+       description = "Run lifted IO operations asynchronously and wait for their results";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "lifted-base" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "magicbane_0_2_0" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, async, attoparsec, base
+     , bytestring, conduit, conduit-combinators, data-default, data-has
+     , ekg-core, ekg-wai, envy, errors, fast-logger, http-api-data
+     , http-client, http-client-tls, http-conduit, http-link-header
+     , http-types, lifted-async, lifted-base, monad-control
+     , monad-logger, monad-metrics, mono-traversable, mtl, network-uri
+     , raw-strings-qq, refined, safe-exceptions, servant-server, split
+     , string-conversions, text, transformers, transformers-base
+     , unordered-containers, wai, wai-cli, wai-middleware-metrics
+     }:
+     mkDerivation {
+       pname = "magicbane";
+       version = "0.2.0";
+       sha256 = "0v67mycp7mgawcwnkw68pivyicp9p2nj0f9isrdb14x5smm1f1zd";
+       libraryHaskellDepends = [
+         aeson aeson-qq async attoparsec base bytestring conduit
+         conduit-combinators data-default data-has ekg-core ekg-wai envy
+         errors fast-logger http-api-data http-client http-client-tls
+         http-conduit http-link-header http-types lifted-async lifted-base
+         monad-control monad-logger monad-metrics mono-traversable mtl
+         network-uri raw-strings-qq refined safe-exceptions servant-server
+         split string-conversions text transformers transformers-base
+         unordered-containers wai wai-cli wai-middleware-metrics
+       ];
+       homepage = "https://github.com/myfreeweb/magicbane#readme";
+       description = "A web framework that integrates Servant, EKG, fast-logger, wai-cli…";
+       license = stdenv.lib.licenses.publicDomain;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "magico" = callPackage
     ({ mkDerivation, base, hmatrix, transformers, utility-ht }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "memory_0_14_13" = callPackage
+  "memory_0_14_14" = callPackage
     ({ mkDerivation, base, basement, bytestring, deepseq, foundation
      , ghc-prim, tasty, tasty-hunit, tasty-quickcheck
      }:
      mkDerivation {
        pname = "memory";
-       version = "0.14.13";
-       sha256 = "0ycxk9yp0bd29jqn48vzblxaa8sny8mw652icyvg3zg3sjg9pjxd";
+       version = "0.14.14";
+       sha256 = "03lnb7nqshddiwqbz1vpba7mb6l80nav896rr77vlp8m41b9h6qx";
        libraryHaskellDepends = [
          base basement bytestring deepseq foundation ghc-prim
        ];
        testHaskellDepends = [
-         base basement foundation tasty tasty-hunit tasty-quickcheck
+         base basement bytestring foundation tasty tasty-hunit
+         tasty-quickcheck
        ];
        homepage = "https://github.com/vincenthz/hs-memory";
        description = "memory and related abstraction stuff";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "mmark_0_0_5_1" = callPackage
+  "mmark_0_0_5_2" = callPackage
     ({ mkDerivation, aeson, base, case-insensitive, containers
      , criterion, data-default-class, deepseq, dlist, email-validate
      , foldl, hashable, hspec, hspec-megaparsec, html-entity-map, lucid
···
      }:
      mkDerivation {
        pname = "mmark";
-       version = "0.0.5.1";
-       sha256 = "0zx2lcz8ha1s5apr3hnxv4kms1n2c5rajyxhz9gck7kxpx2yviqz";
+       version = "0.0.5.2";
+       sha256 = "1ap0m90dcnxixr8nxvq8i2nj51gmf293cw8bya6i63zw69ip18z4";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base case-insensitive containers data-default-class deepseq
···
      }:
      mkDerivation {
        pname = "mmark-cli";
-       version = "0.0.1.0";
-       sha256 = "1ix5c7xirhnrbnqp63ff78ddmwq8jimwmadavridanp3cf2wygx2";
+       version = "0.0.2.0";
+       sha256 = "108vrkpb61b1fpyqwqqxx9d3c8jsn0igk3rfm56pxyps2rdpx7px";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
          unordered-containers
        ];
        homepage = "https://github.com/mmark-md/mmark-cli";
-       description = "Description";
+       description = "Command line interface to MMark markdown processor";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "mmark-ext_0_1_0_0" = callPackage
+  "mmark-ext_0_1_1_0" = callPackage
     ({ mkDerivation, base, blaze-html, foldl, hspec, lucid, microlens
      , mmark, modern-uri, skylighting, text
      }:
      mkDerivation {
        pname = "mmark-ext";
-       version = "0.1.0.0";
-       sha256 = "1qwwhjmphxry6dfalhalmyvaw41gr2b70g39acrx4zcqlif6gg3x";
-       revision = "1";
-       editedCabalFile = "0qnadhdn9di4wwib57r05c7xkp3ir7xjdixlpajycpgnzr2p038a";
+       version = "0.1.1.0";
+       sha256 = "0vgsdiagr8bp02dpi8hn4libn0np2z74ksj2vm2x0a76haqlv8kc";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base blaze-html foldl lucid microlens mmark modern-uri skylighting
          text
        ];
        testHaskellDepends = [ base hspec lucid mmark text ];
-       homepage = "https://github.com/mrkkrp/mmark-ext";
+       homepage = "https://github.com/mmark-md/mmark-ext";
        description = "Commonly useful extensions for MMark markdown processor";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "monad-logger_0_3_28" = callPackage
+  "monad-logger_0_3_28_1" = callPackage
     ({ mkDerivation, base, blaze-builder, bytestring, conduit
      , conduit-extra, exceptions, fast-logger, lifted-base
      , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
···
      }:
      mkDerivation {
        pname = "monad-logger";
-       version = "0.3.28";
-       sha256 = "0xmi4b52zdaydcjh4hzr3q3vajhkhjljjbfp3grhx1pc41wycfhr";
+       version = "0.3.28.1";
+       sha256 = "15gpr6wgyqfiz780p8l4lfxmxnanpviyvkba20hdsx92czq64cgr";
        libraryHaskellDepends = [
          base blaze-builder bytestring conduit conduit-extra exceptions
          fast-logger lifted-base monad-control monad-loops mtl resourcet stm
···
      }) {};
 
   "mtl-tf" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation, base, transformers }:
      mkDerivation {
        pname = "mtl-tf";
-       version = "0.1";
-       sha256 = "0qfmswdkj95bh6wkic8hh002wsxqlrylw45k6w9iyzv4saqnl22f";
-       libraryHaskellDepends = [ base ];
-       description = "Monad transformer library using type families";
+       version = "0.2.1.0";
+       sha256 = "0z9vinxhbbg4lpf8mxi0h3jbz4kv6x3ih05q44kjh4z8mpm9szzy";
+       libraryHaskellDepends = [ base transformers ];
+       description = "Monad Transformer Library with Type Families";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "nbt";
-       version = "0.6";
-       sha256 = "0lcnxlj0cfrw840saay3lxyjmc00rxhksqa6ccyhg8119y20gcjd";
+       version = "0.7";
+       sha256 = "10iby4sg50la1k635ygdqf5h50rvidl0k871brdjs8b9hi1vlv5r";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ array base bytestring cereal text ];
        testHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "nest" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hedgehog, text
+     , transformers, unix
+     }:
+     mkDerivation {
+       pname = "nest";
+       version = "0.0.1";
+       sha256 = "1ndd93z9yqa1slhb8wq3j5fr3rc2fna0cb5xqh9s3dynb966zqqk";
+       libraryHaskellDepends = [
+         base bytestring containers text transformers unix
+       ];
+       testHaskellDepends = [ base bytestring containers hedgehog text ];
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "nested-routes" = callPackage
     ({ mkDerivation, attoparsec, base, bifunctors, bytestring
      , composition-extra, errors, exceptions, extractable-singleton
···
      }:
      mkDerivation {
        pname = "ngx-export";
-       version = "1.0.1";
-       sha256 = "1n2d9sh8df6532716pbyxklr3k7lykb6hjf2b976jfd9qrgw505z";
+       version = "1.1.0";
+       sha256 = "1d3xz1jsvnr0rg5y0rpkrlwzng589abq8w5ylg7d5pmr75ih2a0n";
        libraryHaskellDepends = [
          async base binary bytestring deepseq monad-loops template-haskell
          unix
···
     ({ mkDerivation, base, nlopt, vector }:
      mkDerivation {
        pname = "nlopt-haskell";
-       version = "0.1.0.0";
-       sha256 = "0skh0bsms2nsw3dwi4ibjs579bbpc8ya158nrhyn3yxgdx79qgnj";
+       version = "0.1.1.0";
+       sha256 = "1jgszhkr6xc94rjasrhbfm618yz5l37zkibaxycn50fzvsilgfgg";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ nlopt ];
        testHaskellDepends = [ base vector ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "odpic-raw" = callPackage
+    ({ mkDerivation, base, bytestring, c2hs, odpic }:
+     mkDerivation {
+       pname = "odpic-raw";
+       version = "0.1.1";
+       sha256 = "0cvy2xkvdq6k93mly0avbvxmcyxq5s5bayl7zps27zad2b85myr2";
+       libraryHaskellDepends = [ base bytestring ];
+       librarySystemDepends = [ odpic ];
+       libraryToolDepends = [ c2hs ];
+       homepage = "https://github.com/leptonyu/odpic-raw#readme";
+       license = stdenv.lib.licenses.bsd3;
+     }) {odpic = null;};
+
   "oeis" = callPackage
     ({ mkDerivation, base, HTTP, HUnit, network, network-uri
      , test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "optimization";
-       version = "0.1.7";
-       sha256 = "1y490h96qvn9w3z360adbxmbcvw3zpirgfs02hbjkarxi13z4shn";
+       version = "0.1.9";
+       sha256 = "0v1bi97jvdnn4jfknsnayaqdawckh7xxcnkr5nwvxqnpckg89yyf";
        libraryHaskellDepends = [
          ad base distributive linear semigroupoids vector
        ];
···
        homepage = "https://github.com/PasswordManager/passman-core#readme";
        description = "Deterministic password generator core";
        license = stdenv.lib.licenses.gpl3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-       broken = true;
      }) {};
 
   "passwords" = callPackage
···
      }:
      mkDerivation {
        pname = "plugins";
-       version = "1.5.6.0";
-       sha256 = "1l40i9n4iqsj2pw5kv7p8mkfg9vninplasz27zdgfs4hxd9pxl8q";
-       revision = "1";
-       editedCabalFile = "0l4sx1d9lgs6yr23dq4ccz1la9i94cz4nfvpdkpr5wni40mzl2m3";
+       version = "1.5.7";
+       sha256 = "1l9ymnsxvgjp7p2j5mvyygrsg7qf2yam1k4y3gz8s2l6kl78ri5f";
        libraryHaskellDepends = [
          array base Cabal containers directory filepath ghc ghc-paths
          ghc-prim haskell-src process random
        ];
-       homepage = "http://hub.darcs.net/stepcut/plugins";
+       homepage = "https://github.com/stepcut/plugins";
        description = "Dynamic linking for Haskell and C objects";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        pname = "pointed";
        version = "5";
        sha256 = "05sxac90xv4j8glmf2mxs0smmv6vhia0qaaag5v37ar5a6pvh1l9";
-       revision = "1";
-       editedCabalFile = "170gqax34qch77zzqwq95z2lzq9da8gmfxg1vcll4aphhafwgzzp";
+       revision = "2";
+       editedCabalFile = "0x0x44mm29s3ycx17hw0clqvicbypf1w4r01gv3sbvzyy31qph7g";
        libraryHaskellDepends = [
          base comonad containers data-default-class hashable kan-extensions
          semigroupoids semigroups stm tagged transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "pointed_5_0_1" = callPackage
+    ({ mkDerivation, base, comonad, containers, data-default-class
+     , hashable, kan-extensions, semigroupoids, semigroups, stm, tagged
+     , transformers, transformers-compat, unordered-containers
+     }:
+     mkDerivation {
+       pname = "pointed";
+       version = "5.0.1";
+       sha256 = "1p91a762xglckscnhpflxzav8byf49a02mli3983i4kpr2jkaimr";
+       libraryHaskellDepends = [
+         base comonad containers data-default-class hashable kan-extensions
+         semigroupoids semigroups stm tagged transformers
+         transformers-compat unordered-containers
+       ];
+       homepage = "http://github.com/ekmett/pointed/";
+       description = "Pointed and copointed data";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "pointedalternative" = callPackage
     ({ mkDerivation, base, mtl, semigroups, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "pomaps";
-       version = "0.0.0.2";
-       sha256 = "1lsiwpyg5bl5si5ral8lin4hbgbczbf8b4jwd8v1nh2s9293rpb9";
+       version = "0.0.0.3";
+       sha256 = "1gxfaqcg6d9wkm67d8rrjvigy9kvvh9403v3jk790x9pfydcjvym";
        libraryHaskellDepends = [
          base containers deepseq ghc-prim lattices
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "prefix-expression" = callPackage
+    ({ mkDerivation, base, hspec, regex-pcre-builtin }:
+     mkDerivation {
+       pname = "prefix-expression";
+       version = "1.2.0";
+       sha256 = "0yskcb3jzpdwiaydp2ys3bb9mybba2j67f9cnylwd1iqib13z8rs";
+       libraryHaskellDepends = [ base regex-pcre-builtin ];
+       testHaskellDepends = [ base hspec ];
+       homepage = "https://github.com/VonFry/prefix-expression";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "prefix-units" = callPackage
     ({ mkDerivation, base, Cabal, HUnit, QuickCheck, test-framework
      , test-framework-hunit, test-framework-quickcheck2
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "primitive_0_6_3_0" = callPackage
+    ({ mkDerivation, base, ghc-prim, transformers }:
+     mkDerivation {
+       pname = "primitive";
+       version = "0.6.3.0";
+       sha256 = "0mcmbnj08wd6zfwn7xk6zf5hy5zwbla5v78pw0dpymqg9s0gzpnd";
+       libraryHaskellDepends = [ base ghc-prim transformers ];
+       testHaskellDepends = [ base ghc-prim ];
+       homepage = "https://github.com/haskell/primitive";
+       description = "Primitive memory-related operations";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "primitive-simd" = callPackage
     ({ mkDerivation, base, criterion, deepseq, ghc-prim, primitive
      , random, vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "process_1_6_2_0" = callPackage
+  "process_1_6_3_0" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, filepath
      , unix
      }:
      mkDerivation {
        pname = "process";
-       version = "1.6.2.0";
-       sha256 = "0gsyzwvid2w1z5m0w492sqb8q8c86q9wa7iqjadcdhbv8ag9z6xm";
+       version = "1.6.3.0";
+       sha256 = "0lxkl0gmyy2sn3r9c7dyz8vz1cm6nvygmgrizilliir5bp42m8cc";
        libraryHaskellDepends = [ base deepseq directory filepath unix ];
        testHaskellDepends = [ base bytestring directory ];
        description = "Process libraries";
···
        pname = "quickcheck-special";
        version = "0.1.0.6";
        sha256 = "1dhwgy1jwglp4y3nbysr1i182415aibqlcsrvwxn2c5x162qjwwm";
+       revision = "1";
+       editedCabalFile = "1whwmij115vw0qwkzlkc4z4yhj7iwwqjhf5aaxn5np0gh2gzihb3";
        libraryHaskellDepends = [ base QuickCheck special-values ];
        homepage = "https://github.com/minad/quickcheck-special#readme";
        description = "Edge cases and special values for QuickCheck Arbitrary instances";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "rakuten_0_1_0_5" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, connection, constraints
+     , data-default-class, extensible, hspec, http-api-data, http-client
+     , http-client-tls, http-types, lens, req, servant-server, text
+     , unordered-containers, warp
+     }:
+     mkDerivation {
+       pname = "rakuten";
+       version = "0.1.0.5";
+       sha256 = "1197vkml0pvrdqvh55bvsb52rzqfj6p6vrpihr5ci7flp4h9wkp1";
+       libraryHaskellDepends = [
+         aeson base bytestring connection constraints data-default-class
+         extensible http-api-data http-client http-client-tls http-types
+         lens req text unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base bytestring connection constraints data-default-class
+         extensible hspec http-api-data http-client http-client-tls
+         http-types lens req servant-server text unordered-containers warp
+       ];
+       homepage = "https://github.com/matsubara0507/rakuten#readme";
+       description = "The Rakuten API in Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ralist" = callPackage
     ({ mkDerivation, base, criterion, deepseq, hspec }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "rebase_1_2_2" = callPackage
+  "rebase_1_2_3" = callPackage
     ({ mkDerivation, base, base-prelude, bifunctors, bytestring
      , containers, contravariant, contravariant-extras, deepseq, dlist
      , either, fail, hashable, mtl, profunctors, scientific
···
      }:
      mkDerivation {
        pname = "rebase";
-       version = "1.2.2";
-       sha256 = "11p4wg2xissj4xzw80dww2srj2ylgw3wlnapykizy2fwjl1az9k4";
+       version = "1.2.3";
+       sha256 = "1glnxvgf79qm2iz4xxdn6zygjff42cyakk1nah2wrzkkrr11axqk";
        libraryHaskellDepends = [
          base base-prelude bifunctors bytestring containers contravariant
          contravariant-extras deepseq dlist either fail hashable mtl
···
      }:
      mkDerivation {
        pname = "reqcatcher";
-       version = "0.1.0.0";
-       sha256 = "0lcismi3aj6h2s2snv80w2pdk389zffd0cjrbd2y9285vw401mvm";
+       version = "0.1.0.1";
+       sha256 = "1ywh83ydy48mlix7mglnkhsjj3b13jqs2gs52by6q1g438nb31in";
        libraryHaskellDepends = [ base http-types network text wai warp ];
        testHaskellDepends = [
          base http-client http-types HUnit lens tasty tasty-hunit wai wreq
···
      }:
      mkDerivation {
        pname = "rio";
-       version = "0.0.0.0";
-       sha256 = "168v27a9m98qcychn4rwrb67sfqs4s1brg79q1fqanpjjqslh8id";
+       version = "0.0.1.0";
+       sha256 = "006avzlv6ghwang3dhllxj7absa32sxw2qss2wdf3hxqbij6fy0b";
        libraryHaskellDepends = [
          base bytestring containers deepseq directory exceptions filepath
          hashable microlens mtl text time typed-process unix unliftio
          unordered-containers vector
        ];
+       homepage = "https://github.com/commercialhaskell/rio#readme";
        description = "A standard library for Haskell";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "servant-exceptions_0_1_1" = callPackage
+    ({ mkDerivation, aeson, base, exceptions, http-media, http-types
+     , mtl, servant, servant-server, text, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-exceptions";
+       version = "0.1.1";
+       sha256 = "1qdb6ins7l0ryyrmg9j5pw428rlhkmzpbq5jqawfn01j8vf9yav5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base exceptions http-media http-types mtl servant
+         servant-server text wai
+       ];
+       executableHaskellDepends = [
+         aeson base exceptions http-types servant-server text warp
+       ];
+       homepage = "https://github.com/ch1bo/servant-exceptions#readme";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "servant-foreign" = callPackage
     ({ mkDerivation, base, hspec, http-types, lens, servant, text }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "servant-kotlin_0_1_0_3" = callPackage
+    ({ mkDerivation, aeson, base, containers, directory, formatting
+     , hspec, http-api-data, lens, servant, servant-foreign, shelly
+     , text, time, wl-pprint-text
+     }:
+     mkDerivation {
+       pname = "servant-kotlin";
+       version = "0.1.0.3";
+       sha256 = "1idki7vf2yph8sndpl8r9a5cngix3163yxb73l5l5fm9a78pk5gd";
+       libraryHaskellDepends = [
+         base containers directory formatting lens servant servant-foreign
+         text time wl-pprint-text
+       ];
+       testHaskellDepends = [
+         aeson base containers directory formatting hspec http-api-data lens
+         servant servant-foreign text time wl-pprint-text
+       ];
+       benchmarkHaskellDepends = [
+         aeson base containers directory formatting http-api-data lens
+         servant servant-foreign shelly text time wl-pprint-text
+       ];
+       homepage = "https://github.com/matsubara0507/servant-kotlin#readme";
+       description = "Automatically derive Kotlin class to query servant webservices";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "servant-lucid" = callPackage
     ({ mkDerivation, base, http-media, lucid, servant }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "servant-websockets_1_1_0" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, conduit
+     , exceptions, resourcet, servant-server, text, wai, wai-websockets
+     , warp, websockets
+     }:
+     mkDerivation {
+       pname = "servant-websockets";
+       version = "1.1.0";
+       sha256 = "0l8a5zc6wiwdfxv2kirb7kxky4zwj71rcrrg1zh07gc3vf4lqf33";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async base bytestring conduit exceptions resourcet
+         servant-server text wai wai-websockets warp websockets
+       ];
+       executableHaskellDepends = [
+         aeson base conduit servant-server text wai warp websockets
+       ];
+       homepage = "https://github.com/moesenle/servant-websockets#readme";
+       description = "Small library providing WebSocket endpoints for servant";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "servant-yaml" = callPackage
     ({ mkDerivation, aeson, base, base-compat, bytestring, http-media
      , servant, servant-server, wai, warp, yaml
···
      }:
      mkDerivation {
        pname = "serverless-haskell";
-       version = "0.3.0";
-       sha256 = "0fvm7nsk3401xdh81gb7jc35k5phc1gfs7dd1gal48ryjc89p2sj";
+       version = "0.3.1";
+       sha256 = "1s4b0x6hs0dighmqgpwnifhy7w5cszd207lwwryn2qp1zq463i2h";
        libraryHaskellDepends = [
          aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
          bytestring lens text time unix unordered-containers
···
      }) {};
 
   "shake-ext" = callPackage
-    ({ mkDerivation, base, composition-prelude, language-ats, shake }:
+    ({ mkDerivation, base, composition-prelude, directory, language-ats
+     , mtl, shake, text
+     }:
      mkDerivation {
        pname = "shake-ext";
-       version = "0.3.1.3";
-       sha256 = "0yz8d4jycgr32sspdda1zy4z61bj91xi40dcr084w11z00a3yhms";
+       version = "1.3.0.1";
+       sha256 = "1rsn8rikw775b4cbxskijqcxqz60h70jnq7nzy7k1mc29ycjf9qv";
        libraryHaskellDepends = [
-         base composition-prelude language-ats shake
+         base composition-prelude directory language-ats mtl shake text
        ];
        homepage = "https://hub.darcs.net/vmchale/shake-ext";
        description = "Helper functions for linting with shake";
···
      }:
      mkDerivation {
        pname = "shakers";
-       version = "0.0.38";
-       sha256 = "08wnf9cv4qsrnx2m3l1nfh74q6i14ng2js4h7gj3z5dv1ki3xwm9";
+       version = "0.0.40";
+       sha256 = "0jlihrgg0c2ksbj2dkzsp6c83m66dxdsy3993xpa018idjsm3cf9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          exceptions hspec HUnit lifted-async lifted-base monad-control mtl
          process system-fileio system-filepath text time transformers
          transformers-base unix-compat
+       ];
+       homepage = "https://github.com/yesodweb/Shelly.hs";
+       description = "shell-like (systems) programming in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "shelly_1_7_0_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , enclosed-exceptions, exceptions, filepath, hspec, HUnit
+     , lifted-async, lifted-base, monad-control, mtl, process
+     , system-fileio, system-filepath, text, time, transformers
+     , transformers-base, unix-compat
+     }:
+     mkDerivation {
+       pname = "shelly";
+       version = "1.7.0.1";
+       sha256 = "0a4ngy8jqcscqhimgiyz7f9kqm23is7x7gyjxr0j6iq1dy57ahq3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base bytestring containers directory enclosed-exceptions
+         exceptions lifted-async lifted-base monad-control mtl process
+         system-fileio system-filepath text time transformers
+         transformers-base unix-compat
+       ];
+       testHaskellDepends = [
+         async base bytestring containers directory enclosed-exceptions
+         exceptions filepath hspec HUnit lifted-async lifted-base
+         monad-control mtl process system-fileio system-filepath text time
+         transformers transformers-base unix-compat
        ];
        homepage = "https://github.com/yesodweb/Shelly.hs";
        description = "shell-like (systems) programming in Haskell";
···
      }:
      mkDerivation {
        pname = "smallcaps";
-       version = "0.6.0.4";
-       sha256 = "1lw5zzfpizwrbpm981xr7sx1ac7iwkhwp541g276sszq927ls8n5";
+       version = "0.6.0.5";
+       sha256 = "06cqknha64gmf3rjjmcr3358fd5rii6xlgph5fvan0h25cnlk7nw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "spake2";
-       version = "0.4.1";
-       sha256 = "0b9zs1mp7r8y1w79z1w7kpj84jyryhvy7md9ikihnl80cvnl6p7c";
+       version = "0.4.2";
+       sha256 = "02zvlh7pva2d2k56n3070wdp4chv6avhwzn7mg2zax1mzswd21r4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        testHaskellDepends = [ base QuickCheck ];
        description = "Combinator library for splitting lists";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "split_0_2_3_3" = callPackage
+    ({ mkDerivation, base, QuickCheck }:
+     mkDerivation {
+       pname = "split";
+       version = "0.2.3.3";
+       sha256 = "04qlmkcyklznl03gsjg95b4nzb6i96gdapqg60rny9szgi7ngk8x";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base QuickCheck ];
+       description = "Combinator library for splitting lists";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "split-channel" = callPackage
···
      }:
      mkDerivation {
        pname = "streaming-cassava";
-       version = "0.1.0.0";
-       sha256 = "17swzhq069rr041l33bwa5ybx1j6w9lvh3l3xs40m842njli2bac";
+       version = "0.1.0.1";
+       sha256 = "0dr58azgyw7ihxrabva7fh0yafq2kx12yvap4jl6ljnlwvcapa5i";
        libraryHaskellDepends = [
          base bytestring cassava mtl streaming streaming-bytestring
          transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "stripe-core_2_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, mtl, text, time
+     , transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "stripe-core";
+       version = "2.3.0";
+       sha256 = "08656c3s9326kgppwiys7whil47yw6qibjzmivjzykh6858j0kfm";
+       libraryHaskellDepends = [
+         aeson base bytestring mtl text time transformers
+         unordered-containers
+       ];
+       homepage = "https://github.com/dmjio/stripe-haskell";
+       description = "Stripe API for Haskell - Pure Core";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "stripe-haskell" = callPackage
     ({ mkDerivation, base, stripe-core, stripe-http-streams }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "stripe-haskell_2_3_0" = callPackage
+    ({ mkDerivation, base, stripe-core, stripe-http-streams }:
+     mkDerivation {
+       pname = "stripe-haskell";
+       version = "2.3.0";
+       sha256 = "18358axxx2rkv06bh1n48hsx3bh3bj4h3xx1ma3hvv68l9cprwsm";
+       libraryHaskellDepends = [ base stripe-core stripe-http-streams ];
+       homepage = "https://github.com/dmjio/stripe";
+       description = "Stripe API for Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "stripe-http-streams" = callPackage
     ({ mkDerivation, aeson, base, bytestring, free, HsOpenSSL, hspec
      , http-streams, io-streams, stripe-core, stripe-tests, text
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "stripe-http-streams_2_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, free, HsOpenSSL, hspec
+     , http-streams, io-streams, stripe-core, stripe-tests, text
+     }:
+     mkDerivation {
+       pname = "stripe-http-streams";
+       version = "2.3.0";
+       sha256 = "0nn244ghmyibdrvzfz9k8skhsfh47sh8g34v1c63rkswqb4wpnsp";
+       libraryHaskellDepends = [
+         aeson base bytestring HsOpenSSL http-streams io-streams stripe-core
+         text
+       ];
+       testHaskellDepends = [
+         base free HsOpenSSL hspec http-streams stripe-core stripe-tests
+       ];
+       doCheck = false;
+       description = "Stripe API for Haskell - http-streams backend";
+       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
···
        homepage = "https://github.com/dmjio/stripe-haskell";
        description = "Tests for Stripe API bindings for Haskell";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "stripe-tests_2_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, free, hspec, hspec-core
+     , mtl, random, stripe-core, text, time, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "stripe-tests";
+       version = "2.3.0";
+       sha256 = "14j0zvnrl0s2br0vwpm105wscdyddan62iqwrf0fg8c4mj6kpfrw";
+       libraryHaskellDepends = [
+         aeson base bytestring free hspec hspec-core mtl random stripe-core
+         text time transformers unordered-containers
+       ];
+       homepage = "https://github.com/dmjio/stripe-haskell";
+       description = "Tests for Stripe API bindings for Haskell";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "strips" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "tagsoup_0_14_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , process, QuickCheck, text, time
+     }:
+     mkDerivation {
+       pname = "tagsoup";
+       version = "0.14.3";
+       sha256 = "00j2rm2sx0syn16kg2402fz4k8yqfl9knmi367jsiycds1q9zzf9";
+       libraryHaskellDepends = [ base bytestring containers text ];
+       testHaskellDepends = [
+         base bytestring deepseq directory process QuickCheck time
+       ];
+       homepage = "https://github.com/ndmitchell/tagsoup#readme";
+       description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tagsoup-ht" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-accessor
      , explicit-exception, old-time, tagsoup, transformers, utility-ht
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "tar-conduit_0_2_0" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
+     , containers, criterion, deepseq, directory, filepath, hspec, unix
+     , weigh
+     }:
+     mkDerivation {
+       pname = "tar-conduit";
+       version = "0.2.0";
+       sha256 = "01fqvm5wji1rgivqri0prp3k3drhr3gmmlcwy0v4qcwdhwgi0r2r";
+       libraryHaskellDepends = [
+         base bytestring conduit-combinators directory filepath unix
+       ];
+       testHaskellDepends = [
+         base bytestring conduit conduit-combinators containers deepseq
+         directory filepath hspec weigh
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring conduit conduit-combinators containers criterion
+         deepseq directory filepath hspec
+       ];
+       homepage = "https://github.com/snoyberg/tar-conduit#readme";
+       description = "Extract and create tar files using conduit for streaming";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tardis" = callPackage
     ({ mkDerivation, base, mmorph, mtl }:
      mkDerivation {
···
        pname = "tasty-hspec";
        version = "1.1.3.2";
        sha256 = "0n4pn89jz9i8d7mxsdp6ynwkg5gjyaipdy261parx64m3nxi4vcv";
-       revision = "2";
-       editedCabalFile = "1si8bkb5rqx0hfm2y52676x7d4zr4mpgd82sqp7na57f0w2j8hg2";
+       revision = "3";
+       editedCabalFile = "1qyk0mrzy4nv175xhva1wp7dchx7jnzb5p32bc0vd8pxz19pfljm";
        libraryHaskellDepends = [
          base hspec hspec-core QuickCheck random tagged tasty
          tasty-quickcheck tasty-smallcheck
···
      }) {};
 
   "telegram-api" = callPackage
-    ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring, filepath
-     , hjpath, hspec, http-api-data, http-client, http-client-tls
-     , http-media, http-types, mime-types, mtl, optparse-applicative
-     , random, servant, servant-client, string-conversions, text
-     , transformers, utf8-string
+    ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring
+     , containers, filepath, hjpath, hspec, http-api-data, http-client
+     , http-client-tls, http-media, http-types, mime-types, mtl
+     , optparse-applicative, random, servant, servant-client
+     , servant-client-core, string-conversions, text, transformers
+     , utf8-string
      }:
      mkDerivation {
        pname = "telegram-api";
-       version = "0.7.1.0";
-       sha256 = "0shb5al3ih6qrs2aw1h03mfqk954gml1lnyh6svzcsz9z6f7hvbb";
+       version = "0.7.2.0";
+       sha256 = "1aixgyxz3izv9z3zwwsbvdnlg4lrhy7aa33zw98v70072a0rqaj2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson base bytestring http-api-data http-client http-media
-         http-types mime-types mtl servant servant-client string-conversions
-         text transformers
+         aeson base bytestring containers http-api-data http-client
+         http-media http-types mime-types mtl servant servant-client
+         servant-client-core string-conversions text transformers
        ];
        testHaskellDepends = [
          aeson ansi-wl-pprint base filepath hjpath hspec http-client
          http-client-tls http-types optparse-applicative random servant
-         servant-client text transformers utf8-string
+         servant-client servant-client-core text transformers utf8-string
        ];
        homepage = "http://github.com/klappvisor/haskell-telegram-api#readme";
        description = "Telegram Bot API bindings";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "terminal-progress-bar_0_1_2" = callPackage
+    ({ mkDerivation, async, base, HUnit, stm, stm-chans, terminal-size
+     , test-framework, test-framework-hunit
+     }:
+     mkDerivation {
+       pname = "terminal-progress-bar";
+       version = "0.1.2";
+       sha256 = "1r4i8h4625f4ixnppx3ng5lsay4msdgqy0mzl3p1z57aqxg1l84l";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ async base stm stm-chans terminal-size ];
+       testHaskellDepends = [
+         base HUnit test-framework test-framework-hunit
+       ];
+       homepage = "https://github.com/roelvandijk/terminal-progress-bar";
+       description = "A simple progress bar in the terminal";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "terminal-size" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "terminfo_0_4_1_0" = callPackage
+  "terminfo_0_4_1_1" = callPackage
     ({ mkDerivation, base, ncurses }:
      mkDerivation {
        pname = "terminfo";
-       version = "0.4.1.0";
-       sha256 = "0pgzx7byi4p2fwk6hcqnbs59bv4igzmhfkr5wrkkfsh4msqxflrz";
+       version = "0.4.1.1";
+       sha256 = "1pfd2vdk298v23af2zqcl66xxivrzwjjpdf3dr0fa0isl70fi3hp";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ ncurses ];
        homepage = "https://github.com/judah/terminfo";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "time_1_8_0_4" = callPackage
+  "time_1_9" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck, random, tasty
      , tasty-hunit, tasty-quickcheck, unix
      }:
      mkDerivation {
        pname = "time";
-       version = "1.8.0.4";
-       sha256 = "18m58vj490pk6vxfpda5r2rc1vkv0gy5sqgp5nhql0562m5xi8mk";
+       version = "1.9";
+       sha256 = "13nfiwsh1bq4w9rwmqm1iy9kxwrqbi82qpqlpcd02ywklh21silx";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq QuickCheck random tasty tasty-hunit tasty-quickcheck
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "type-combinators-singletons_0_2_0_0" = callPackage
+  "type-combinators-singletons_0_2_1_0" = callPackage
     ({ mkDerivation, base, singletons, type-combinators }:
      mkDerivation {
        pname = "type-combinators-singletons";
-       version = "0.2.0.0";
-       sha256 = "0mqg2c36z22zdjgmix54xfj9d218ypwjgvhvhxlhzw5x0ka506s5";
+       version = "0.2.1.0";
+       sha256 = "00cwlfcka2d1wcp7159r3sk3gz852dmc71jvjfr8bn1rrr781n0q";
        libraryHaskellDepends = [ base singletons type-combinators ];
        homepage = "https://github.com/mstksg/type-combinators-singletons";
        description = "Interop between /type-combinators/ and /singletons/";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "typelits-witnesses_0_3_0_0" = callPackage
+  "typelits-witnesses_0_3_0_1" = callPackage
     ({ mkDerivation, base, base-compat, constraints, reflection
      , transformers
      }:
      mkDerivation {
        pname = "typelits-witnesses";
-       version = "0.3.0.0";
-       sha256 = "1rjc2wxm6cmvf03m3w3r19a9kya5ksk27zy00dmm3zqhq58ccb4v";
+       version = "0.3.0.1";
+       sha256 = "0d2537dwz5kiq81amrj2v00bvlwjfkidlz45g1h96zv78mlw1l7c";
        libraryHaskellDepends = [
          base base-compat constraints reflection transformers
        ];
···
      }) {};
 
   "unconstrained" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation }:
      mkDerivation {
        pname = "unconstrained";
-       version = "0.1.0.1";
-       sha256 = "0wzkf8fqlqd11rcb7cvb7zsyg1ws5wyplgmsll6xbfbh68adh32p";
-       libraryHaskellDepends = [ base ];
+       version = "0.1.0.2";
+       sha256 = "03811shhcfkcrsai3a1vw99g0pmg8m3cfi8gfiaf8b13l1k7lwfj";
        description = "Null constraint";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "vector-space_0_13" = callPackage
+    ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:
+     mkDerivation {
+       pname = "vector-space";
+       version = "0.13";
+       sha256 = "05yn93vnhzhpp2i6qb4b3dasvmpk71rab6vhssqvpb3qhdvxb482";
+       libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];
+       description = "Vector & affine spaces, linear maps, and derivatives";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "vector-space-map" = callPackage
     ({ mkDerivation, base, containers, doctest, vector-space }:
      mkDerivation {
···
        homepage = "https://github.com/maoe/viewprof";
        description = "Text-based interactive GHC .prof viewer";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "viewprof_0_0_0_13" = callPackage
+    ({ mkDerivation, base, brick, containers, directory, ghc-prof, lens
+     , scientific, text, vector, vector-algorithms, vty
+     }:
+     mkDerivation {
+       pname = "viewprof";
+       version = "0.0.0.13";
+       sha256 = "1ichcff012k1f9cqk01sixv3yx52krnhjfnw73yw06kacpd7i74z";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base brick containers directory ghc-prof lens scientific text
+         vector vector-algorithms vty
+       ];
+       homepage = "https://github.com/maoe/viewprof";
+       description = "Text-based interactive GHC .prof viewer";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "views" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "weeder_0_1_13" = callPackage
+  "weeder_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq
      , directory, extra, filepath, foundation, hashable, process, text
      , unordered-containers, vector, yaml
      }:
      mkDerivation {
        pname = "weeder";
-       version = "0.1.13";
-       sha256 = "0a0zfp1g5mh393v4d1js5a0fnkj03q5kzycsyp3x4nk37dnc67fy";
+       version = "1.0";
+       sha256 = "1s6xfzv49pism1z4qpid3745w8x06nddifzb9165j2h6n7fivgav";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, base, magic, mtl, random, unix, xmonad }:
      mkDerivation {
        pname = "xmonad-wallpaper";
-       version = "0.0.1.3";
-       sha256 = "0vw1pcfpsxcaqnq9s5p7my3jr6q38ndm7qd5x7m06wmakcalcbyy";
+       version = "0.0.1.4";
+       sha256 = "0f6214kqp86xnk1zginjiprnqlj2fzcvh3w5sv3yvqg98mwdd0cg";
        libraryHaskellDepends = [ base magic mtl random unix xmonad ];
        description = "xmonad wallpaper extension";
        license = stdenv.lib.licenses.lgpl3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-core_1_4_37_3" = callPackage
+    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
+     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
+     , cereal, clientsession, conduit, conduit-extra, containers, cookie
+     , criterion, data-default, deepseq, deepseq-generics, directory
+     , exceptions, fast-logger, hspec, hspec-expectations, http-types
+     , HUnit, lifted-base, monad-control, monad-logger, mtl, mwc-random
+     , network, old-locale, parsec, path-pieces, primitive, QuickCheck
+     , random, resourcet, safe, semigroups, shakespeare
+     , streaming-commons, template-haskell, text, time, transformers
+     , transformers-base, unix-compat, unordered-containers, vector, wai
+     , wai-extra, wai-logger, warp, word8
+     }:
+     mkDerivation {
+       pname = "yesod-core";
+       version = "1.4.37.3";
+       sha256 = "1jw1302p5s9jy7xghxzg9j63pn6b1hp957n1808qyk1iz7yrfsg0";
+       libraryHaskellDepends = [
+         aeson auto-update base blaze-builder blaze-html blaze-markup
+         byteable bytestring case-insensitive cereal clientsession conduit
+         conduit-extra containers cookie data-default deepseq
+         deepseq-generics directory exceptions fast-logger http-types
+         lifted-base monad-control monad-logger mtl mwc-random old-locale
+         parsec path-pieces primitive random resourcet safe semigroups
+         shakespeare template-haskell text time transformers
+         transformers-base unix-compat unordered-containers vector wai
+         wai-extra wai-logger warp word8
+       ];
+       testHaskellDepends = [
+         async base blaze-builder bytestring clientsession conduit
+         conduit-extra containers cookie hspec hspec-expectations http-types
+         HUnit lifted-base mwc-random network path-pieces QuickCheck random
+         resourcet shakespeare streaming-commons template-haskell text
+         transformers wai wai-extra
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-html bytestring criterion shakespeare text transformers
+       ];
+       homepage = "http://www.yesodweb.com/";
+       description = "Creation of type-safe, RESTful web applications";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-crud" = callPackage
     ({ mkDerivation, base, classy-prelude, containers, MissingH
      , monad-control, persistent, random, safe, stm, uuid, yesod-core
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) zip;};
 
-  "zip-archive_0_3_2" = callPackage
+  "zip-archive_0_3_2_2" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
      , digest, directory, filepath, HUnit, mtl, old-time, pretty
      , process, temporary, text, time, unix, zip, zlib
      }:
      mkDerivation {
        pname = "zip-archive";
-       version = "0.3.2";
-       sha256 = "1k413av98vchpsqd3930w4sznih4jip98vbgyif86nbpji7mp44f";
+       version = "0.3.2.2";
+       sha256 = "1xyabamc3670r8qjwpyfxcbsxhsnzy6i9n5zx58maq830lwp2m9c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        executableHaskellDepends = [ base bytestring directory ];
        testHaskellDepends = [
-         base bytestring directory HUnit old-time process temporary time
-         unix
+         base bytestring directory filepath HUnit old-time process temporary
+         time unix
        ];
        testToolDepends = [ zip ];
        homepage = "http://github.com/jgm/zip-archive";
···
        ];
        description = "Multi-file, colored, filtered log tailer";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "zuramaru" = callPackage
+    ({ mkDerivation, base, cmdargs, containers, distributive, doctest
+     , either, extensible, extra, lens, megaparsec, mono-traversable
+     , mtl, profunctors, readline, safe, safe-exceptions, silently
+     , singletons, string-qq, tasty, tasty-discover, tasty-hunit
+     , template-haskell, text, text-show, throwable-exceptions
+     , transformers
+     }:
+     mkDerivation {
+       pname = "zuramaru";
+       version = "0.1.0.0";
+       sha256 = "0g8kkwyjmsj5wqsqn6yxg9qr79ljfskc5qy4wg0xvlb8781xbj8m";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base cmdargs containers distributive either extensible extra lens
+         megaparsec mono-traversable mtl profunctors readline safe
+         safe-exceptions singletons string-qq template-haskell text
+         text-show throwable-exceptions transformers
+       ];
+       executableHaskellDepends = [
+         base cmdargs containers distributive either extensible extra lens
+         megaparsec mono-traversable mtl profunctors readline safe
+         safe-exceptions singletons string-qq template-haskell text
+         text-show throwable-exceptions transformers
+       ];
+       testHaskellDepends = [
+         base cmdargs containers distributive doctest either extensible
+         extra lens megaparsec mono-traversable mtl profunctors readline
+         safe safe-exceptions silently singletons string-qq tasty
+         tasty-discover tasty-hunit template-haskell text text-show
+         throwable-exceptions transformers
+       ];
+       homepage = "https://github.com/aiya000/hs-zuramaru";
+       description = "A lisp processor, An inline-lisp, in Haskell";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "zxcvbn-c" = callPackage