Merge branch 'master' into staging-next

Larger rebuild, probably mainly haskell.
Hydra nixpkgs: ?compare=1503325

maintainers/maintainer-list.nix

···
     github = "abbradar";
     name = "Nikolay Amiantov";
   };
+  abhi18av = {
+    email = "[e-mail]";
+    github = "abhi18av";
+    name = "Abhinav Sharma";
+  };
   abigailbuccaneer = {
     email = "[e-mail]";
     github = "abigailbuccaneer";
···
     name = "Thomas Tuegel";
   };
   tv = {
-    email = "[e-mail]";
+    email = "[e-mail]";
     github = "4z3";
     name = "Tomislav Viljetić";
   };

nixos/modules/tasks/auto-upgrade.nix

···
           HOME = "/root";
         } // config.networking.proxy.envVars;
 
-      path = [ pkgs.gnutar pkgs.xz.bin config.nix.package.out ];
+      path = [ pkgs.gnutar pkgs.xz.bin pkgs.gitMinimal config.nix.package.out ];
 
       script = ''
         ${config.system.build.nixos-rebuild}/bin/nixos-rebuild switch ${toString cfg.flags}

nixos/tests/all-tests.nix

···
   nat.firewall = handleTest ./nat.nix { withFirewall = true; };
   nat.firewall-conntrack = handleTest ./nat.nix { withFirewall = true; withConntrackHelpers = true; };
   nat.standalone = handleTest ./nat.nix { withFirewall = false; };
+  neo4j = handleTest ./neo4j.nix {};
   netdata = handleTest ./netdata.nix {};
   networking.networkd = handleTest ./networking.nix { networkd = true; };
   networking.scripted = handleTest ./networking.nix { networkd = false; };

nixos/tests/neo4j.nix

···
+import ./make-test.nix {
+  name = "neo4j";
+
+  nodes = {
+    master =
+      { ... }:
+
+      {
+        services.neo4j.enable = true;
+      };
+  };
+
+  testScript = ''
+    startAll;
+
+    $master->waitForUnit("neo4j");
+    $master->sleep(20); # Hopefully this is long enough!!
+    $master->succeed("curl http://localhost:7474/");
+  '';
+}

pkgs/applications/editors/android-studio/default.nix

···
     sha256Hash = "0dracganibnkyapn2pk2qqnxpwmii57371ycri4nccaci9v9pcjw";
   };
   betaVersion = {
-    version = "3.4.0.11"; # "Android Studio 3.4 Beta 2"
-    build = "183.5240537";
-    sha256Hash = "0mv7ayqjkw97jzdifw1cdvjhnzygzkd2a9rc0h99fclhf2nii5yr";
+    version = "3.4.0.12"; # "Android Studio 3.4 Beta 3"
+    build = "183.5256591";
+    sha256Hash = "1yab2sgabgk3wa3wrzv9z1dc2k7x0079v0mlwrp32jwx8r9byvcw";
   };
   latestVersion = { # canary & dev
-    version = "3.5.0.1"; # "Android Studio 3.5 Canary 2"
-    build = "183.5240547";
-    sha256Hash = "0z52ig9v2w9i6bqiqpdvgcr6g6sgl8p5317jamg72d5csm9hgfx3";
+    version = "3.5.0.2"; # "Android Studio 3.5 Canary 3"
+    build = "183.5256920";
+    sha256Hash = "09bd80ld21hq743xjacsq0nkxwl5xzr253p86n71n580yn4rgmlb";
   };
 in rec {
   # Old alias (TODO @primeos: Remove after 19.03 is branched off):

pkgs/applications/misc/calibre/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "3.38.1";
+  version = "3.39.1";
   name = "calibre-${version}";
 
   src = fetchurl {
     url = "https://download.calibre-ebook.com/${version}/${name}.tar.xz";
-    sha256 = "07fvpnabk17sfg81xn0bsnw36k45hawwz0fcz5cmp5qydm85ncv0";
+    sha256 = "08c1wsdn0giv9zfb6bis9bbrw687rci8fs26qsal8ijmjk55dfsh";
   };
 
   patches = [

pkgs/applications/misc/cool-retro-term/default.nix

···
 , qtquickcontrols, qtgraphicaleffects, qmake }:
 
 stdenv.mkDerivation rec {
-  version = "1.1.0";
+  version = "1.1.1";
   name = "cool-retro-term-${version}";
 
   src = fetchFromGitHub {
     owner = "Swordfish90";
     repo = "cool-retro-term";
     rev = version;
-    sha256 = "0gmigjpc19q7l94q4wzbrxh7cdb6zk3zscaijzwsz9364wsgzb47";
+    sha256 = "0mird4k88ml6y61hky2jynrjmnxl849fvhsr5jfdlnv0i7r5vwi5";
   };
 
   patchPhase = ''

pkgs/applications/networking/cluster/kube-router/default.nix

···
 
 buildGoPackage rec {
   name = "kube-router-${version}";
-  version = "0.2.3";
+  version = "0.2.5";
   rev = "v${version}";
 
   goPackagePath = "github.com/cloudnativelabs/kube-router";
···
     inherit rev;
     owner = "cloudnativelabs";
     repo = "kube-router";
-    sha256 = "1dsr76dq6sycwgh75glrcb4scv52lrrd0aivskhc7mwq30plafcj";
+    sha256 = "1j6q6kg4qj75v2mdy9ivvwq8mx9fpdf0w08959l8imrp5byd56wv";
   };
 
   buildFlagsArray = ''

pkgs/applications/networking/gns3/default.nix

···
 
 let
   stableVersion = "2.1.12";
-  # Currently there is no preview version.
-  previewVersion = stableVersion;
+  previewVersion = "2.2.0a1";
   addVersion = args:
     let version = if args.stable then stableVersion else previewVersion;
         branch = if args.stable then "stable" else "preview";
···
   };
   guiPreview = mkGui {
     stable = false;
-    sha256Hash = guiSrcHash;
+    sha256Hash = "16jjgfbdi7b3349wrqalf40qcaqzw3d4vdjbwcy8dbqblg48hn5w";
   };
 
   serverStable = mkServer {
···
   };
   serverPreview = mkServer {
     stable = false;
-    sha256Hash = serverSrcHash;
+    sha256Hash = "0bcsjljy947grfn3y9xyi3dbzdw5wkljq1nr66cqfkidx9f4fzni";
   };
 }

pkgs/applications/networking/gns3/gui.nix

···
     raven psutil jsonschema # tox for check
     # Runtime dependencies
     sip (pyqt5.override { withWebSockets = true; })
-  ];
+  ] ++ stdenv.lib.optional (!stable) pythonPackages.distro;
 
   doCheck = false; # Failing
 

pkgs/applications/networking/gns3/server.nix

···
 { stdenv, python36, fetchFromGitHub }:
 
 let
-  python = python36.override {
+  python = if stable then python36.override {
     packageOverrides = self: super: {
       async-timeout = super.async-timeout.overridePythonAttrs (oldAttrs: rec {
         version = "2.0.1";
···
           ++ stdenv.lib.optional (pythonOlder "3.5") typing;
       });
     };
-  };
+  } else python36;
 
 in python.pkgs.buildPythonPackage {
   pname = "gns3-server";
···
     aiohttp-cors yarl aiohttp multidict
     jinja2 psutil zipstream raven jsonschema typing
     (python.pkgs.callPackage ../../../development/python-modules/prompt_toolkit/1.nix {})
-  ];
+  ] ++ stdenv.lib.optional (!stable) python.pkgs.distro;
 
   # Requires network access
   doCheck = false;

pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix

···
   mkTelegram = args: qt5.callPackage (import ./generic.nix args) { };
   stableVersion = {
     stable = true;
-    version = "1.5.8";
-    sha256Hash = "0sl4p4a7fyh68g01rddiy719lyr321cjar78b3c732zxfj8lxvkb";
+    version = "1.5.11";
+    sha256Hash = "09blyzs6mrmrrmjcfia9pa35mfv4zfc9mrqc36hqqcchmg54kx6w";
     # svn log svn://svn.archlinux.org/community/telegram-desktop/trunk
-    archPatchesRevision = "415526";
-    archPatchesHash = "1lfzws90ab0vajhm5r64gyyqqc1g6a2ay0a1vkp0ah1iw5jh11ik";
+    archPatchesRevision = "429149";
+    archPatchesHash = "1ylpi9kb6hk27x9wmna4ing8vzn9b7247iya91pyxxrpxrcrhpli";
   };
 in {
   stable = mkTelegram stableVersion;

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···
 let
   inherit (stdenv.lib) concatStringsSep makeBinPath optional;
 
-  version = "2.6.149990.1216";
+  version = "2.7.162522.0121";
   srcs = {
     x86_64-linux = fetchurl {
       url = "https://zoom.us/client/${version}/zoom_x86_64.tar.xz";
-      sha256 = "0bs5kx2601lwwr9lgdd3hlbrrwsf0dai766zrca907dl400pmzyd";
+      sha256 = "01i4g4kmawk3mclifh4bwcqpdnbvrz0sz49b6l33n0k5ysky20r1";
     };
   };
 
···
       files = concatStringsSep " " [
         "*.pcm"
         "*.png"
-        "ZXMPPROOT.cer"
         "ZoomLauncher"
         "config-dump.sh"
         "timezones"

pkgs/applications/networking/mailreaders/notmuch/default.nix

···
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  version = "0.28";
+  version = "0.28.1";
   name = "notmuch-${version}";
 
   passthru = {
···
 
   src = fetchurl {
     url = "https://notmuchmail.org/releases/${name}.tar.gz";
-    sha256 = "0dqarmjc8544m2w7bqrqmvsfy55fw82707z3lz9cql8nr777bjmc";
+    sha256 = "0mcsfkrp6mpy374m5rwwgm9md8qzvwa3s4rbzid4cnkx2cwfj4fi";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/compilers/ghcjs-ng/8.2/git.json

···
-{
-  "url": "https://github.com/ghcjs/ghcjs",
-  "rev": "0cff73c3ee13b464adba90f308b77751c75b9f26",
-  "sha256": "1shg34zi6ryaihar62qdkkalv8dsrsqbv58jzkhk9in38sdfkjxv",
-  "fetchSubmodules": true
-}

pkgs/development/compilers/ghcjs-ng/8.2/stage0.nix pkgs/development/compilers/ghcjs-ng/8.6/stage0.nix

···
     }:
     mkDerivation {
       pname = "ghcjs";
-      version = "8.2.0.1";
+      version = "8.6.0.1";
       src = configuredSrc + /.;
       isLibrary = true;
       isExecutable = true;
···
 
   ghc-api-ghcjs = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
-    , deepseq, directory, filepath, ghc-boot, ghc-boot-th, ghci-ghcjs
-    , hoopl, hpc, process, stdenv, template-haskell-ghcjs, terminfo
-    , time, transformers, unix
+    , deepseq, directory, filepath, ghc-boot, ghc-boot-th, ghc-heap
+    , ghci-ghcjs, hpc, process, stdenv, template-haskell-ghcjs
+    , terminfo, time, transformers, unix
     }:
     mkDerivation {
       pname = "ghc-api-ghcjs";
-      version = "8.2.2";
+      version = "8.6.2";
       src = configuredSrc + /lib/ghc-api-ghcjs;
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
-        ghc-boot ghc-boot-th ghci-ghcjs hoopl hpc process
+        ghc-boot ghc-boot-th ghc-heap ghci-ghcjs hpc process
         template-haskell-ghcjs terminfo time transformers unix
       ];
       homepage = "http://www.haskell.org/ghc/";
···
 
   ghci-ghcjs = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
-    , deepseq, filepath, ghc-boot, ghc-boot-th, stdenv
+    , deepseq, filepath, ghc-boot, ghc-boot-th, ghc-heap, stdenv
     , template-haskell-ghcjs, transformers, unix
     }:
     mkDerivation {
       pname = "ghci-ghcjs";
-      version = "8.2.2";
+      version = "8.6.1";
       src = configuredSrc + /lib/ghci-ghcjs;
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq filepath ghc-boot
-        ghc-boot-th template-haskell-ghcjs transformers unix
+        ghc-boot-th ghc-heap template-haskell-ghcjs transformers unix
       ];
       description = "The library supporting GHC's interactive interpreter (customized for GHCJS)";
       license = stdenv.lib.licenses.bsd3;
···
     }:
     mkDerivation {
       pname = "haddock-api-ghcjs";
-      version = "2.18.1";
+      version = "2.20.0";
       src = configuredSrc + /lib/haddock-api-ghcjs;
       enableSeparateDataOutput = true;
       libraryHaskellDepends = [
···
         xhtml
       ];
       testHaskellDepends = [
-        base containers ghc-api-ghcjs hspec QuickCheck
+        array base bytestring Cabal containers deepseq directory filepath
+        ghc-api-ghcjs ghc-boot ghc-paths haddock-library-ghcjs hspec
+        QuickCheck transformers xhtml
       ];
       testToolDepends = [ hspec-discover ];
       homepage = "http://www.haskell.org/haddock/";
-      description = "A documentation-generation tool for Haskell libraries (customized for GHCJS)";
+      description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};
 
   haddock-library-ghcjs = callPackage
-    ({ mkDerivation, base, base-compat, bytestring, deepseq, hspec
-    , hspec-discover, QuickCheck, stdenv, transformers
+    ({ mkDerivation, base, base-compat, bytestring, containers, deepseq
+    , directory, filepath, haddock-library, hspec, hspec-discover
+    , optparse-applicative, parsec, QuickCheck, stdenv, text
+    , transformers, tree-diff
     }:
     mkDerivation {
       pname = "haddock-library-ghcjs";
-      version = "1.4.4";
+      version = "1.6.0";
       src = configuredSrc + /lib/haddock-library-ghcjs;
-      libraryHaskellDepends = [ base bytestring deepseq transformers ];
+      libraryHaskellDepends = [
+        base bytestring containers parsec text transformers
+      ];
       testHaskellDepends = [
-        base base-compat bytestring deepseq hspec QuickCheck transformers
+        base base-compat bytestring containers deepseq directory filepath
+        haddock-library hspec optparse-applicative parsec QuickCheck text
+        transformers tree-diff
       ];
       testToolDepends = [ hspec-discover ];
       homepage = "http://www.haskell.org/haddock/";
···
     ({ mkDerivation, base, ghc-boot-th, pretty, stdenv }:
     mkDerivation {
       pname = "template-haskell-ghcjs";
-      version = "2.12.0.0";
+      version = "2.14.0.0";
       src = configuredSrc + /lib/template-haskell-ghcjs;
       libraryHaskellDepends = [ base ghc-boot-th pretty ];
       description = "Support library for Template Haskell (customized for GHCJS)";

pkgs/development/compilers/ghcjs-ng/8.4/dep-overrides.nix

···
 
 let inherit (haskellLib) dontCheck doJailbreak;
 in self: super: {
-  haddock-library-ghcjs = dontCheck super.haddock-library-ghcjs;
+  haddock-library-ghcjs = doJailbreak (dontCheck super.haddock-library-ghcjs);
   haddock-api-ghcjs = doJailbreak super.haddock-api-ghcjs;
+
+  template-haskell-ghcjs = doJailbreak super.template-haskell-ghcjs;
 }

pkgs/development/compilers/ghcjs-ng/8.6/dep-overrides.nix

···
+{ haskellLib }:
+
+let inherit (haskellLib) dontCheck doJailbreak dontHaddock;
+in self: super: {
+  haddock-library-ghcjs = doJailbreak super.haddock-library-ghcjs;
+  haddock-api-ghcjs = doJailbreak (dontHaddock super.haddock-api-ghcjs);
+}

pkgs/development/compilers/ghcjs-ng/8.6/git.json

···
+{
+  "url": "https://github.com/ghcjs/ghcjs",
+  "rev": "75c61af32d73def4409d1fe7b64659c1d28cd075",
+  "sha256": "18pixn6xdz6qp941yhxfnmwi463jnpskmg473lv07vvgy4hpgjhj",
+  "fetchSubmodules": true
+}

pkgs/development/compilers/ghcjs-ng/configured-ghcjs-src.nix

···
   # TODO: How to actually fix this?
   # Seems to work fine and produce the right files.
   touch ghc/includes/ghcautoconf.h
+  mkdir -p ghc/compiler/vectorise
+  mkdir -p ghc/utils/haddock/haddock-library/vendor
 
   patchShebangs .
   ./utils/makePackages.sh copy

pkgs/development/compilers/ghcjs-ng/default.nix

···
     inherit passthru;
 
     meta.platforms = passthru.bootPkgs.ghc.meta.platforms;
-    meta.hydraPlatforms = [];
-    meta.broken = true;  # does not compile: https://hydra.nixos.org/build/88052615
-
+    meta.maintainers = [lib.maintainers.elvishjerricco];
   }

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "0vww2qf94a6dg46mynkgpk0lh3x12vvfby3flqymi4wfrx1fif1k";
+      sha256 = "06385r9rlncrrmzdfl8q600bw6plbvkmkwgl3llg595xrm711a97";
     };
   }).override {
     dbus = if pkgs.stdenv.isLinux then self.dbus else null;
···
   # aarch64 and armv7l fixes.
   happy = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.happy else super.happy; # Similar to https://ghc.haskell.org/trac/ghc/ticket/13062
   hashable = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.hashable else super.hashable; # https://github.com/tibbe/hashable/issues/95
-  servant-docs = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.servant-docs else super.servant-docs;
+  servant-docs =
+    let
+      f = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64)
+          then dontCheck
+          else pkgs.lib.id;
+    in doJailbreak (f super.servant-docs); # jailbreak tasty < 1.2 until servant-docs > 0.11.3 is on hackage.
   swagger2 = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontHaddock (dontCheck super.swagger2) else super.swagger2;
 
   # requires a release including https://github.com/haskell-servant/servant-swagger/commit/249530d9f85fe76dfb18b100542f75a27e6a3079
···
   hlint = super.hlint.overrideScope (self: super: { haskell-src-exts = self.haskell-src-exts_1_21_0; });
   hoogle = super.hoogle.overrideScope (self: super: { haskell-src-exts = self.haskell-src-exts_1_21_0; });
 
+  # Jailbreak tasty < 1.2: https://github.com/phadej/tdigest/issues/30
+  tdigest = doJailbreak super.tdigest; # until tdigest > 0.2.1
+
+  # These patches contain fixes for 8.6 that should be safe for
+  # earlier versions, but we need the relaxed version bounds in GHC
+  # 8.4 builds. beam needs to release a round of updates that relax
+  # bounds and include the 8.6 fixes:
+  # https://github.com/tathougies/beam/issues/315
+  beam-core = appendPatch super.beam-core ./patches/beam-core-fix-ghc-8.6.x-build.patch;
+  beam-migrate = appendPatch super.beam-migrate ./patches/beam-migrate-fix-ghc-8.6.x-build.patch;
+  beam-postgres = appendPatch super.beam-postgres ./patches/beam-postgres-fix-ghc-8.6.x-build.patch;
+  beam-sqlite = appendPatch super.beam-sqlite ./patches/beam-sqlite-fix-ghc-8.6.x-build.patch;
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
     haddock-library = dontHaddock (dontCheck self.haddock-library_1_5_0_1);
   }));
 
+  # cabal2nix doesn't list this because of a conditional on the GHC version.
+  aeson = addBuildDepend super.aeson self.contravariant;
+
 }

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

···
   integer-gmp = null;
   libiserv = null;
   mtl = null;
-  parallel = null;
   parsec = null;
   pretty = null;
   process = null;

pkgs/development/haskell-modules/generic-builder.nix

···
     runHook postHaddock
   '';
 
+  # The scary sed expression handles two cases in v2.5 Cabal's package configs:
+  # 1. 'id:    short-name-0.0.1-9yvw8HF06tiAXuxm5U8KjO'
+  # 2. 'id:\n
+  #         very-long-descriptive-useful-name-0.0.1-9yvw8HF06tiAXuxm5U8KjO'
   installPhase = ''
     runHook preInstall
 
···
         rmdir "$packageConfFile"
       fi
       for packageConfFile in "$packageConfDir/"*; do
-        local pkgId=$( ${gnused}/bin/sed -n -e 's|^id:[ ]\+||p' $packageConfFile )
+        local pkgId=$( ${gnused}/bin/sed -n -e ':a' -e '/^id:$/N; s/id:\n[ ]*\([^\n]*\).*$/\1/p; s/id:[ ]*\([^\n]*\)$/\1/p; ta' $packageConfFile )
         mv $packageConfFile $packageConfDir/$pkgId.conf
       done
 

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

···
      }:
      mkDerivation {
        pname = "Unique";
-       version = "0.4.7.5";
-       sha256 = "0wd4rwbn765n2jyzwwwcghqh1qx69wb9ci7wmvw1ahzg0wbadbqz";
+       version = "0.4.7.6";
+       sha256 = "19388lmnld4z1vgnj9cfwhm51xn0m0rwsq76w5752sy9nzcpck91";
        libraryHaskellDepends = [
          base containers extra hashable unordered-containers
        ];
···
      }) {};
 
   "aeson-value-parser" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, mtl, scientific, text
-     , transformers, unordered-containers, vector
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, mtl
+     , scientific, text, transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "aeson-value-parser";
-       version = "0.14.3";
-       sha256 = "1ikj4kdd9qs50a5zqfhmw0f6k6b8pi9w78nk6r1vpm352xs3vsi1";
+       version = "0.16";
+       sha256 = "07l08rbx7xdp0jnr672skmisaa5wikpn6h43m6i9l7l7x1937b38";
        libraryHaskellDepends = [
-         aeson base bytestring mtl scientific text transformers
+         aeson attoparsec base bytestring mtl scientific text transformers
          unordered-containers vector
        ];
-       description = "An API for parsing \"aeson\" JSON tree into Haskell types";
+       description = "API for parsing \"aeson\" JSON tree into Haskell types";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "antiope-athena_6_3_0" = callPackage
+    ({ mkDerivation, amazonka, amazonka-athena, amazonka-core, base
+     , lens, resourcet, text, unliftio-core
+     }:
+     mkDerivation {
+       pname = "antiope-athena";
+       version = "6.3.0";
+       sha256 = "0yzvzhwl92k1v50w1jzlz2zq5rp7n6x1j51fpqrqq97vj7vqzfsq";
+       libraryHaskellDepends = [
+         amazonka amazonka-athena amazonka-core base lens resourcet text
+         unliftio-core
+       ];
+       testHaskellDepends = [
+         amazonka amazonka-athena amazonka-core base lens resourcet text
+         unliftio-core
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "antiope-contract" = callPackage
     ({ mkDerivation, aeson, antiope-s3, avro, base, bytestring, text }:
      mkDerivation {
        pname = "antiope-contract";
-       version = "6.2.0";
-       sha256 = "0s2s0vq6n7zwjj1yd7kmpwxkvbnfd2ikjv9nzg1rz0hm6mz1dn4p";
+       version = "6.3.0";
+       sha256 = "1d9z3vm7ab6fn0b1v0795v36x36j7lczjgkn2krx7zxq7srzf77l";
        libraryHaskellDepends = [
          aeson antiope-s3 avro base bytestring text
        ];
···
        pname = "antiope-core";
        version = "6.2.0";
        sha256 = "0g3bhh8vdnkd5h9savhjc053jbb4k7b7chbzcjjqd4kj95v8jmr3";
+       libraryHaskellDepends = [
+         amazonka amazonka-core base bytestring exceptions generic-lens
+         http-client http-types lens monad-logger mtl resourcet text
+         transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         amazonka amazonka-core base bytestring exceptions generic-lens
+         http-client http-types lens monad-logger mtl resourcet text
+         transformers unliftio-core
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "antiope-core_6_3_0" = callPackage
+    ({ mkDerivation, amazonka, amazonka-core, base, bytestring
+     , exceptions, generic-lens, http-client, http-types, lens
+     , monad-logger, mtl, resourcet, text, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "antiope-core";
+       version = "6.3.0";
+       sha256 = "001qkmiild396pg9hnw776djygjm692k1w9bmckn6l9ahiz8yah0";
        libraryHaskellDepends = [
          amazonka amazonka-core base bytestring exceptions generic-lens
          http-client http-types lens monad-logger mtl resourcet text
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "antiope-dynamodb_6_3_0" = callPackage
+    ({ mkDerivation, amazonka, amazonka-core, amazonka-dynamodb
+     , antiope-core, base, generic-lens, lens, text, unliftio-core
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "antiope-dynamodb";
+       version = "6.3.0";
+       sha256 = "0912726sm6g2ssrzni3ldiavb506wa51ib07n4gm8vapzhnwxxlb";
+       libraryHaskellDepends = [
+         amazonka amazonka-core amazonka-dynamodb antiope-core base
+         generic-lens lens text unliftio-core unordered-containers
+       ];
+       testHaskellDepends = [
+         amazonka amazonka-core amazonka-dynamodb antiope-core base
+         generic-lens lens text unliftio-core unordered-containers
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "antiope-messages" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3
      , amazonka-sqs, antiope-s3, base, generic-lens, lens, lens-aeson
···
        pname = "antiope-messages";
        version = "6.2.0";
        sha256 = "11zkyfv06fsqxznr36hh563yz401y3wg2a5hc6x6ydza4xdnrzdz";
+       libraryHaskellDepends = [
+         aeson amazonka amazonka-core amazonka-s3 amazonka-sqs antiope-s3
+         base generic-lens lens lens-aeson monad-loops network-uri text
+         unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson amazonka amazonka-core amazonka-s3 amazonka-sqs antiope-s3
+         base generic-lens lens lens-aeson monad-loops network-uri text
+         unliftio-core
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "antiope-messages_6_3_0" = callPackage
+    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3
+     , amazonka-sqs, antiope-s3, base, generic-lens, lens, lens-aeson
+     , monad-loops, network-uri, text, unliftio-core
+     }:
+     mkDerivation {
+       pname = "antiope-messages";
+       version = "6.3.0";
+       sha256 = "0yg38mayxzm7awgn0jczyh3vkyvhm3nmi47vry7knws916xrpr4x";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-s3 amazonka-sqs antiope-s3
          base generic-lens lens lens-aeson monad-loops network-uri text
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "antiope-s3_6_3_0" = callPackage
+    ({ mkDerivation, amazonka, amazonka-core, amazonka-s3, antiope-core
+     , attoparsec, base, bytestring, conduit, conduit-extra, exceptions
+     , generic-lens, hedgehog, hspec, http-types, hw-hspec-hedgehog
+     , lens, monad-logger, mtl, network-uri, resourcet, text
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "antiope-s3";
+       version = "6.3.0";
+       sha256 = "00szjn9vbb6xndzs0wpq2hw9a529ldy5y0pckfm3xkd6ap5ifx41";
+       libraryHaskellDepends = [
+         amazonka amazonka-core amazonka-s3 antiope-core attoparsec base
+         bytestring conduit conduit-extra exceptions generic-lens http-types
+         lens monad-logger mtl network-uri resourcet text unliftio-core
+       ];
+       testHaskellDepends = [
+         amazonka amazonka-core amazonka-s3 antiope-core attoparsec base
+         bytestring conduit conduit-extra exceptions generic-lens hedgehog
+         hspec http-types hw-hspec-hedgehog lens monad-logger mtl
+         network-uri resourcet text unliftio-core
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "antiope-sns" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sns, base
      , generic-lens, lens, text, unliftio-core
···
        pname = "antiope-sns";
        version = "6.2.0";
        sha256 = "0npm9q3vf2njiqwyswxc6xh5psjls0skz29mz22y59sk25m5fmkv";
+       libraryHaskellDepends = [
+         aeson amazonka amazonka-core amazonka-sns base generic-lens lens
+         text unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson amazonka amazonka-core amazonka-sns base generic-lens lens
+         text unliftio-core
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "antiope-sns_6_3_0" = callPackage
+    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sns, base
+     , generic-lens, lens, text, unliftio-core
+     }:
+     mkDerivation {
+       pname = "antiope-sns";
+       version = "6.3.0";
+       sha256 = "0fr51vp8ihlv7pnlrl73knd8wwck1rsw5v4yzm2b8299m7gqd86v";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-sns base generic-lens lens
          text unliftio-core
···
          aeson amazonka amazonka-core amazonka-s3 amazonka-sqs
          antiope-messages antiope-s3 base generic-lens lens lens-aeson
          monad-loops network-uri text unliftio-core
+       ];
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "antiope-sqs_6_3_0" = callPackage
+    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3
+     , amazonka-sqs, antiope-messages, antiope-s3, base, conduit
+     , generic-lens, lens, lens-aeson, monad-loops, mtl, network-uri
+     , text, unliftio-core
+     }:
+     mkDerivation {
+       pname = "antiope-sqs";
+       version = "6.3.0";
+       sha256 = "0a1kkzy9nldhwgh8xvnp4lqv49gpm6q9prnv2bgwlp00izy2r5s1";
+       libraryHaskellDepends = [
+         aeson amazonka amazonka-core amazonka-s3 amazonka-sqs
+         antiope-messages antiope-s3 base conduit generic-lens lens
+         lens-aeson monad-loops mtl network-uri text unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson amazonka amazonka-core amazonka-s3 amazonka-sqs
+         antiope-messages antiope-s3 base conduit generic-lens lens
+         lens-aeson monad-loops mtl network-uri text unliftio-core
        ];
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }) {};
 
   "bitvec" = callPackage
-    ({ mkDerivation, base, HUnit, primitive, QuickCheck, test-framework
-     , test-framework-hunit, test-framework-quickcheck2, vector
+    ({ mkDerivation, base, HUnit, primitive, QuickCheck
+     , quickcheck-classes, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, vector
      }:
      mkDerivation {
        pname = "bitvec";
-       version = "0.1.0.2";
-       sha256 = "15a9p3wpjyq9761yjpbxgzl6mfly9gbwzbpsqi0zyza09cf51gk2";
+       version = "0.1.1.0";
+       sha256 = "12wvilgmibkvbd1hb15ixyidkqdyadx8i8jwm9n50q9qjp4phmm5";
+       revision = "1";
+       editedCabalFile = "02y6rvmgvxhmw0mqq9b20hs75x42kkgsp2c3kppwmp4pspjipmjm";
        libraryHaskellDepends = [ base primitive vector ];
        testHaskellDepends = [
-         base HUnit primitive QuickCheck test-framework test-framework-hunit
-         test-framework-quickcheck2 vector
+         base HUnit primitive QuickCheck quickcheck-classes test-framework
+         test-framework-hunit test-framework-quickcheck2 vector
        ];
        description = "Unboxed vectors of bits / dense IntSets";
        license = stdenv.lib.licenses.publicDomain;
···
      }) {};
 
   "buffon-machines" = callPackage
-    ({ mkDerivation, base, multiset, random, template-haskell }:
+    ({ mkDerivation, base, mtl, multiset, random, template-haskell }:
      mkDerivation {
        pname = "buffon-machines";
-       version = "1.0.0.0";
-       sha256 = "0s8gfbfilvnhkyjs94fb7s0amcar3nvhjb5lx1gzqgbxdgs1grdy";
-       libraryHaskellDepends = [ base multiset random template-haskell ];
+       version = "1.1.1.0";
+       sha256 = "0985xh66j3f8p352gsq9balndwrsnylqilnnbk2sfb535jyh84dh";
+       libraryHaskellDepends = [
+         base mtl multiset random template-haskell
+       ];
        description = "Perfect simulation of discrete random variables";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        benchmarkHaskellDepends = [ base criterion deepseq hashable ];
        description = "Efficient little-endian bit vector library";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "bv-little_1_0_0" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, hashable, integer-gmp
+     , keys, mono-traversable, mono-traversable-keys, primitive
+     , QuickCheck, smallcheck, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck, text-show
+     }:
+     mkDerivation {
+       pname = "bv-little";
+       version = "1.0.0";
+       sha256 = "0hdzwcdm3cdiqyjkl5k9hg61za51w61j5168c17nfs1yyhh0fdms";
+       libraryHaskellDepends = [
+         base deepseq hashable integer-gmp keys mono-traversable
+         mono-traversable-keys primitive QuickCheck text-show
+       ];
+       testHaskellDepends = [
+         base deepseq hashable mono-traversable mono-traversable-keys
+         QuickCheck smallcheck tasty tasty-hunit tasty-quickcheck
+         tasty-smallcheck text-show
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq hashable mono-traversable QuickCheck
+         smallcheck
+       ];
+       description = "Efficient little-endian bit vector library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "bv-sized" = callPackage
···
      }:
      mkDerivation {
        pname = "cabal2nix";
-       version = "2.13";
-       sha256 = "0qp5q40y2wsba0gykws0w6xzbvr19bcgbqbz05xacp14zxw4r4sp";
+       version = "2.14.1";
+       sha256 = "1bkhh5s3x6as4pz70p2rgwkrb121k5ic7j5dhmlh0rwvhrr9g1z2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "cairo";
-       version = "0.13.5.0";
-       sha256 = "1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2";
+       version = "0.13.6.0";
+       sha256 = "0c0b0ffxd9dx4c52ny6im420f6wyjmd822fn6vh561d07nr0y08n";
+       revision = "1";
+       editedCabalFile = "1mldbaa3qp0nf4jyns1cnadyk8gga2w6hl3y2xdbnbbsjm42s4m9";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
+
+  "cairo-core" = callPackage
+    ({ mkDerivation, base, bytestring, c2hs, Cabal, cairo, directory
+     , filepath, haskell-src-exts, http-client, http-client-tls, hxt
+     , hxt-xpath, monad-extras, transformers
+     }:
+     mkDerivation {
+       pname = "cairo-core";
+       version = "1.16.3";
+       sha256 = "1dap6697r6izvags7k43b88z7m9i9yy0znrf1lgkrwv23mg6qxmj";
+       setupHaskellDepends = [
+         base bytestring Cabal directory filepath haskell-src-exts
+         http-client http-client-tls hxt hxt-xpath
+       ];
+       libraryHaskellDepends = [ base monad-extras transformers ];
+       libraryPkgconfigDepends = [ cairo ];
+       libraryToolDepends = [ c2hs ];
+       description = "Cairo Haskell binding (core functions)";
+       license = stdenv.lib.licenses.bsd3;
+     }) {inherit (pkgs) cairo;};
 
   "cake" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, cmdargs
···
      }:
      mkDerivation {
        pname = "collection-json";
-       version = "1.3.0.0";
-       sha256 = "17fb6zralgg6linsjapbqb4l7hycfwwvpr2l8jdksdky6bf65633";
+       version = "1.3.1.0";
+       sha256 = "0wlpv47jj5q2kiwm1daaw4p4s9vh3xfs4rpb78y2a1qw6r6nw9vw";
        libraryHaskellDepends = [
          aeson base network-uri network-uri-json text
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cubicbezier_0_6_0_6" = 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.6";
+       sha256 = "0s7s1ak0x89jy3q4yxrcvjzsq9w4yh23ycjcja6i7klj5gggqwss";
+       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 {
···
        testToolDepends = [ hspec-discover ];
        description = "Support for construction, rendering, and parsing of CUE sheets";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "cue-sheet_2_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, exceptions, hspec
+     , hspec-discover, hspec-megaparsec, megaparsec, mtl, QuickCheck
+     , text
+     }:
+     mkDerivation {
+       pname = "cue-sheet";
+       version = "2.0.1";
+       sha256 = "0papll3xcq2ipmya61jr71gf3zx2swmys829x5sbz7lv6abj9r3i";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring containers exceptions megaparsec mtl QuickCheck
+         text
+       ];
+       testHaskellDepends = [
+         base bytestring exceptions hspec hspec-megaparsec megaparsec
+         QuickCheck text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Support for construction, rendering, and parsing of CUE sheets";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "cufft" = callPackage
···
        pname = "dhall";
        version = "1.20.1";
        sha256 = "1p5whphy666q0h22yq3jb4aipb5bkqp45bp86m7dp12ljksfhxz0";
-       revision = "1";
-       editedCabalFile = "1km0zbbahhq24s84s9gcck1javhplqjg51q4qf8i19iahnxkl3rq";
+       revision = "2";
+       editedCabalFile = "0629z8lc97rapfcqcgvxwp9x4x3xqpzrly8m0nsn0dds7400jxrk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "eap";
        version = "0.9.0.2";
        sha256 = "0bgx7sxpmvhd84j7kkqznazw7p1fl862w7jxlap473g2q5365kqc";
+       revision = "1";
+       editedCabalFile = "1lsy7pl39s02f45l7g9alw49xwh7m8m4bm3ydcz11rh9xdgcb9jv";
        libraryHaskellDepends = [
          base binary bytestring cryptonite memory mtl pretty-hex
        ];
···
      }) {};
 
   "espial" = callPackage
-    ({ mkDerivation, aeson, base, bcrypt, bytestring, case-insensitive
-     , classy-prelude, classy-prelude-conduit, classy-prelude-yesod
-     , conduit, containers, data-default, directory, ekg, ekg-core
-     , esqueleto, fast-logger, file-embed, foreign-store, hjsmin
-     , hscolour, hspec, http-conduit, iso8601-time, microlens
-     , monad-control, monad-logger, monad-metrics, mtl, optparse-generic
-     , persistent, persistent-sqlite, persistent-template, pinboard
-     , pretty-show, safe, shakespeare, template-haskell, text, time
-     , transformers, unordered-containers, vector, wai, wai-extra
-     , wai-logger, wai-middleware-metrics, warp, yaml, yesod, yesod-auth
-     , yesod-core, yesod-form, yesod-static, yesod-test
+    ({ mkDerivation, aeson, attoparsec, base, bcrypt, bytestring
+     , case-insensitive, classy-prelude, classy-prelude-conduit
+     , classy-prelude-yesod, conduit, containers, data-default
+     , directory, ekg, ekg-core, entropy, esqueleto, fast-logger
+     , file-embed, foreign-store, hjsmin, hscolour, hspec, http-api-data
+     , http-client, http-client-tls, http-conduit, http-types
+     , iso8601-time, microlens, monad-logger, monad-metrics, mtl
+     , optparse-generic, parser-combinators, persistent
+     , persistent-sqlite, persistent-template, pretty-show, safe
+     , shakespeare, template-haskell, text, time, transformers
+     , unordered-containers, vector, wai, wai-extra, wai-logger
+     , wai-middleware-metrics, warp, yaml, yesod, yesod-auth, yesod-core
+     , yesod-form, yesod-static, yesod-test
      }:
      mkDerivation {
        pname = "espial";
-       version = "0.0.5.1";
-       sha256 = "010a809fmi6sxh2fwiwvjqk3d293cg5acj57lb1qbm6qjzn7ir37";
+       version = "0.0.7";
+       sha256 = "06nlmz8j6f64dgbd9y9b7i9fd1bv32yxijx764zlvy75i6vbips5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base bcrypt bytestring case-insensitive classy-prelude
-         classy-prelude-conduit classy-prelude-yesod conduit containers
-         data-default directory ekg ekg-core esqueleto fast-logger
-         file-embed foreign-store hjsmin hscolour http-conduit iso8601-time
-         microlens monad-control monad-logger monad-metrics mtl persistent
-         persistent-sqlite persistent-template pinboard pretty-show safe
+         aeson attoparsec base bcrypt bytestring case-insensitive
+         classy-prelude classy-prelude-conduit classy-prelude-yesod conduit
+         containers data-default directory ekg ekg-core entropy esqueleto
+         fast-logger file-embed foreign-store hjsmin hscolour http-api-data
+         http-client http-client-tls http-conduit http-types iso8601-time
+         microlens monad-logger monad-metrics mtl parser-combinators
+         persistent persistent-sqlite persistent-template pretty-show safe
          shakespeare template-haskell text time transformers
          unordered-containers vector wai wai-extra wai-logger
          wai-middleware-metrics warp yaml yesod yesod-auth yesod-core
          yesod-form yesod-static
        ];
        executableHaskellDepends = [
-         aeson base bcrypt bytestring case-insensitive classy-prelude
-         classy-prelude-conduit classy-prelude-yesod conduit containers
-         data-default directory ekg ekg-core esqueleto fast-logger
-         file-embed foreign-store hjsmin hscolour http-conduit iso8601-time
-         microlens monad-control monad-logger monad-metrics mtl
-         optparse-generic persistent persistent-sqlite persistent-template
-         pinboard pretty-show safe shakespeare template-haskell text time
+         aeson attoparsec base bcrypt bytestring case-insensitive
+         classy-prelude classy-prelude-conduit classy-prelude-yesod conduit
+         containers data-default directory ekg ekg-core entropy esqueleto
+         fast-logger file-embed foreign-store hjsmin hscolour http-api-data
+         http-client http-client-tls http-conduit http-types iso8601-time
+         microlens monad-logger monad-metrics mtl optparse-generic
+         parser-combinators persistent persistent-sqlite persistent-template
+         pretty-show safe shakespeare template-haskell text time
          transformers unordered-containers vector wai wai-extra wai-logger
          wai-middleware-metrics warp yaml yesod yesod-auth yesod-core
          yesod-form yesod-static
        ];
        testHaskellDepends = [
-         aeson base bcrypt bytestring case-insensitive classy-prelude
-         classy-prelude-conduit classy-prelude-yesod conduit containers
-         data-default directory ekg ekg-core esqueleto fast-logger
-         file-embed foreign-store hjsmin hscolour hspec http-conduit
-         iso8601-time microlens monad-control monad-logger monad-metrics mtl
-         persistent persistent-sqlite persistent-template pinboard
+         aeson attoparsec base bcrypt bytestring case-insensitive
+         classy-prelude classy-prelude-conduit classy-prelude-yesod conduit
+         containers data-default directory ekg ekg-core entropy esqueleto
+         fast-logger file-embed foreign-store hjsmin hscolour hspec
+         http-api-data http-client http-client-tls http-conduit http-types
+         iso8601-time microlens monad-logger monad-metrics mtl
+         parser-combinators persistent persistent-sqlite persistent-template
          pretty-show safe shakespeare template-haskell text time
          transformers unordered-containers vector wai wai-extra wai-logger
          wai-middleware-metrics warp yaml yesod yesod-auth yesod-core
          yesod-form yesod-static yesod-test
        ];
        description = "Espial is an open-source, web-based bookmarking server";
-       license = stdenv.lib.licenses.mit;
+       license = stdenv.lib.licenses.agpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
        pname = "failable";
        version = "0.1.1.0";
        sha256 = "0wg4jhilnyqxs6kqikbli1ia6xl4hi4hipdc1pp1f2d2gxgg0afb";
+       revision = "1";
+       editedCabalFile = "05952427jqydy44yqsjad3xwy62k48f7ygyby28rg6s5l59966pz";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "A 'Failable' error monad class to unify failure across monads that can fail";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "flac";
        version = "0.1.2";
        sha256 = "0adc88h5dmazf9m2xah0qkcav3pm0l3jiy8wbg9fxjv1qpgv74jn";
-       revision = "4";
-       editedCabalFile = "0bmhd56fg4idz62maig3kykk7dyqy9dpm27fdljqg8jccl0vbwbm";
+       revision = "5";
+       editedCabalFile = "0rwwq8qrxd497rd5m0kidz4v69frj72ds7a6zrdqigj5f5471rhd";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers data-default-class directory exceptions
···
          base bytestring data-default-class directory flac hspec JuicyPixels
          temporary
        ];
+       description = "Support for writing picture to FLAC metadata blocks with JuicyPixels";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "flac-picture_0_1_2" = callPackage
+    ({ mkDerivation, base, bytestring, directory, flac, hspec
+     , hspec-discover, JuicyPixels, temporary
+     }:
+     mkDerivation {
+       pname = "flac-picture";
+       version = "0.1.2";
+       sha256 = "02h36z65xmy0mvg7j2863h35dcf24l08ma0dxjbqcn42sca9ss0m";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base bytestring flac JuicyPixels ];
+       testHaskellDepends = [
+         base bytestring directory flac hspec JuicyPixels temporary
+       ];
+       testToolDepends = [ hspec-discover ];
        description = "Support for writing picture to FLAC metadata blocks with JuicyPixels";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.lgpl21;
      }) {inherit (pkgs) cairo;};
 
+  "gi-cairo-again" = callPackage
+    ({ mkDerivation, base, cairo-core, haskell-gi-base
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "gi-cairo-again";
+       version = "1.16.0";
+       sha256 = "1xxrcx9dsscymz2v53splzrr39gajw2bcr3ksblak46bamb67bmg";
+       libraryHaskellDepends = [
+         base cairo-core haskell-gi-base template-haskell
+       ];
+       description = "Bridge between packages gi-* and cairo-core";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "gi-cairo-connector" = callPackage
     ({ mkDerivation, base, gi-cairo, gi-cairo-render, haskell-gi-base
      , mtl
···
      }:
      mkDerivation {
        pname = "gio";
-       version = "0.13.5.0";
-       sha256 = "0p1mwzbrzb74wxlykasza4qvvlck2b0wgnhvfa0j3h27x4ii8xjw";
+       version = "0.13.6.0";
+       sha256 = "1ck92sy9j3jrwi2w6a0nslz92aczznsz96rdqq8v78rqqislpirm";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "7.20190122";
-       sha256 = "0z5a5sskmjmayh1w9m48v7b81s1ybcglglry2jy1awdbn2l4mxk5";
+       version = "7.20190129";
+       sha256 = "0gsi1ymv7dmx429vhv58979hfh23zrfvrsam6saf16ckh5hd0n81";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fpairing" "-fproduction" "-fs3" "-ftorrentparser" "-fwebapp"
···
        pname = "git-monitor";
        version = "3.1.1.5";
        sha256 = "0jqmcldnl1hd0za33jw4490qgx9ngqbh7pyy47y1pb9j1hvci9jj";
+       revision = "1";
+       editedCabalFile = "18s9vigsi5z5j2m5q956nj4h84bwgfh8v010dz4jahhrlkavg1ra";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "github-webhooks_0_10_1" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , cryptonite, deepseq, deepseq-generics, hspec, memory, text, time
+     , vector
+     }:
+     mkDerivation {
+       pname = "github-webhooks";
+       version = "0.10.1";
+       sha256 = "1hjl5ygvxhh70l951zc4n4qmdf3vf2x983jyimsinyv03bl11i6x";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptonite deepseq
+         deepseq-generics memory text time vector
+       ];
+       testHaskellDepends = [ aeson base bytestring hspec text vector ];
+       description = "Aeson instances for GitHub Webhook payloads";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "githud" = callPackage
     ({ mkDerivation, base, mtl, parsec, process, tasty, tasty-hunit
      , tasty-quickcheck, tasty-smallcheck, text, unix
···
      }:
      mkDerivation {
        pname = "gitlib-libgit2";
-       version = "3.1.2";
-       sha256 = "1nj9f2qmjxb5k9b23wfyz290pgb01hnzrswbamwb7am9bnkk250b";
+       version = "3.1.2.1";
+       sha256 = "0gm2d8x7brcf3x3d6jy3anig158cj3961gicw1wq7xg0wz90l3mr";
        libraryHaskellDepends = [
          base bytestring conduit conduit-combinators containers directory
          exceptions fast-logger filepath gitlib hlibgit2 mmorph monad-loops
···
      }:
      mkDerivation {
        pname = "glib";
-       version = "0.13.6.0";
-       sha256 = "1sz8mvac39sxj7skw8zasbp6srm4k92223l29lll1125d8n0cwaf";
+       version = "0.13.7.0";
+       sha256 = "06hdn8mprq6xclp8xfr1iqx82i0nhims3dhjblqn26ig5fdidjbw";
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [
          base bytestring containers text utf8-string
···
      }:
      mkDerivation {
        pname = "google-server-api";
-       version = "0.3.0.0";
-       sha256 = "1zrgflz6pav8ygjjisjm35w7a232116f90s0pd8jqf46an2bm8i2";
+       version = "0.3.1.0";
+       sha256 = "12n3cd4k515z8shi6klxa2s3cbccqk8h38y45h1lqk1j8ydp3r21";
        libraryHaskellDepends = [
          aeson aeson-casing base base64-bytestring bytestring HsOpenSSL
          http-api-data http-client http-client-tls mime-mail monad-control
···
      }:
      mkDerivation {
        pname = "gtk";
-       version = "0.15.0";
-       sha256 = "110lawhnd00acllfjhimcq59wxsrl2xs68mam6wmqfc43wan5f5k";
+       version = "0.15.1";
+       sha256 = "1hhx6qcbd0qlwvi1d98vkmshrq1j7wiia0i3pwdidvfrjkn3aa7j";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "gtk2hs-buildtools";
-       version = "0.13.4.0";
-       sha256 = "0yg6xmylgpylmnh5g33qwwn5x9bqckdvvv4czqzd9vrr12lnnghg";
-       revision = "1";
-       editedCabalFile = "0nbghg11y4nvxjxrvdm4a7fzj8z12fr12hkj4b7p27imlryg3m10";
+       version = "0.13.5.0";
+       sha256 = "01a3q7ciinrwa6xjk0qwpyjabdjzfsy8qqfkp0iir2h8i8prnpz4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "gtk3";
-       version = "0.15.0";
-       sha256 = "1q6ysw00gjaaali18iz111zqzkjiblzg7cfg6ckvzf93mg0w6g0c";
+       version = "0.15.1";
+       sha256 = "0kya9ag8c7zl8sqx32hmlmz9rpxghvyr2svzcr38lzizfd74bnpq";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "hasbolt-extras";
-       version = "0.0.0.15";
-       sha256 = "114yzmvj96nhq37947p5kf3zc4hdh4dnbavms0f1ndszmn1q7hd9";
+       version = "0.0.0.16";
+       sha256 = "1759pk8w5vvgm194lbfj1z9vxwh19d1s36lwpwni1qk7l1lpvvm6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hedis_0_11_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, bytestring-lexing
+     , deepseq, doctest, errors, HTTP, HUnit, mtl, network, network-uri
+     , resource-pool, scanner, stm, test-framework, test-framework-hunit
+     , text, time, tls, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "hedis";
+       version = "0.11.0";
+       sha256 = "070m9jrv1jczrxscbrr0fln45harw2y9rcj9qnp4d9sj7m597vvy";
+       libraryHaskellDepends = [
+         async base bytestring bytestring-lexing deepseq errors HTTP mtl
+         network network-uri resource-pool scanner stm text time tls
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         async base bytestring doctest HUnit mtl stm test-framework
+         test-framework-hunit text time
+       ];
+       benchmarkHaskellDepends = [ base mtl time ];
+       description = "Client library for the Redis datastore: supports full command set, pipelining";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hedis-config" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hedis, scientific, text
      , time
···
   "hledger" = callPackage
     ({ mkDerivation, ansi-terminal, base, base-compat-batteries
      , bytestring, cmdargs, containers, criterion, data-default, Decimal
-     , Diff, directory, easytest, file-embed, filepath, hashable
-     , haskeline, here, hledger-lib, html, lucid, math-functions
-     , megaparsec, mtl, mtl-compat, old-time, parsec, pretty-show
-     , process, regex-tdfa, safe, shakespeare, split, tabular, temporary
-     , terminfo, test-framework, test-framework-hunit, text, time
-     , timeit, transformers, unordered-containers, utf8-string
-     , utility-ht, wizards
+     , Diff, directory, easytest, filepath, hashable, haskeline, here
+     , hledger-lib, html, lucid, math-functions, megaparsec, mtl
+     , mtl-compat, old-time, parsec, pretty-show, process, regex-tdfa
+     , safe, shakespeare, split, tabular, temporary, terminfo
+     , test-framework, test-framework-hunit, text, time, timeit
+     , transformers, unordered-containers, utf8-string, utility-ht
+     , wizards
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.12.1";
-       sha256 = "1b9zvlrhrzg0rvk90ac1z8n8sfhdx070l8hy3sg25nbcsqxzd51w";
+       version = "1.13";
+       sha256 = "1dhyc439r0ff3jdnbfcb06wb7xlxwvczn9p2spn5316wdza8lk53";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          ansi-terminal base base-compat-batteries bytestring cmdargs
-         containers data-default Decimal Diff directory easytest file-embed
-         filepath hashable haskeline here hledger-lib lucid math-functions
-         megaparsec mtl mtl-compat old-time parsec pretty-show process
-         regex-tdfa safe shakespeare split tabular temporary terminfo text
-         time transformers unordered-containers utf8-string utility-ht
-         wizards
+         containers data-default Decimal Diff directory easytest filepath
+         hashable haskeline here hledger-lib lucid math-functions megaparsec
+         mtl mtl-compat old-time parsec pretty-show process regex-tdfa safe
+         shakespeare split tabular temporary terminfo text time transformers
+         unordered-containers utf8-string utility-ht wizards
        ];
        executableHaskellDepends = [
          ansi-terminal base base-compat-batteries bytestring cmdargs
-         containers data-default Decimal directory easytest file-embed
-         filepath haskeline here hledger-lib math-functions megaparsec mtl
-         mtl-compat old-time parsec pretty-show process regex-tdfa safe
-         shakespeare split tabular temporary terminfo text time transformers
+         containers data-default Decimal directory easytest filepath
+         haskeline here hledger-lib math-functions megaparsec mtl mtl-compat
+         old-time parsec pretty-show process regex-tdfa safe shakespeare
+         split tabular temporary terminfo text time transformers
          unordered-containers utf8-string utility-ht wizards
        ];
        testHaskellDepends = [
          ansi-terminal base base-compat-batteries bytestring cmdargs
-         containers data-default Decimal directory easytest file-embed
-         filepath haskeline here hledger-lib math-functions megaparsec mtl
-         mtl-compat old-time parsec pretty-show process regex-tdfa safe
-         shakespeare split tabular temporary terminfo test-framework
+         containers data-default Decimal directory easytest filepath
+         haskeline here hledger-lib math-functions megaparsec mtl mtl-compat
+         old-time parsec pretty-show process regex-tdfa safe shakespeare
+         split tabular temporary terminfo test-framework
          test-framework-hunit text time transformers unordered-containers
          utf8-string utility-ht wizards
        ];
        benchmarkHaskellDepends = [
          ansi-terminal base base-compat-batteries bytestring cmdargs
          containers criterion data-default Decimal directory easytest
-         file-embed filepath haskeline here hledger-lib html math-functions
-         megaparsec mtl mtl-compat old-time parsec pretty-show process
-         regex-tdfa safe shakespeare split tabular temporary terminfo text
-         time timeit transformers unordered-containers utf8-string
-         utility-ht wizards
+         filepath haskeline here hledger-lib html math-functions megaparsec
+         mtl mtl-compat old-time parsec pretty-show process regex-tdfa safe
+         shakespeare split tabular temporary terminfo text time timeit
+         transformers unordered-containers utf8-string utility-ht wizards
        ];
        description = "Command-line interface for the hledger accounting tool";
        license = stdenv.lib.licenses.gpl3;
···
      }:
      mkDerivation {
        pname = "hledger-api";
-       version = "1.12";
-       sha256 = "0vl4ag5r58zag8djihmdlj9apqrvczjn51qfizs366wprdppdxax";
+       version = "1.13";
+       sha256 = "1pkim0qxgakbngnslw04lhlmv2ad195lw60hxz5iyrxywizkiwp3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, ansi-terminal, array, base, base-compat-batteries
      , blaze-markup, bytestring, call-stack, cassava, cassava-megaparsec
      , cmdargs, containers, data-default, Decimal, deepseq, directory
-     , doctest, easytest, extra, filepath, Glob, hashtables, megaparsec
-     , mtl, mtl-compat, old-time, parsec, parser-combinators
-     , pretty-show, regex-tdfa, safe, split, tabular, text, time
-     , transformers, uglymemo, utf8-string
+     , doctest, easytest, extra, file-embed, filepath, Glob, hashtables
+     , here, megaparsec, mtl, mtl-compat, old-time, parsec
+     , parser-combinators, pretty-show, regex-tdfa, safe, split, tabular
+     , template-haskell, text, time, transformers, uglymemo, utf8-string
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.12";
-       sha256 = "1m38r9z6ccdxhl54k8x9drbfmj1l9hy8mnb7cj4bwprpz4xx15bh";
+       version = "1.13";
+       sha256 = "1pfqfc7kfy3sni5i8h73i6gj0yf3fsbn1lf1g1zx2jfpgxm36wgg";
        libraryHaskellDepends = [
          ansi-terminal array base base-compat-batteries blaze-markup
          bytestring call-stack cassava cassava-megaparsec cmdargs containers
-         data-default Decimal deepseq directory easytest extra filepath Glob
-         hashtables megaparsec mtl mtl-compat old-time parsec
-         parser-combinators pretty-show regex-tdfa safe split tabular text
-         time transformers uglymemo utf8-string
+         data-default Decimal deepseq directory easytest extra file-embed
+         filepath Glob hashtables here megaparsec mtl mtl-compat old-time
+         parsec parser-combinators pretty-show regex-tdfa safe split tabular
+         template-haskell text time transformers uglymemo utf8-string
        ];
        testHaskellDepends = [
          ansi-terminal array base base-compat-batteries blaze-markup
          bytestring call-stack cassava cassava-megaparsec cmdargs containers
          data-default Decimal deepseq directory doctest easytest extra
-         filepath Glob hashtables megaparsec mtl mtl-compat old-time parsec
-         parser-combinators pretty-show regex-tdfa safe split tabular text
-         time transformers uglymemo utf8-string
+         file-embed filepath Glob hashtables here megaparsec mtl mtl-compat
+         old-time parsec parser-combinators pretty-show regex-tdfa safe
+         split tabular template-haskell text time transformers uglymemo
+         utf8-string
        ];
        description = "Core data types, parsers and functionality for the hledger accounting tools";
        license = stdenv.lib.licenses.gpl3;
···
      , brick, cmdargs, containers, data-default, directory, filepath
      , fsnotify, hledger, hledger-lib, megaparsec, microlens
      , microlens-platform, pretty-show, process, safe, split, text
-     , text-zipper, time, transformers, vector, vty
+     , text-zipper, time, transformers, unix, vector, vty
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.12.1";
-       sha256 = "0ifyp2kawi4x0slnv5gkcgn8v6vx6d9q56x6zjpfzslajqfwfk8y";
+       version = "1.13";
+       sha256 = "1dmziyffx3bjam40j1jxbbg0wm15fkci9zpsdpdbzx39264c0n40";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          ansi-terminal async base base-compat-batteries brick cmdargs
          containers data-default directory filepath fsnotify hledger
          hledger-lib megaparsec microlens microlens-platform pretty-show
-         process safe split text text-zipper time transformers vector vty
+         process safe split text text-zipper time transformers unix vector
+         vty
        ];
        description = "Curses-style user interface for the hledger accounting tool";
        license = stdenv.lib.licenses.gpl3;
···
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.12";
-       sha256 = "14n3qhdr95nfgczw05dki2wy26k86z1h0li8md1bglch4j9fjs36";
+       version = "1.13";
+       sha256 = "045bhllvxs92r96hx9aaipc9hpaqhv7b3dm2nxc1912iq761wqnp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "hw-json_1_0_0_1" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base
+     , bits-extra, bytestring, criterion, directory, dlist, hedgehog
+     , hspec, hspec-discover, hw-balancedparens, hw-bits
+     , hw-hspec-hedgehog, hw-json-simd, hw-mquery, hw-parser, hw-prim
+     , hw-rankselect, hw-rankselect-base, hw-simd, lens, mmap
+     , optparse-applicative, text, transformers, vector, word8
+     }:
+     mkDerivation {
+       pname = "hw-json";
+       version = "1.0.0.1";
+       sha256 = "1svynix1vilp6w5azm0nlkx3b92m5x8plnj8jnw4k6ybr4mdw32b";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-wl-pprint array attoparsec base bits-extra bytestring dlist
+         hw-balancedparens hw-bits hw-mquery hw-parser hw-prim hw-rankselect
+         hw-rankselect-base hw-simd mmap text vector word8
+       ];
+       executableHaskellDepends = [
+         base bytestring dlist hw-balancedparens hw-json-simd hw-mquery
+         hw-prim hw-rankselect hw-rankselect-base lens mmap
+         optparse-applicative vector
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring hedgehog hspec hw-balancedparens hw-bits
+         hw-hspec-hedgehog hw-prim hw-rankselect hw-rankselect-base
+         transformers vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion directory mmap
+       ];
+       description = "Memory efficient JSON parser";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hw-json-lens" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion, hw-json
      , lens, scientific, word8
···
      }:
      mkDerivation {
        pname = "hw-json-simd";
-       version = "0.1.0.0";
-       sha256 = "015frhg0v7vxrl1m4bjg2rfa7z0846g9xclirdhb4n5pjzr11rp9";
+       version = "0.1.0.1";
+       sha256 = "0pi67lyx9ysvgfsk75a4yzmfrn65f7i65pp2m6z5hd5svali37sw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring hw-prim lens vector ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "instana-haskell-trace-sdk" = callPackage
+    ({ mkDerivation, aeson, aeson-extra, base, binary, bytestring
+     , containers, directory, ekg-core, exceptions, hslogger
+     , http-client, http-client-tls, http-types, HUnit, network, process
+     , random, regex-base, regex-tdfa, retry, scientific, servant
+     , servant-server, stm, sysinfo, text, time, transformers, unix
+     , unordered-containers, wai, warp
+     }:
+     mkDerivation {
+       pname = "instana-haskell-trace-sdk";
+       version = "0.1.0.0";
+       sha256 = "1px0p990sr2l7l7h8k5l24bjvi4ag5i3v78vwlhgzykpfsxwq3bg";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-extra base bytestring containers directory ekg-core
+         exceptions hslogger http-client http-client-tls http-types network
+         process random regex-base regex-tdfa retry scientific stm sysinfo
+         text time unix unordered-containers wai
+       ];
+       executableHaskellDepends = [
+         aeson base binary bytestring hslogger http-client http-types
+         servant servant-server text time transformers unix wai warp
+       ];
+       testHaskellDepends = [
+         aeson aeson-extra base bytestring directory ekg-core exceptions
+         hslogger http-client http-types HUnit process random regex-base
+         regex-tdfa retry scientific text unix unordered-containers
+       ];
+       description = "SDK for adding custom Instana tracing support to Haskell applications";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "instance-control" = callPackage
     ({ mkDerivation, base, mtl, transformers }:
      mkDerivation {
···
      }) {};
 
   "iri" = callPackage
-    ({ mkDerivation, attoparsec, base, base-prelude, bug, bytestring
-     , contravariant, hashable, ip, profunctors, ptr, punycode
-     , QuickCheck, quickcheck-instances, rerebase, semigroups, tasty
-     , tasty-hunit, tasty-quickcheck, template-haskell, text
-     , text-builder, th-lift, th-lift-instances, unordered-containers
-     , vector, vector-builder, vector-instances
+    ({ mkDerivation, attoparsec, base, bytestring, contravariant
+     , hashable, ip, profunctors, ptr, punycode, QuickCheck
+     , quickcheck-instances, rerebase, semigroups, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, text-builder, th-lift
+     , th-lift-instances, unordered-containers, vector, vector-builder
+     , vector-instances
      }:
      mkDerivation {
        pname = "iri";
-       version = "0.3.4.1";
-       sha256 = "0lissbq0rajhds1s68shba227v0qsq51ffs171rnw31m92rn1c54";
+       version = "0.4";
+       sha256 = "0v790f2fl4hcb6069ak5cscd156ry3065cshjh9c30239allw7m5";
        libraryHaskellDepends = [
-         attoparsec base base-prelude bug bytestring contravariant hashable
-         ip profunctors ptr punycode semigroups template-haskell text
-         text-builder th-lift th-lift-instances unordered-containers vector
-         vector-builder vector-instances
+         attoparsec base bytestring contravariant hashable ip profunctors
+         ptr punycode semigroups template-haskell text text-builder th-lift
+         th-lift-instances unordered-containers vector vector-builder
+         vector-instances
        ];
        testHaskellDepends = [
          QuickCheck quickcheck-instances rerebase tasty tasty-hunit
          tasty-quickcheck
        ];
-       description = "RFC-based International Resource Identifier library";
+       description = "RFC-based resource identifier library";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "machines-attoparsec" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, machines, tasty
+     , tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "machines-attoparsec";
+       version = "0";
+       sha256 = "0mxm1gy7kr7czhmfwskl56wnawb2l3axfig22935bliq75mpvbs4";
+       libraryHaskellDepends = [
+         attoparsec base bytestring machines text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring machines tasty tasty-hunit text
+       ];
+       description = "Parse machines streams with attoparsec parsers";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "machines-binary" = callPackage
     ({ mkDerivation, base, binary, bytestring, machines }:
      mkDerivation {
···
        ];
        description = "Directory (system) utilities for the machines library";
        license = stdenv.lib.licenses.asl20;
+     }) {};
+
+  "machines-encoding" = callPackage
+    ({ mkDerivation, base, bytestring, machines, text }:
+     mkDerivation {
+       pname = "machines-encoding";
+       version = "0";
+       sha256 = "1n8skhf48q7dissrq7hpgsccjgh1hspjqh331m58z8id9xry133g";
+       libraryHaskellDepends = [ base bytestring machines text ];
+       description = "Transcode encodings with machines";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "machines-io" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "mmark_0_0_6_1" = callPackage
+    ({ mkDerivation, aeson, base, case-insensitive, containers
+     , criterion, deepseq, dlist, email-validate, foldl, hashable, hspec
+     , hspec-discover, hspec-megaparsec, html-entity-map, lucid
+     , megaparsec, microlens, microlens-th, modern-uri, mtl
+     , parser-combinators, QuickCheck, text, text-metrics
+     , unordered-containers, weigh, yaml
+     }:
+     mkDerivation {
+       pname = "mmark";
+       version = "0.0.6.1";
+       sha256 = "0riizf8qg6938w9vvf0lwaflsc3lpbqmbiqdfv8d7fhxpk10qaxw";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base case-insensitive containers deepseq dlist email-validate
+         foldl hashable html-entity-map lucid megaparsec microlens
+         microlens-th modern-uri mtl parser-combinators text text-metrics
+         unordered-containers yaml
+       ];
+       testHaskellDepends = [
+         aeson base foldl hspec hspec-megaparsec lucid megaparsec modern-uri
+         QuickCheck text
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion text weigh ];
+       description = "Strict markdown processor for writers";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mmark-cli" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory
      , ghc-syntax-highlighter, gitrev, lucid, megaparsec, mmark
···
 
   "mmtf" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, data-msgpack
-     , hspec, QuickCheck, text
+     , hspec, http-conduit, QuickCheck, text
      }:
      mkDerivation {
        pname = "mmtf";
-       version = "0.1.0.1";
-       sha256 = "100hyv6qb8jkqaw2f2h2fz9m32xrh3ffll67y52a11pkxzilyh19";
+       version = "0.1.2.0";
+       sha256 = "0z3x3cz4lgsnbpbi9ra179wdi3xqq0h46a6x76mq8k76c0jms51y";
        libraryHaskellDepends = [
-         base binary bytestring containers data-msgpack text
+         base binary bytestring containers data-msgpack http-conduit text
        ];
-       testHaskellDepends = [ base bytestring hspec QuickCheck ];
+       testHaskellDepends = [
+         base binary bytestring containers data-msgpack hspec http-conduit
+         QuickCheck text
+       ];
        description = "Macromolecular Transmission Format implementation";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        ];
        description = "Extra typeclass instances for mono-traversable";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "mono-traversable-keys" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hashable, keys
+     , mono-traversable, semigroups, text, transformers
+     , unordered-containers, vector, vector-instances
+     }:
+     mkDerivation {
+       pname = "mono-traversable-keys";
+       version = "0.1.0";
+       sha256 = "0xyl4n0ydfqrjydm2g62r1zl36bdvvp8nbxbqkbai1z24a9r51dw";
+       libraryHaskellDepends = [
+         base bytestring containers hashable keys mono-traversable
+         semigroups text transformers unordered-containers vector
+         vector-instances
+       ];
+       description = "Type-classes for interacting with monomorphic containers with a key";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "mono-traversable-wrapper" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "network_3_0_0_0" = callPackage
+  "network_3_0_0_1" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, hspec
      , hspec-discover, HUnit, unix
      }:
      mkDerivation {
        pname = "network";
-       version = "3.0.0.0";
-       sha256 = "1j9lhyb50k056ynyfsyh1ak9gn1knh11cyajlnbix8yhahm2mkla";
+       version = "3.0.0.1";
+       sha256 = "03f7gi3skz2ivack73wgn0zsppxwscl6j6xvwjal6i7y3rzajiam";
        libraryHaskellDepends = [ base bytestring deepseq unix ];
        testHaskellDepends = [ base bytestring directory hspec HUnit ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "network-arbitrary";
-       version = "0.4.0.1";
-       sha256 = "161l63gr2l2ncp8vaznl4izxgig43w26q91hvpd6x57k0y4r2zk9";
+       version = "0.4.0.2";
+       sha256 = "0n7h1vfh4iwcni8v92hkfvwdqcnv928c1pxj5mrcrvfggpq97a1a";
        libraryHaskellDepends = [
          base bytestring http-media http-types network-uri QuickCheck
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "optparse-simple_0_1_1_1" = callPackage
+    ({ mkDerivation, base, bytestring, directory, githash
+     , optparse-applicative, template-haskell, transformers
+     }:
+     mkDerivation {
+       pname = "optparse-simple";
+       version = "0.1.1.1";
+       sha256 = "0nqr81q5rvzpgl3r79rrmf30jzkds8gwdir2w1c9775jy2wslssl";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base githash optparse-applicative template-haskell transformers
+       ];
+       testHaskellDepends = [ base bytestring directory ];
+       description = "Simple interface to optparse-applicative";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "optparse-text" = callPackage
     ({ mkDerivation, base, hspec, optparse-applicative, text }:
      mkDerivation {
···
        maintainers = with stdenv.lib.maintainers; [ peti ];
      }) {};
 
+  "pandoc_2_6" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
+     , binary, blaze-html, blaze-markup, bytestring, case-insensitive
+     , cmark-gfm, containers, criterion, data-default, deepseq, Diff
+     , directory, doctemplates, exceptions, executable-path, filepath
+     , Glob, haddock-library, hslua, hslua-module-text, HsYAML, HTTP
+     , http-client, http-client-tls, http-types, ipynb, JuicyPixels, mtl
+     , network, network-uri, pandoc-types, parsec, process, QuickCheck
+     , random, safe, SHA, skylighting, split, syb, tagsoup, tasty
+     , tasty-golden, tasty-hunit, tasty-quickcheck, temporary, texmath
+     , text, time, unicode-transforms, unix, unordered-containers
+     , vector, weigh, xml, zip-archive, zlib
+     }:
+     mkDerivation {
+       pname = "pandoc";
+       version = "2.6";
+       sha256 = "046vya7ivngv0hp5chnfxc1dm5n3krbgm0883ph45l31c7liyxma";
+       configureFlags = [ "-fhttps" "-f-trypandoc" ];
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base base64-bytestring binary blaze-html
+         blaze-markup bytestring case-insensitive cmark-gfm containers
+         data-default deepseq directory doctemplates exceptions filepath
+         Glob haddock-library hslua hslua-module-text HsYAML HTTP
+         http-client http-client-tls http-types ipynb JuicyPixels mtl
+         network network-uri pandoc-types parsec process random safe SHA
+         skylighting split syb tagsoup temporary texmath text time
+         unicode-transforms unix unordered-containers vector xml zip-archive
+         zlib
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base base64-bytestring bytestring containers Diff directory
+         executable-path filepath Glob hslua pandoc-types process QuickCheck
+         tasty tasty-golden tasty-hunit tasty-quickcheck temporary text time
+         xml zip-archive
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers criterion mtl text time weigh
+       ];
+       postInstall = ''
+         mkdir -p $out/share
+         mv $data/*/*/man $out/share/
+       '';
+       description = "Conversion between markup formats";
+       license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       maintainers = with stdenv.lib.maintainers; [ peti ];
+     }) {};
+
   "pandoc-citeproc" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
      , Cabal, containers, data-default, directory, filepath, hs-bibutils
···
        pname = "pandoc-citeproc";
        version = "0.15.0.1";
        sha256 = "1y4jmralmcikmk75cf5bjlv4ymr42x35a6174ybqa99jmlm5znr9";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [
+         aeson base bytestring containers data-default directory filepath
+         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051
+         setenv split syb tagsoup text time unordered-containers vector
+         xml-conduit yaml
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty attoparsec base bytestring filepath pandoc
+         pandoc-types syb text yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers directory filepath mtl pandoc
+         pandoc-types process temporary text yaml
+       ];
+       doCheck = false;
+       description = "Supports using pandoc with citeproc";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "pandoc-citeproc_0_16" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
+     , Cabal, containers, data-default, directory, filepath, hs-bibutils
+     , mtl, old-locale, pandoc, pandoc-types, parsec, process, rfc5051
+     , setenv, split, syb, tagsoup, temporary, text, time
+     , unordered-containers, vector, xml-conduit, yaml
+     }:
+     mkDerivation {
+       pname = "pandoc-citeproc";
+       version = "0.16";
+       sha256 = "1fs1dr7cgkzy0sb68fx85x6l5j1hx9sgkiyxzdfi90hpqnm207sy";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "pandora";
-       version = "0.1.0";
-       sha256 = "1hfm9a8rfjksjv8qmz8a17f9pg1qw2rizaakl108lafckbz7f4ya";
+       version = "0.1.1";
+       sha256 = "0x2pfvvpn7r99238ma3q6fnirx6zh2pzz86b4fijll2k7wqxkl94";
        description = "A box of patterns and paradigms";
        license = stdenv.lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "pango";
-       version = "0.13.5.0";
-       sha256 = "1s29dmds28ffbcbic8pw3bsixkb6lzjm78j8qv4x3r9l64kvjndz";
+       version = "0.13.6.0";
+       sha256 = "14qcikd9r06ra7zp557c0bffd357yj4hk9bjigyhq2kdrc2l7igr";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal filepath gtk2hs-buildtools ];
        libraryHaskellDepends = [
···
        pname = "persistent-spatial";
        version = "0.1.0.0";
        sha256 = "0x9ialzl7mmq3h4nx79z51czddn7xgs0sngixc38cdlmddvm2g36";
+       revision = "1";
+       editedCabalFile = "18qd2k3b6s8nd9v8fqsdf8f8pblm6frm8q8958zi5gs44096cgz8";
        libraryHaskellDepends = [
          aeson base http-api-data integer-logarithms lens persistent text
        ];
···
      }:
      mkDerivation {
        pname = "postgresql-simple-typed";
-       version = "0.1.0.2";
-       sha256 = "12f06lzh2kw27ykwiwgbavj1wbkf4w0xjy6gk2nf4kzm65qvj8az";
+       version = "0.1.1.1";
+       sha256 = "1sfp83xy797zamgyxvcm4jrg3x1jl8f0gzb5c3jsmqbg16rnx0ay";
        libraryHaskellDepends = [
          base postgresql-libpq postgresql-simple template-haskell
          transformers typedquery utf8-string
···
      }:
      mkDerivation {
        pname = "prolog";
-       version = "0.2.1.1";
-       sha256 = "0cl1d4d4jgkqk37q2n3n7xqmd847srd6sqikciz4b8cfp57lw8m7";
+       version = "0.3";
+       sha256 = "02i79irax13rny953k6fvswsgbif9nnvysnnbq3k4w37b3g5maiv";
        libraryHaskellDepends = [
          base containers mtl parsec syb template-haskell th-lift
          transformers
···
        pname = "radius";
        version = "0.6.0.1";
        sha256 = "19c2bv0iq4j0709rf9k9jk5q2s756bvjnr1gy630mcgp92rg8d9j";
+       revision = "1";
+       editedCabalFile = "1a4q1kz21v2m4wfdfaawdlkfnq9s8c5iijzcrdprrgsbi3kplrdi";
        libraryHaskellDepends = [
          base binary bytestring cryptonite iproute memory
        ];
···
     ({ mkDerivation, base, composition-prelude }:
      mkDerivation {
        pname = "recursion";
-       version = "2.2.1.0";
-       sha256 = "0f16lk8apql211gy30vm5l0gjhjlp243cdbrrz6wq47pdlxns5pa";
+       version = "2.2.2.0";
+       sha256 = "1ij7yxh06zb7fjkba2ghq88kvhr1rw4jlc0miwqfl53f6ssvcklf";
        libraryHaskellDepends = [ base composition-prelude ];
        description = "A recursion schemes library for GHC";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "recursion-schemes_5_1_1" = callPackage
+  "recursion-schemes_5_1_1_1" = callPackage
     ({ mkDerivation, base, base-orphans, comonad, free, HUnit
      , template-haskell, th-abstraction, transformers
      }:
      mkDerivation {
        pname = "recursion-schemes";
-       version = "5.1.1";
-       sha256 = "0qw112jkl6jzy3wcyxvv5liv16mxiiqi5v5zyzazl9p8h2wy1rb0";
+       version = "5.1.1.1";
+       sha256 = "0f9f1x1vjdqk6bzgsiqv7z7fq955dlkca3m0l4sc2mnpds3b0cgj";
+       revision = "1";
+       editedCabalFile = "19sqa4v3knasdmfzwmal1pi0yfj3zllrdr6n1chjvy1b6fa5za7z";
        libraryHaskellDepends = [
          base base-orphans comonad free template-haskell th-abstraction
          transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "req_2_0_0" = callPackage
+    ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder
+     , bytestring, case-insensitive, connection, hspec, hspec-core
+     , hspec-discover, http-api-data, http-client, http-client-tls
+     , http-types, monad-control, mtl, QuickCheck, retry, text, time
+     , transformers, transformers-base, unordered-containers
+     }:
+     mkDerivation {
+       pname = "req";
+       version = "2.0.0";
+       sha256 = "0avwvslsb689p9afbh3k0zwmqwkrqagicz26xcyfjsd5648mh3wr";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson authenticate-oauth base blaze-builder bytestring
+         case-insensitive connection http-api-data http-client
+         http-client-tls http-types monad-control mtl retry text time
+         transformers transformers-base
+       ];
+       testHaskellDepends = [
+         aeson base blaze-builder bytestring case-insensitive hspec
+         hspec-core http-client http-types monad-control mtl QuickCheck
+         retry text time unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       doCheck = false;
+       description = "Easy-to-use, type-safe, expandable, high-level HTTP client library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "req-conduit" = callPackage
     ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec
      , http-client, req, resourcet, temporary, transformers, weigh
···
        ];
        description = "Retry combinators for monadic actions that may fail";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "retry_0_8_0_0" = callPackage
+    ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl
+     , random, stm, tasty, tasty-hedgehog, tasty-hunit, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "retry";
+       version = "0.8.0.0";
+       sha256 = "0m44firqn9bkspj2jjf88kksf7mjmbi00xz0855lnflc8b3377cf";
+       libraryHaskellDepends = [
+         base exceptions ghc-prim random transformers
+       ];
+       testHaskellDepends = [
+         base exceptions ghc-prim hedgehog HUnit mtl random stm tasty
+         tasty-hedgehog tasty-hunit time transformers
+       ];
+       description = "Retry combinators for monadic actions that may fail";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "retryer" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "scrapbook" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, data-default, drinkery
+     , extensible, feed, gitrev, req, rio, tasty, tasty-hunit
+     , xml-conduit, xml-types, yaml
+     }:
+     mkDerivation {
+       pname = "scrapbook";
+       version = "0.3.3";
+       sha256 = "17xc7ljfxxwg4l2jiqf8ffwgwq3hq7lynf6p478jp0sxf54irjr1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base data-default extensible feed req rio
+         xml-conduit xml-types yaml
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty base data-default drinkery extensible feed
+         gitrev req rio xml-conduit xml-types yaml
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base data-default extensible feed req rio tasty
+         tasty-hunit xml-conduit xml-types yaml
+       ];
+       description = "Automatically derive Kotlin class to query servant webservices";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "scrape-changes" = callPackage
     ({ mkDerivation, async, attoparsec, base, bytestring, cron
      , directory, email-validate, filepath, hashable, hslogger
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "sendfile_0_7_10" = callPackage
+    ({ mkDerivation, base, bytestring, network }:
+     mkDerivation {
+       pname = "sendfile";
+       version = "0.7.10";
+       sha256 = "1wnfmq64sq13siig0rrnln2bmk1aygnsgdwh5dh32agv9csrk4ab";
+       libraryHaskellDepends = [ base bytestring network ];
+       description = "A portable sendfile library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "sendgrid-haskell" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, exceptions
      , http-conduit, monad-control, text, transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "servant-blaze_0_9" = callPackage
+    ({ mkDerivation, base, blaze-html, http-media, servant
+     , servant-server, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-blaze";
+       version = "0.9";
+       sha256 = "1pfnpc6m7i8knndc1734fbzpfgmvdcpkd8cj0jyw139b70siz63r";
+       libraryHaskellDepends = [ base blaze-html http-media servant ];
+       testHaskellDepends = [ base blaze-html servant-server wai warp ];
+       description = "Blaze-html support for servant";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "servant-cassava" = callPackage
     ({ mkDerivation, base, base-compat, bytestring, cassava, http-media
      , servant, servant-server, vector, wai, warp
···
        testHaskellDepends = [ base lucid servant-server wai warp ];
        description = "Servant support for lucid";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "servant-lucid_0_9" = callPackage
+    ({ mkDerivation, base, http-media, lucid, servant, servant-server
+     , text, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-lucid";
+       version = "0.9";
+       sha256 = "1xamwcijd03cynml5c2hr577qairybyrqd90ixyb1a94lql6agbf";
+       libraryHaskellDepends = [ base http-media lucid servant text ];
+       testHaskellDepends = [ base lucid servant-server wai warp ];
+       description = "Servant support for lucid";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "servant-machines" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "snap-core_1_0_4_0" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
+     , case-insensitive, containers, deepseq, directory, filepath
+     , hashable, HUnit, io-streams, lifted-base, monad-control, mtl
+     , network, network-uri, old-locale, parallel, QuickCheck, random
+     , readable, regex-posix, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text, time, transformers
+     , transformers-base, unix-compat, unordered-containers, vector
+     , zlib
+     }:
+     mkDerivation {
+       pname = "snap-core";
+       version = "1.0.4.0";
+       sha256 = "0dklxgrbqhnb6bc4ic358g4fyj11ywmjrkxxhqcjmci2hhpn00mr";
+       libraryHaskellDepends = [
+         attoparsec base bytestring bytestring-builder case-insensitive
+         containers directory filepath hashable HUnit io-streams lifted-base
+         monad-control mtl network network-uri old-locale random readable
+         regex-posix text time transformers transformers-base unix-compat
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring bytestring-builder case-insensitive
+         containers deepseq directory filepath hashable HUnit io-streams
+         lifted-base monad-control mtl network network-uri old-locale
+         parallel QuickCheck random readable regex-posix test-framework
+         test-framework-hunit test-framework-quickcheck2 text time
+         transformers transformers-base unix-compat unordered-containers
+         vector zlib
+       ];
+       description = "Snap: A Haskell Web Framework (core interfaces and types)";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "snap-cors" = callPackage
     ({ mkDerivation, snap-core }:
      mkDerivation {
···
        ];
        description = "A web server for the Snap Framework";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "snap-server_1_1_1_0" = callPackage
+    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
+     , bytestring, bytestring-builder, case-insensitive, clock
+     , containers, criterion, deepseq, directory, filepath, HsOpenSSL
+     , http-common, http-streams, HUnit, io-streams, io-streams-haproxy
+     , lifted-base, monad-control, mtl, network, old-locale
+     , openssl-streams, parallel, QuickCheck, random, snap-core
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , text, threads, time, transformers, unix, unix-compat, vector
+     }:
+     mkDerivation {
+       pname = "snap-server";
+       version = "1.1.1.0";
+       sha256 = "0kjdsdgpxxsp5r4gpx8wdq5qn1b1y80mgkl9ahjbhlahjf5xyf6k";
+       configureFlags = [ "-fopenssl" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base blaze-builder bytestring bytestring-builder
+         case-insensitive clock containers filepath HsOpenSSL io-streams
+         io-streams-haproxy lifted-base mtl network old-locale
+         openssl-streams snap-core text time unix unix-compat vector
+       ];
+       testHaskellDepends = [
+         attoparsec base base16-bytestring blaze-builder bytestring
+         bytestring-builder case-insensitive clock containers deepseq
+         directory filepath HsOpenSSL http-common http-streams HUnit
+         io-streams io-streams-haproxy lifted-base monad-control mtl network
+         old-locale openssl-streams parallel QuickCheck random snap-core
+         test-framework test-framework-hunit test-framework-quickcheck2 text
+         threads time transformers unix unix-compat vector
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base blaze-builder bytestring bytestring-builder
+         criterion io-streams io-streams-haproxy snap-core vector
+       ];
+       description = "A web server for the Snap Framework";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "snap-stream" = callPackage
···
        pname = "stack";
        version = "1.9.3";
        sha256 = "01lbr9gp3djr5bzlchzb2rdw20855aganmczvq76fzzjyway64cf";
-       revision = "3";
-       editedCabalFile = "0rycd09sk0c269izk35hby179ja77yya41ql7j3hp7s9ja7j6vfg";
+       revision = "4";
+       editedCabalFile = "15mdzgxl82j1yyhxazr4sjr1qpnc83wcf5h4c7lf7iydz60jri79";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
      }:
      mkDerivation {
        pname = "structured-cli";
-       version = "2.5.0.2";
-       sha256 = "0ds6rwzja9yrxq14ip4gxg6km6bzar4dxl5v9m3f3d64zqgm7yi5";
+       version = "2.5.0.3";
+       sha256 = "14kmsh3n4d6zgpqkv1v4laz2sd52317i840szp9mw3i72f012gj0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "swagger2";
        version = "2.3.1";
        sha256 = "0717i4bv97sywbdf94bszh2g858wznvl8q7ngv0zirnlvx8a27y6";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson base base-compat-batteries bytestring containers cookie
+         generics-sop hashable http-media insert-ordered-containers lens mtl
+         network QuickCheck scientific template-haskell text time
+         transformers transformers-compat unordered-containers uuid-types
+         vector
+       ];
+       testHaskellDepends = [
+         aeson base base-compat-batteries bytestring containers doctest Glob
+         hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck
+         quickcheck-instances template-haskell text time
+         unordered-containers utf8-string vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Swagger 2.0 data model";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "swagger2_2_3_1_1" = callPackage
+    ({ mkDerivation, aeson, base, base-compat-batteries, bytestring
+     , Cabal, cabal-doctest, containers, cookie, doctest, generics-sop
+     , Glob, hashable, hspec, hspec-discover, http-media, HUnit
+     , insert-ordered-containers, lens, mtl, network, QuickCheck
+     , quickcheck-instances, scientific, template-haskell, text, time
+     , transformers, transformers-compat, unordered-containers
+     , utf8-string, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "swagger2";
+       version = "2.3.1.1";
+       sha256 = "19fslhjqcnk0da1c8sdflnnxjzbbzqb0nbknpgyd45q0psxr6xs7";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson base base-compat-batteries bytestring containers cookie
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "tasty_1_2_1" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, clock, containers, mtl
+     , optparse-applicative, stm, tagged, unbounded-delays, unix
+     , wcwidth
+     }:
+     mkDerivation {
+       pname = "tasty";
+       version = "1.2.1";
+       sha256 = "0yw8bb92x723md31nisd75mdbfsq9can1h5r4gchdjvwafxy98ia";
+       libraryHaskellDepends = [
+         ansi-terminal async base clock containers mtl optparse-applicative
+         stm tagged unbounded-delays unix wcwidth
+       ];
+       description = "Modern and extensible testing framework";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tasty-ant-xml" = callPackage
     ({ mkDerivation, base, containers, directory, filepath
      , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers
···
      }:
      mkDerivation {
        pname = "teardown";
-       version = "0.5.0.0";
-       sha256 = "0p1rjvl36gl4dqpvcjsb06jyiwsxg2qyha8rfdiddljb4ixw1sjh";
+       version = "0.5.0.1";
+       sha256 = "1ian64cbmw18n75p2jx8d856d3gz5lahvfxy1xbsh1isz56jzh2d";
        libraryHaskellDepends = [
          base prettyprinter rio typed-process unliftio
        ];
···
        pname = "test-framework";
        version = "0.8.2.0";
        sha256 = "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm";
-       revision = "1";
-       editedCabalFile = "1af61pnf2vrkvs3hcqla5ddsrd0hd2pylv6l545yn3dcvl665rcc";
+       revision = "2";
+       editedCabalFile = "1kmv576j1zbms6p3vffripvas87ca3ypdb42h7pqkxsxxfi1gb8j";
        libraryHaskellDepends = [
          ansi-terminal ansi-wl-pprint base containers hostname old-locale
          random regex-posix time xml
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
+  "texmath_0_11_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, pandoc-types, parsec, process, split, syb, temporary, text
+     , utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.11.2";
+       sha256 = "12jkv3wa5lmlik516fp6i429vlznzybhhw4843d55hdid5yhvihf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec syb xml
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath process split temporary text
+         utf8-string xml
+       ];
+       description = "Conversion between formats used to represent mathematics";
+       license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "texrunner" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , HUnit, io-streams, lens, mtl, process, semigroups, temporary
···
        benchmarkHaskellDepends = [ criterion rerebase ];
        description = "An efficient strict text builder";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "text-builder_0_6_5" = callPackage
+    ({ mkDerivation, base, base-prelude, bytestring, criterion
+     , deferred-folds, QuickCheck, quickcheck-instances, rerebase
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "text-builder";
+       version = "0.6.5";
+       sha256 = "1kf5r4cr4qw3awfshycnh9l7p3phssknlvwmkglabmdj3zf1xz5q";
+       libraryHaskellDepends = [
+         base base-prelude bytestring deferred-folds semigroups text
+         transformers
+       ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "An efficient strict text builder";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "text-containers" = callPackage
···
      }:
      mkDerivation {
        pname = "tonatona-google-server-api";
-       version = "0.1.0.0";
-       sha256 = "0mlzw51s4q3q7sf2hbx26g8chmicsv7nchqrq06x6f7ms58aiy27";
+       version = "0.1.1.0";
+       sha256 = "094la1rd8527a398607rsq9z2hiay59biy9fnfiw7qyigwf4zlr0";
        libraryHaskellDepends = [
          base google-server-api monad-logger persistent persistent-sqlite
          resource-pool servant-client tonalude tonaparser tonatona
···
      }:
      mkDerivation {
        pname = "too-many-cells";
-       version = "0.1.1.0";
-       sha256 = "0hilycd6m32jv3gbsq6j182mc3igcxnhsfqzn6sj5zbip0kx17h7";
+       version = "0.1.2.1";
+       sha256 = "08ckcp8gyhq8nhr5l7qbmyl8csz5kl22qmwapwzi4jiffwwi9yca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "transformers_0_5_5_0" = callPackage
+  "transformers_0_5_6_2" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "transformers";
-       version = "0.5.5.0";
-       sha256 = "198ric8gr1y58scckr468d11y2g45mzc5pkaa40shj7xgj1bh7mi";
+       version = "0.5.6.2";
+       sha256 = "0v66j5k0xqk51pmca55wq192qyw2p43s2mgxlz4f95q2c1fpjs5n";
        libraryHaskellDepends = [ base ];
        description = "Concrete functor and monad transformers";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "trim" = callPackage
+    ({ mkDerivation, base, directory, hspec, optparse-applicative }:
+     mkDerivation {
+       pname = "trim";
+       version = "0.1.0.0";
+       sha256 = "0zpn8w4fzswwcb081hvl6cy5gdid69wx3i1gj3sgkxf01347m23m";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       executableHaskellDepends = [ base directory optparse-applicative ];
+       testHaskellDepends = [ base hspec ];
+       description = "A command-line tool for trimming whitespace";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "trimpolya" = callPackage
     ({ mkDerivation, base, bio, bytestring, simpleargs }:
      mkDerivation {
···
        pname = "ttl-hashtables";
        version = "1.3.0.0";
        sha256 = "1qlwwxylj9d2p4jm4bi0a3x60cfzd6g982v6q0crs323zn8q5cj5";
+       revision = "1";
+       editedCabalFile = "0nbf825s51pls4y0nc9jzik8z6szfvqd66dfjp6ybbywrrdzckf3";
        libraryHaskellDepends = [
          base clock containers data-default failable hashable hashtables mtl
          transformers
···
      }:
      mkDerivation {
        pname = "typedquery";
-       version = "0.1.1.1";
-       sha256 = "1p6hlx2hsp7sjhspw3c95b1px6r2hylr31f4hcjq505z3i33gm7m";
+       version = "0.1.1.2";
+       sha256 = "1ziyc4bjxfndmfpmg8j2dl80nq1a9ay9nfpxh5856yar63lw16fi";
        libraryHaskellDepends = [
          aeson base bytestring haskell-src-meta parsec template-haskell text
          transformers
···
      }:
      mkDerivation {
        pname = "vt-utils";
-       version = "1.1.0.0";
-       sha256 = "1xqcffipp5hwvmiqxg80zj3v4nzqklqcpy3kblfkw4xkvg57gh87";
+       version = "1.2.0.0";
+       sha256 = "1mbc4a8s6h3f5w3da2ln95050c1ssnh7pyj4i34nvmm5gqrb3jb9";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring case-insensitive directory
          http-client http-types HUnit parsec process text time transformers
···
     ({ mkDerivation, base, Cabal, gtk2hs-buildtools, webkitgtk }:
      mkDerivation {
        pname = "webkit2gtk3-javascriptcore";
-       version = "0.14.2.1";
-       sha256 = "1y22whxgyjkhmh4nxgkxfzwk3nkkbnrx70qn5h57fv7r2c012jxj";
+       version = "0.14.3.0";
+       sha256 = "1gsa7lvv0xidy4i9d8bjqc0hpbzx1vvp9npzj2q8x1l68f9vjj5j";
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [ base ];
        libraryPkgconfigDepends = [ webkitgtk ];
···
        doCheck = false;
        description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "websockets_0_12_5_3" = callPackage
+    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
+     , bytestring, bytestring-builder, case-insensitive, containers
+     , criterion, entropy, HUnit, network, QuickCheck, random, SHA
+     , streaming-commons, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text
+     }:
+     mkDerivation {
+       pname = "websockets";
+       version = "0.12.5.3";
+       sha256 = "0mkxl7iwl5pl2w0svji9248v4c0hi45k725jj5ybaknb73650ns4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base base64-bytestring binary bytestring
+         bytestring-builder case-insensitive containers entropy network
+         random SHA streaming-commons text
+       ];
+       testHaskellDepends = [
+         attoparsec base base64-bytestring binary bytestring
+         bytestring-builder case-insensitive containers entropy HUnit
+         network QuickCheck random SHA streaming-commons test-framework
+         test-framework-hunit test-framework-quickcheck2 text
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base base64-bytestring binary bytestring
+         bytestring-builder case-insensitive containers criterion entropy
+         network random SHA text
+       ];
+       doCheck = false;
+       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "websockets-rpc" = callPackage
···
        testHaskellDepends = [ base bytestring ghc-prim hedgehog ];
        description = "Data types for large but fixed width signed and unsigned integers";
        license = stdenv.lib.licenses.bsd2;
+     }) {};
+
+  "wide-word_0_1_0_8" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, hedgehog
+     , primitive, QuickCheck, quickcheck-classes, semirings
+     }:
+     mkDerivation {
+       pname = "wide-word";
+       version = "0.1.0.8";
+       sha256 = "1n6g9kn7k8gi2qi8fbik5pi2yj5mbzzj62512as1gjysv3y3l2dj";
+       libraryHaskellDepends = [ base deepseq primitive ];
+       testHaskellDepends = [
+         base bytestring ghc-prim hedgehog QuickCheck quickcheck-classes
+         semirings
+       ];
+       description = "Data types for large but fixed width signed and unsigned integers";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "wigner-symbols" = callPackage
···
      }:
      mkDerivation {
        pname = "wolf";
-       version = "0.3.45";
-       sha256 = "0l3jp2qqscy2fq5fvaq83hsh68f1d5xg97k2dhyc01zc6fd5jqi8";
+       version = "0.3.46";
+       sha256 = "1d0i1611458dpqih73x8gcxq7lkwpxdc1c3pgj3hqb6gwjhjnxyj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "xml";
        version = "1.3.14";
        sha256 = "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j";
+       revision = "1";
+       editedCabalFile = "130xwqmgmg9vp988mppm5ivz1r5qbivb270fz2rwl4q0x04czdzd";
        libraryHaskellDepends = [ base bytestring text ];
        description = "A simple XML library";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "yesod-content-pdf";
-       version = "0.2.0.3";
-       sha256 = "0c1jh0rcbbdh0ld9j2pq79pifs30gadz4p10xmphz9s68bjp8n4c";
+       version = "0.2.0.4";
+       sha256 = "1n51prhxbbjrkvnvf2v4nk6vs8zxvwrnb1826r2vkhq0j1pyyi2k";
        libraryHaskellDepends = [
          base blaze-builder blaze-html bytestring conduit data-default
          directory network-uri process temporary transformers yesod-core
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "yesod-core_1_6_11" = callPackage
+    ({ mkDerivation, aeson, async, auto-update, base, blaze-html
+     , blaze-markup, byteable, bytestring, case-insensitive, cereal
+     , clientsession, conduit, conduit-extra, containers, cookie
+     , deepseq, fast-logger, gauge, hspec, hspec-expectations
+     , http-types, HUnit, monad-logger, mtl, network, parsec
+     , path-pieces, primitive, random, resourcet, rio, shakespeare
+     , streaming-commons, template-haskell, text, time, transformers
+     , unix-compat, unliftio, unordered-containers, vector, wai
+     , wai-extra, wai-logger, warp, word8
+     }:
+     mkDerivation {
+       pname = "yesod-core";
+       version = "1.6.11";
+       sha256 = "1cpl8g2sdvv751vvs68169w9nki43h6rmj2i2wqkfzijwgd8djwr";
+       libraryHaskellDepends = [
+         aeson auto-update base blaze-html blaze-markup byteable bytestring
+         case-insensitive cereal clientsession conduit conduit-extra
+         containers cookie deepseq fast-logger http-types monad-logger mtl
+         parsec path-pieces primitive random resourcet rio shakespeare
+         template-haskell text time transformers unix-compat unliftio
+         unordered-containers vector wai wai-extra wai-logger warp word8
+       ];
+       testHaskellDepends = [
+         async base bytestring clientsession conduit conduit-extra
+         containers cookie hspec hspec-expectations http-types HUnit network
+         path-pieces random resourcet shakespeare streaming-commons
+         template-haskell text transformers unliftio wai wai-extra warp
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-html bytestring gauge shakespeare text
+       ];
+       description = "Creation of type-safe, RESTful web applications";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-crud" = callPackage

pkgs/development/haskell-modules/patches/beam-core-fix-ghc-8.6.x-build.patch

···
+diff --git a/beam-core/Database/Beam/Backend/SQL.hs b/beam-core/Database/Beam/Backend/SQL.hs
+index e2cd37d0..6f9db126 100644
+--- a/Database/Beam/Backend/SQL.hs
++++ b/Database/Beam/Backend/SQL.hs
+@@ -10,6 +10,7 @@
+ import Database.Beam.Backend.Types
+ 
+ import Control.Monad.IO.Class
++import Control.Monad.Fail (MonadFail)
+ 
+ -- * MonadBeam class
+ 
+@@ -29,7 +30,7 @@
+ --   strategies. More complicated strategies (for example, Postgres's @COPY@)
+ --   are supported in individual backends. See the documentation of those
+ --   backends for more details.
+-class (BeamBackend be, Monad m, MonadIO m, Sql92SanityCheck syntax) =>
++class (BeamBackend be, Monad m, MonadIO m, MonadFail m, Sql92SanityCheck syntax) =>
+   MonadBeam syntax be handle m | m -> syntax be handle where
+ 
+   {-# MINIMAL withDatabaseDebug, runReturningMany #-}
+diff --git a/Database/Beam/Backend/SQL/Builder.hs b/Database/Beam/Backend/SQL/Builder.hs
+index 9e734036..e9849912 100644
+--- a/Database/Beam/Backend/SQL/Builder.hs
++++ b/Database/Beam/Backend/SQL/Builder.hs
+@@ -33,6 +33,7 @@
+ import           Data.Hashable
+ import           Data.Int
+ import           Data.String
++import qualified Control.Monad.Fail as Fail
+ #if !MIN_VERSION_base(4, 11, 0)
+ import           Data.Semigroup
+ #endif
+@@ -507,8 +508,10 @@
+   type BackendFromField SqlSyntaxBackend = Trivial
+ 
+ newtype SqlSyntaxM a = SqlSyntaxM (IO a)
+-  deriving (Applicative, Functor, Monad, MonadIO)
++  deriving (Applicative, Functor, Monad, MonadIO, Fail.MonadFail)
+ 
+ instance MonadBeam SqlSyntaxBuilder SqlSyntaxBackend SqlSyntaxBackend SqlSyntaxM where
+-  withDatabaseDebug _ _ _ = fail "absurd"
+-  runReturningMany _ _ = fail "absurd"
++  withDatabaseDebug _ _ _ = Fail.fail "absurd"
++  runReturningMany _ _ = Fail.fail "absurd"
++
++
+diff --git a/Database/Beam/Schema/Lenses.hs b/Database/Beam/Schema/Lenses.hs
+index b21dddb6..5df0654c 100644
+--- a/Database/Beam/Schema/Lenses.hs
++++ b/Database/Beam/Schema/Lenses.hs
+@@ -1,4 +1,5 @@
+ {-# LANGUAGE PolyKinds #-}
++{-# LANGUAGE UndecidableInstances #-}
+ module Database.Beam.Schema.Lenses
+     ( tableLenses
+     , TableLens(..)
+diff --git a/beam-core.cabal b/beam-core.cabal
+index 4bf4ffd9..251d4d85 100644
+--- a/beam-core.cabal
++++ b/beam-core.cabal
+@@ -64,8 +64,8 @@
+                        time         >=1.6     && <1.10,
+                        hashable     >=1.1     && <1.3,
+                        network-uri  >=2.6     && <2.7,
+-                       containers   >=0.5     && <0.6,
+-                       vector-sized >=0.5     && <1.1,
++                       containers   >=0.5     && <0.7,
++                       vector-sized >=0.5     && <1.3,
+                        tagged       >=0.8     && <0.9
+   Default-language:    Haskell2010
+   default-extensions:  ScopedTypeVariables, OverloadedStrings, GADTs, RecursiveDo, FlexibleInstances, FlexibleContexts, TypeFamilies,

pkgs/development/haskell-modules/patches/beam-migrate-fix-ghc-8.6.x-build.patch

···
+diff --git a/Database/Beam/Migrate/Generics/Types.hs b/Database/Beam/Migrate/Generics/Types.hs
+index 553e208b..0cf9b2c8 100644
+--- a/Database/Beam/Migrate/Generics/Types.hs
++++ b/Database/Beam/Migrate/Generics/Types.hs
+@@ -1,3 +1,5 @@
++{-# LANGUAGE UndecidableInstances #-}
++
+ module Database.Beam.Migrate.Generics.Types where
+ 
+ import           Database.Beam.Migrate.Types
+diff --git a/beam-migrate.cabal b/beam-migrate.cabal
+index f53b280d..9cf3722c 100644
+--- a/beam-migrate.cabal
++++ b/beam-migrate.cabal
+@@ -69,13 +69,12 @@ library
+                        mtl                  >=2.2     && <2.3,
+                        scientific           >=0.3     && <0.4,
+                        vector               >=0.11    && <0.13,
+-                       containers           >=0.5     && <0.6,
+                        unordered-containers >=0.2     && <0.3,
+                        hashable             >=1.2     && <1.3,
+                        parallel             >=3.2     && <3.3,
+                        deepseq              >=1.4     && <1.5,
+                        ghc-prim             >=0.5     && <0.6,
+-                       containers           >=0.5     && <0.6,
++                       containers           >=0.5     && <0.7,
+                        haskell-src-exts     >=1.18    && <1.21,
+                        pretty               >=1.1     && <1.2,
+                        dependent-map        >=0.2     && <0.3,

pkgs/development/haskell-modules/patches/beam-postgres-fix-ghc-8.6.x-build.patch

···
+diff --git a/Database/Beam/Postgres/Connection.hs b/Database/Beam/Postgres/Connection.hs
+index 433f55b9..5836c53d 100644
+--- a/Database/Beam/Postgres/Connection.hs
++++ b/Database/Beam/Postgres/Connection.hs
+@@ -52,6 +52,8 @@ import qualified Database.PostgreSQL.Simple.Types as Pg (Null(..), Query(..))
+ 
+ import           Control.Monad.Reader
+ import           Control.Monad.State
++import           Control.Monad.Fail (MonadFail)
++import qualified Control.Monad.Fail as Fail
+ 
+ import           Data.ByteString (ByteString)
+ import           Data.ByteString.Builder (toLazyByteString, byteString)
+@@ -302,6 +304,9 @@ deriving instance Functor PgF
+ newtype Pg a = Pg { runPg :: F PgF a }
+     deriving (Monad, Applicative, Functor, MonadFree PgF)
+ 
++instance MonadFail Pg where
++    fail e = fail $ "Internal Error with: " <> show e
++
+ instance MonadIO Pg where
+     liftIO x = liftF (PgLiftIO x id)
+ 
+diff --git a/beam-postgres.cabal b/beam-postgres.cabal
+index e14b84f5..d29a5b67 100644
+--- a/beam-postgres.cabal
++++ b/beam-postgres.cabal
+@@ -31,7 +31,7 @@ library
+                       beam-migrate         >=0.3  && <0.4,
+ 
+                       postgresql-libpq     >=0.8  && <0.10,
+-                      postgresql-simple    >=0.5  && <0.6,
++                      postgresql-simple    >=0.5  && <0.7,
+ 
+                       text                 >=1.0  && <1.3,
+                       bytestring           >=0.10 && <0.11,
+@@ -38,7 +38,7 @@ library
+ 
+                       hashable             >=1.1  && <1.3,
+                       lifted-base          >=0.2  && <0.3,
+-                      free                 >=4.12 && <5.1,
++                      free                 >=4.12 && <5.2,
+                       time                 >=1.6  && <1.10,
+                       monad-control        >=1.0  && <1.1,
+                       mtl                  >=2.1  && <2.3,

pkgs/development/haskell-modules/patches/beam-sqlite-fix-ghc-8.6.x-build.patch

···
+diff --git a/Database/Beam/Sqlite/Connection.hs b/Database/Beam/Sqlite/Connection.hs
+index f034b272..4e459ea3 100644
+--- a/Database/Beam/Sqlite/Connection.hs
++++ b/Database/Beam/Sqlite/Connection.hs
+@@ -37,6 +37,7 @@ import           Database.SQLite.Simple.Types (Null)
+ 
+ import           Control.Exception (bracket_, onException, mask)
+ import           Control.Monad (forM_, replicateM_)
++import           Control.Monad.Fail (MonadFail)
+ import           Control.Monad.Free.Church
+ import           Control.Monad.IO.Class (MonadIO(..))
+ import           Control.Monad.Identity (Identity)
+@@ -143,7 +144,7 @@ newtype SqliteM a
+   { runSqliteM :: ReaderT (String -> IO (), Connection) IO a
+     -- ^ Run an IO action with access to a SQLite connection and a debug logging
+     -- function, called or each query submitted on the connection.
+-  } deriving (Monad, Functor, Applicative, MonadIO)
++  } deriving (Monad, Functor, Applicative, MonadIO, MonadFail)
+ 
+ newtype BeamSqliteParams = BeamSqliteParams [SQLData]
+ instance ToRow BeamSqliteParams where

pkgs/development/interpreters/racket/default.nix

···
     license = licenses.lgpl3;
     maintainers = with maintainers; [ kkallio henrytill vrthra ];
     platforms = [ "x86_64-darwin" "x86_64-linux" ];
+    broken = stdenv.isDarwin; # No support yet for setting FFI lookup path
   };
 }

pkgs/development/interpreters/racket/minimal.nix

···
       and the pkg library are still bundled.
     '';
     platforms = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" ];
+    broken = false; # Minimal build does not require working FFI
   };
 })

pkgs/development/libraries/ftgl/default.nix

···
-{stdenv, fetchurl, freetype, libGLU_combined}:
+{ stdenv, fetchurl, freetype, libGLU_combined, OpenGL }:
 
 let
   name = "ftgl-2.1.3-rc5";
···
     sha256 = "0nsn4s6vnv5xcgxcw6q031amvh2zfj2smy1r5mbnjj2548hxcn2l";
   };
 
-  buildInputs = [ freetype libGLU_combined ];
+  buildInputs = [ freetype ]
+    ++ (if stdenv.isDarwin then
+      [ OpenGL ]
+    else
+      [ libGLU_combined ])
+    ;
 
   enableParallelBuilding = true;
 

pkgs/development/libraries/zeitgeist/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "1.0.1";
-  name = "zeitgeist-${version}";
+  pname = "zeitgeist";
+  version = "1.0.2";
 
   outputs = [ "out" "lib" "dev" "man" ] ++ stdenv.lib.optional pythonSupport "py";
 
   src = fetchFromGitLab {
     domain = "gitlab.freedesktop.org";
-    owner = "zeitgeist";
-    repo = "zeitgeist";
+    owner = pname;
+    repo = pname;
     rev = "v${version}";
-    sha256 = "1lgqcqr5h9ba751b7ajp7h2w1bb5qza2w3k1f95j3ab15p7q0q44";
+    sha256 = "0ig3d3j1n0ghaxsgfww6g2hhcdwx8cljwwfmp9jk1nrvkxd6rnmv";
   };
 
   preConfigure = "NOCONFIGURE=1 ./autogen.sh";
 
-  configureFlags = [ "--with-session-bus-services-dir=$(out)/share/dbus-1/services" ];
+  configureFlags = [ "--with-session-bus-services-dir=${placeholder ''out''}/share/dbus-1/services" ];
 
   nativeBuildInputs = [
     autoconf automake libtool pkgconfig gettext gobject-introspection vala python2Packages.python
···
 
   meta = with stdenv.lib; {
     description = "A service which logs the users's activities and events";
-    homepage = http://zeitgeist.freedesktop.org/;
-    maintainers = with maintainers; [ lethalman ];
+    homepage = https://zeitgeist.freedesktop.org/;
+    maintainers = with maintainers; [ lethalman worldofpeace ];
     license = licenses.gpl2;
     platforms = platforms.linux;
   };

pkgs/development/python-modules/filetype/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, python
+}:
+
+buildPythonPackage rec {
+  pname = "filetype";
+  version = "1.0.2";
+
+  # No tests in PyPI tarball
+  # See https://github.com/h2non/filetype.py/pull/33
+  src = fetchFromGitHub {
+    owner = "h2non";
+    repo = "filetype.py";
+    rev = "v${version}";
+    sha256 = "000gl3q2cadfnmqnbxg31ppc3ak8blzb4nfn75faxbp7b6r5qgr2";
+  };
+
+  checkPhase = ''
+    ${python.interpreter} -m unittest discover
+  '';
+
+  meta = with lib; {
+    description = "Infer file type and MIME type of any file/buffer";
+    homepage = https://github.com/h2non/filetype.py;
+    license = licenses.mit;
+    maintainers = with maintainers; [ dotlambda ];
+  };
+}

pkgs/development/python-modules/grammalecte/default.nix

···
 
 buildPythonPackage rec {
   pname = "grammalecte";
-  version = "0.6.1";
+  version = "0.6.5";
 
   src = fetchurl {
     url = "http://www.dicollecte.org/grammalecte/zip/Grammalecte-fr-v${version}.zip";
-    sha256 = "0y2ck6pkd2p3cbjlxxvz3x5rnbg3ghfx97n13302rnab66cy4zkh";
+    sha256 = "11byjs3ggdhia5f4vyfqfvbbczsfqimll98h98g7hlsrm7vrifb0";
   };
 
   propagatedBuildInputs = [ bottle ];
 
   preBuild = "cd ..";
-  postInstall = ''
-    rm $out/bin/bottle.py
-  '';
 
   disabled = !isPy3k;
 
   meta = {
     description = "Grammalecte is an open source grammar checker for the French language";
-    homepage = https://dicollecte.org/grammalecte/;
+    homepage = https://grammalecte.net;
     license = with lib.licenses; [ gpl3 ];
     maintainers = with lib.maintainers; [ apeyroux ];
   };

pkgs/development/python-modules/isbnlib/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, nose
+, coverage
+}:
+
+buildPythonPackage rec {
+  pname = "isbnlib";
+  version = "3.9.4";
+
+  # PyPI tarball is missing LICENSE file
+  # See https://github.com/xlcnd/isbnlib/pull/53
+  src = fetchFromGitHub {
+    owner = "xlcnd";
+    repo = "isbnlib";
+    rev = "v${version}";
+    sha256 = "0gc0k5khf34b4zz56a9zc3rscdhj3bx849lbzgmzpji30sbyy1fh";
+  };
+
+  checkInputs = [
+    nose
+    coverage
+  ];
+
+  # requires network connection
+  doCheck = false;
+
+  meta = with lib; {
+    description = "Extract, clean, transform, hyphenate and metadata for ISBNs";
+    homepage = https://github.com/xlcnd/isbnlib;
+    license = licenses.lgpl3;
+    maintainers = with maintainers; [ dotlambda ];
+  };
+}

pkgs/development/python-modules/keras-preprocessing/default.nix

···
-{ lib, buildPythonPackage, fetchPypi, numpy, scipy, six }:
+{ lib, buildPythonPackage, fetchPypi, numpy, six, scipy, pillow, pytest, Keras }:
 
 buildPythonPackage rec {
   pname = "Keras_Preprocessing";
-  version = "1.0.5";
+  version = "1.0.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ef2e482c4336fcf7180244d06f4374939099daa3183816e82aee7755af35b754";
+    sha256 = "6e669aa713727f0bc08f756616f64e0dfa75d822226cfc0dcf33297ab05cef7d";
   };
 
-  # Cyclic dependency: keras-preprocessing requires keras, which requires keras-preprocessing
-  postPatch = ''
-    sed -i "s/keras>=[^']*//" setup.py
+  propagatedBuildInputs = [
+    # required
+    numpy six
+    # optional
+    scipy pillow
+  ];
+
+  checkInputs = [
+    pytest Keras
+  ];
+
+  checkPhase = ''
+    py.test tests/
   '';
 
-  # No tests in PyPI tarball
+  # Cyclic dependency: keras-preprocessing's tests require Keras, which requires keras-preprocessing
   doCheck = false;
-
-  propagatedBuildInputs = [ numpy scipy six ];
 
   meta = with lib; {
     description = "Easy data preprocessing and data augmentation for deep learning models";

pkgs/development/python-modules/keras/default.nix

···
     keras-applications keras-preprocessing
   ];
 
-  # Keras 2.2.2 expects older versions of keras_applications
-  # and keras_preprocessing. These substitutions can be removed
-  # for for the next Keras release.
-  postPatch = ''
-    substituteInPlace setup.py --replace "keras_applications==1.0.4" "keras_applications==1.0.5"
-    substituteInPlace setup.py --replace "keras_preprocessing==1.0.2" "keras_preprocessing==1.0.3"
-  '';
-
   # Couldn't get tests working
   doCheck = false;
 

pkgs/development/python-modules/keyutils/default.nix

···
 
 buildPythonPackage rec {
   pname = "keyutils";
-  version = "0.5";
+  version = "0.6";
 
   # github version comes bundled with tests
   src = fetchFromGitHub {
     owner = "sassoftware";
     repo = "python-keyutils";
-    rev = "v${version}";
-    sha256 = "1gga60w8sb3r5bxa0bfp7d7wzg6s3db5y7aizr14p2pvp92d8bdi";
+    rev = version;
+    sha256 = "0pfqfr5xqgsqkxzrmj8xl2glyl4nbq0irs0k6ik7iy3gd3mxf5g1";
   };
 
   buildInputs = [ keyutils ];

pkgs/development/tools/analysis/checkstyle/default.nix

···
 { stdenv, fetchurl, makeWrapper, jre }:
 
 stdenv.mkDerivation rec {
-  version = "8.16";
+  version = "8.17";
   name = "checkstyle-${version}";
 
   src = fetchurl {
     url = "https://github.com/checkstyle/checkstyle/releases/download/checkstyle-${version}/checkstyle-${version}-all.jar";
-    sha256 = "1044imm1pmn4fb0bzg4k44qm1hwwsyf7l7lbnlrznbln7ymdy5ki";
+    sha256 = "10i285kzbma9pny0vlm8wglxsbqliqrhig6n9rj2nv13x5i53ifj";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/tools/build-managers/mill/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mill-${version}";
-  version = "0.3.5";
+  version = "0.3.6";
 
   src = fetchurl {
     url = "https://github.com/lihaoyi/mill/releases/download/${version}/${version}";
-    sha256 = "19ka81f6vjr85gd8cadn0fv0i0qcdspx2skslfksklxdxs2gasf8";
+    sha256 = "1dal08l96a5w8g27vxpsykbwcpfbna4prxqvqk89n0y9jn9s44l1";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/tools/coursier/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "coursier-${version}";
-  version = "1.0.1";
+  version = "1.1.0-M10";
 
   src = fetchurl {
     url = "https://github.com/coursier/coursier/raw/v${version}/coursier";
-    sha256 = "1rn1vb33zfl9iy80fhqvi9ykdjxz029nah5yfr5xixcx9al0bai3";
+    sha256 = "14iq0717vdm0mj0196idc724vmxp1y0f3gfn41sbqahfhvcx05y8";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/tools/pyre/default.nix

···
 let
   # Manually set version - the setup script requires
   # hg and git + keeping the .git directory around.
-  pyre-version = "0.0.18";  # also change typeshed revision below with $pyre-src/.typeshed-version
+  pyre-version = "0.0.20";  # also change typeshed revision below with $pyre-src/.typeshed-version
   pyre-src = fetchFromGitHub {
     owner = "facebook";
     repo = "pyre-check";
     rev = "v${pyre-version}";
-    sha256 = "1sy1lk9j3hq20dabfkr9s4r7prrcndrs345a5iqz6yzvakr4r74d";
+    sha256 = "1alkhdhvmigdhxvvarh0lr5s3b1s6q4arykip2dqb62vs8064s17";
   };
   versionFile = writeScript "version.ml" ''
     cat > "./version.ml" <<EOF
···
   src = fetchFromGitHub {
     owner = "python";
     repo = "typeshed";
-    rev = "bc3f9fe1d3c43b00c04cedb23e0eeebc9e1734b6";
-    sha256 = "06b2kj4n49h4sgi8hn5kalmir8llhanfdc7f1924cxvrkj5ry94b";
+    rev = "0b49ce75b478fdf283dda5dd1368759ac342dfe2";
+    sha256 = "1w5aqbbcfk5ki8n9fgdikkyadjb318ipqyi517s9xnwlzi1jv0fh";
   };
   phases = [ "unpackPhase" "installPhase" ];
   installPhase = "cp -r $src $out";

pkgs/servers/nosql/neo4j/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "neo4j-${version}";
-  version = "3.4.10";
+  version = "3.5.2";
 
   src = fetchurl {
     url = "https://neo4j.com/artifact.php?name=neo4j-community-${version}-unix.tar.gz";
-    sha256 = "0wxcwsnnwk08w3zaz67aa93ysrl61lsy41xynq1sy6z31a7gx9jr";
+    sha256 = "0i36vgs6b24bdhckgkhw23g59x1f2zg6h07c73jv55sdmxmcdpn1";
   };
 
   buildInputs = [ makeWrapper jre8 which gawk ];
+
 
   installPhase = ''
     mkdir -p "$out/share/neo4j"
     cp -R * "$out/share/neo4j"
 
     mkdir -p "$out/bin"
-    for NEO4J_SCRIPT in neo4j neo4j-admin neo4j-import neo4j-shell cypher-shell
+    for NEO4J_SCRIPT in neo4j neo4j-admin neo4j-import cypher-shell
     do
         makeWrapper "$out/share/neo4j/bin/$NEO4J_SCRIPT" \
             "$out/bin/$NEO4J_SCRIPT" \

pkgs/servers/sip/freeswitch/default.nix

···
-{ fetchurl, stdenv, ncurses, curl, pkgconfig, gnutls, readline
+{ fetchurl, stdenv, lib, ncurses, curl, pkgconfig, gnutls, readline
 , openssl, perl, sqlite, libjpeg, speex, pcre
 , ldns, libedit, yasm, which, lua, libopus, libsndfile
+
+, postgresql
+, enablePostgres ? true
 
 , SystemConfiguration
 }:
···
     openssl ncurses curl gnutls readline perl libjpeg
     sqlite pcre speex ldns libedit yasm which lua libopus
     libsndfile
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ SystemConfiguration ];
+  ]
+  ++ lib.optionals enablePostgres [ postgresql ]
+  ++ lib.optionals stdenv.isDarwin [ SystemConfiguration ];
 
   NIX_CFLAGS_COMPILE = "-Wno-error";
 
   hardeningDisable = [ "format" ];
+
+  configureFlags = lib.optionals enablePostgres [ "--enable-core-pgsql-support" ];
 
   meta = {
     description = "Cross-Platform Scalable FREE Multi-Protocol Soft Switch";

pkgs/servers/sql/postgresql/ext/pg_topn.nix

···
-{ stdenv, fetchFromGitHub, postgresql, protobufc }:
+{ stdenv, fetchFromGitHub, postgresql }:
 
 stdenv.mkDerivation rec {
   name = "pg_topn-${version}";
-  version = "2.2.0";
+  version = "2.2.2";
 
-  nativeBuildInputs = [ protobufc ];
   buildInputs = [ postgresql ];
 
   src = fetchFromGitHub {
     owner  = "citusdata";
     repo   = "postgresql-topn";
     rev    = "refs/tags/v${version}";
-    sha256 = "1i5fn517mdvzfhlcj7fh4z0iniynanshcn7kzhsq19sgci0g31fr";
+    sha256 = "1bh28nrxj06vc2cvlsxlwrwad5ff3lfj3kr5cnnggwjk2dhwbbjm";
   };
 
   installPhase = ''
···
 
   meta = with stdenv.lib; {
     description = "Efficient querying of 'top values' for PostgreSQL";
-    homepage    = https://www.citusdata.com/;
+    homepage    = https://github.com/citusdata/postgresql-topn;
     maintainers = with maintainers; [ thoughtpolice ];
     platforms   = platforms.linux;
     license     = licenses.agpl3;

pkgs/tools/graphics/oxipng/default.nix

···
 { stdenv, fetchFromGitHub, rustPlatform }:
 
 rustPlatform.buildRustPackage rec {
-  version = "2.1.8";
+  version = "2.2.0";
   name = "oxipng-${version}";
 
   src = fetchFromGitHub {
     owner = "shssoichiro";
     repo = "oxipng";
     rev = "v${version}";
-    sha256 = "18ld65vm58s6x918g6bhfkrg7lw2lca8daidv88ff14wm5khjvik";
+    sha256 = "00ys1dy8r1g84j04w50qcjas0qnfw4vphazvbfasd9q2b1p5z69l";
   };
 
-  cargoSha256 = "034i8hgi0zgv085bimlja1hl3nd096rqpi167pw6rda5aj18c625";
+  cargoSha256 = "125r3jmgwcq8qddm8hjpyzaam96kkifaxixksyaw2iqk9xq0nrpm";
+
+  # https://crates.io/crates/cloudflare-zlib#arm-vs-nightly-rust
+  cargoBuildFlags = [ "--features=cloudflare-zlib/arm-always" ];
 
   meta = with stdenv.lib; {
     homepage = https://github.com/shssoichiro/oxipng;
···
     license = licenses.mit;
     maintainers = with maintainers; [ dywedir ];
     platforms = platforms.all;
-
-    # Needs newer/unstable rust: error[E0658]: macro is_arm_feature_detected! is unstable
-    broken = stdenv.isAarch64;
   };
 }

pkgs/tools/graphics/pfstools/default.nix

···
 { stdenv, fetchurl, cmake, pkgconfig
 , openexr, zlib, imagemagick, libGLU_combined, freeglut, fftwFloat
-, fftw, gsl, libexif, perl, opencv, qt4
+, fftw, gsl, libexif, perl, opencv, qt5
 }:
 
 stdenv.mkDerivation rec {
···
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [
     openexr zlib imagemagick libGLU_combined freeglut fftwFloat
-    fftw gsl libexif perl opencv qt4
+    fftw gsl libexif perl opencv qt5.qtbase
   ];
 
   patches = [ ./threads.patch ./pfstools.patch ];

pkgs/tools/misc/moreutils/default.nix

···
   buildFlags = "CC=cc";
   installFlags = "PREFIX=$(out)";
 
-  postInstall = "wrapProgram $out/bin/chronic --prefix PERL5LIB : $PERL5LIB";
+  postInstall = ''
+    wrapProgram $out/bin/chronic --prefix PERL5LIB : $PERL5LIB
+    wrapProgram $out/bin/ts --prefix PERL5LIB : $PERL5LIB
+  '';
 
   meta = {
     description = "Growing collection of the unix tools that nobody thought to write long ago when unix was young";

pkgs/tools/misc/ostree/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, pkgconfig, gtk-doc, gobject-introspection, gnome3
+{ stdenv, fetchurl, fetchpatch, pkgconfig, gtk-doc, gobject-introspection, gnome3
 , glib, systemd, xz, e2fsprogs, libsoup, gpgme, which, autoconf, automake, libtool, fuse, utillinuxMinimal, libselinux
 , libarchive, libcap, bzip2, yacc, libxslt, docbook_xsl, docbook_xml_dtd_42, python3
 }:
 
-let
-  version = "2018.9";
-
-  libglnx-src = fetchFromGitHub {
-    owner = "GNOME";
-    repo = "libglnx";
-    rev = "470af8763ff7b99bec950a6ae0a957c1dcfc8edd";
-    sha256 = "1fwik38i6w3r6pn4qkizradcqp1m83n7ljh9jg0y3p3kvrbfxh15";
-  };
-
-  bsdiff-src = fetchFromGitHub {
-    owner = "mendsley";
-    repo = "bsdiff";
-    rev = "1edf9f656850c0c64dae260960fabd8249ea9c60";
-    sha256 = "1h71d2h2d3anp4msvpaff445rnzdxii3id2yglqk7af9i43kdsn1";
-  };
-in stdenv.mkDerivation {
-  name = "ostree-${version}";
+stdenv.mkDerivation rec {
+  pname = "ostree";
+  version = "2019.1";
 
   outputs = [ "out" "dev" "man" "installedTests" ];
 
-  src = fetchFromGitHub {
-    rev = "v${version}";
-    owner = "ostreedev";
-    repo = "ostree";
-    sha256 = "0a8gr4qqxcvz3fqv9w4dxy6iq0rq4kdzf08rzv8xg4gic3ldgyvj";
+  src = fetchurl {
+    url = "https://github.com/ostreedev/ostree/releases/download/v${version}/libostree-${version}.tar.xz";
+    sha256 = "08y7nsxl305dnlfak4kyj88lld848y4kg6bvjqngcxaqqvkk9xqm";
   };
 
   patches = [
···
     (python3.withPackages (p: with p; [ pyyaml ])) gnome3.gjs # for tests
   ];
 
-  prePatch = ''
-    rmdir libglnx bsdiff
-    cp --no-preserve=mode -r ${libglnx-src} libglnx
-    cp --no-preserve=mode -r ${bsdiff-src} bsdiff
-  '';
-
-
   preConfigure = ''
     env NOCONFIGURE=1 ./autogen.sh
   '';
···
   enableParallelBuilding = true;
 
   configureFlags = [
-    "--with-systemdsystemunitdir=$(out)/lib/systemd/system"
-    "--with-systemdsystemgeneratordir=$(out)/lib/systemd/system-generators"
+    "--with-systemdsystemunitdir=${placeholder "out"}/lib/systemd/system"
+    "--with-systemdsystemgeneratordir=${placeholder "out"}/lib/systemd/system-generators"
     "--enable-installed-tests"
   ];
 
   makeFlags = [
-    "installed_testdir=$(installedTests)/libexec/installed-tests/libostree"
-    "installed_test_metadir=$(installedTests)/share/installed-tests/libostree"
+    "installed_testdir=${placeholder "installedTests"}/libexec/installed-tests/libostree"
+    "installed_test_metadir=${placeholder "installedTests"}/share/installed-tests/libostree"
   ];
-
 
   meta = with stdenv.lib; {
     description = "Git for operating system binaries";

pkgs/tools/misc/papis/default.nix

···
-{ lib, fetchFromGitHub, bashInteractive
-, python3, vim
+{ lib, fetchFromGitHub, fetchpatch
+, python36, xdg_utils
 }:
 
-let
-  python = python3;
-
-in python.pkgs.buildPythonApplication rec {
+python36.pkgs.buildPythonApplication rec {
   pname = "papis";
-  version = "0.6";
+  version = "0.7.5";
 
   # Missing tests on Pypi
   src = fetchFromGitHub {
     owner = "papis";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0zy8q154zhpqb75c775nwq3mdl1szhzhkfi0nvyjmzfgsv2g1wa2";
+    sha256 = "1b481sj92z9nw7gwbrpkgd4nlmqc1n73qilkc51k2r56cy1kjvss";
   };
 
-  postPatch = ''
-    sed -i 's/configparser>=3.0.0/# configparser>=3.0.0/' setup.py
-    patchShebangs tests
-  '';
+  # Update click version to 7.0.0
+  patches = fetchpatch {
+    url = https://github.com/papis/papis/commit/fddb80978a37a229300b604c26e992e2dc90913f.patch;
+    sha256 = "0cmagfdaaml1pxhnxggifpb47z5g1p231qywnvnqpd3dm93382w1";
+  };
 
-  propagatedBuildInputs = with python.pkgs; [
-    argcomplete arxiv2bib beautifulsoup4 bibtexparser
-    configparser dmenu-python habanero papis-python-rofi
-    pylibgen prompt_toolkit pyparser python_magic pyyaml
-    requests unidecode urwid vobject tkinter whoosh
-    vim
+  propagatedBuildInputs = with python36.pkgs; [
+    click requests filetype pyparsing configparser
+    arxiv2bib pyyaml chardet beautifulsoup4 prompt_toolkit
+    bibtexparser python-slugify pyparser pylibgen
+    habanero isbnlib
+    # optional dependencies
+    dmenu-python whoosh
   ];
 
-  checkInputs = with python.pkgs; [ pytest ];
-
-  # Papis tries to create the config folder under $HOME during the tests
-  checkPhase = ''
-    mkdir -p check-phase
-    export PATH=$out/bin:$PATH
-    # Still don't know why this fails
-    sed -i 's/--set dir=hello //' tests/bash/test_default.sh
-
-    # This test has been disabled since it requires a network connaction
-    sed -i 's/test_downloader_getter(self):/disabled_test_downloader_getter(self):/' papis/downloaders/tests/test_main.py
-
-    export HOME=$(pwd)/check-phase
-    make test
-    SH=${bashInteractive}/bin/bash make test-non-pythonic
+  postInstall = ''
+    install -Dt "$out/etc/bash_completion.d" scripts/shell_completion/build/bash/papis
   '';
+
+  checkInputs = (with python36.pkgs; [
+    pytest
+  ]) ++ [
+    xdg_utils
+  ];
+
+  # most of the downloader tests require a network connection
+  checkPhase = ''
+    HOME=$(mktemp -d) pytest papis tests --ignore tests/downloaders
+  '';
+
+  # FIXME: find out why 39 tests fail
+  doCheck = false;
 
   meta = {
     description = "Powerful command-line document and bibliography manager";

pkgs/tools/misc/rpm-ostree/default.nix

···
-{ stdenv, fetchpatch, fetchFromGitHub, ostree, rpm, which, autoconf, automake, libtool, pkgconfig,
-  gobject-introspection, gtk-doc, libxml2, libxslt, docbook_xsl, docbook_xml_dtd_42, gperf, cmake,
+{ stdenv, fetchurl, ostree, rpm, which, autoconf, automake, libtool, pkgconfig, cargo, rustc,
+  gobject-introspection, gtk-doc, libxml2, libxslt, docbook_xsl, docbook_xml_dtd_42, docbook_xml_dtd_43, gperf, cmake,
   libcap, glib, systemd, json-glib, libarchive, libsolv, librepo, polkit,
   bubblewrap, pcre, check, python }:
 
-let
-  libglnx-src = fetchFromGitHub {
-    owner = "GNOME";
-    repo = "libglnx";
-    rev = "97b5c08d2f93dc93ba296a84bbd2a5ab9bd8fc97";
-    sha256 = "0cz4x63f6ys7dln54g6mrr7hksvqwz78wdc8qb7zr1h2cp1azcvs";
+stdenv.mkDerivation rec {
+  pname = "rpm-ostree";
+  version = "2019.1";
+
+  src = fetchurl {
+    url = "https://github.com/projectatomic/${pname}/releases/download/v${version}/${pname}-${version}.tar.xz";
+    sha256 = "14qk8mq5yc67j3wl3fa9xnhh8ii8x5qdiavf7ybw7mp4ma4lwa8k";
   };
 
-  libdnf-src = fetchFromGitHub {
-    owner = "rpm-software-management";
-    repo = "libdnf";
-    rev = "b3fcc53f6f3baf4f51f836f5e1eb54eb82d5df49";
-    sha256 = "15nl9x4blyc9922rvz7iq56yy8hxhpsf31cs3ag7aypqpfx3czci";
-  };
-
-  version = "2018.5";
-in stdenv.mkDerivation {
-  name = "rpm-ostree-${version}";
+  patches = [
+    # gobject-introspection requires curl in cflags
+    # https://github.com/NixOS/nixpkgs/pull/50953#issuecomment-449777169
+    # https://github.com/NixOS/nixpkgs/pull/50953#issuecomment-452177080
+    ./fix-introspection-build.patch
+  ];
 
   outputs = [ "out" "dev" "man" "devdoc" ];
-
-  src = fetchFromGitHub {
-    rev = "v${version}";
-    owner = "projectatomic";
-    repo = "rpm-ostree";
-    sha256 = "0y37hr8mmrsww4ka2hlqmz7wp57ibzhah4j87yg8q8dks5hxcbsx";
-  };
-
   nativeBuildInputs = [
-    pkgconfig which autoconf automake libtool cmake gperf
-    gobject-introspection gtk-doc libxml2 libxslt docbook_xsl docbook_xml_dtd_42
+    pkgconfig which autoconf automake libtool cmake gperf cargo rustc
+    gobject-introspection gtk-doc libxml2 libxslt docbook_xsl docbook_xml_dtd_42 docbook_xml_dtd_43
   ];
   buildInputs = [
     libcap ostree rpm glib systemd polkit bubblewrap
     json-glib libarchive libsolv librepo
     pcre check python
-  ];
-
-  patches = [
-    # Use gdbus-codegen from PATH
-    (fetchpatch {
-      url = https://github.com/projectatomic/rpm-ostree/commit/315406d8cd0937e786723986e88d376c88806c60.patch;
-      sha256 = "073yfa62515kyf58s0sz56w0a40062lh761y2y4assqipybwxbvp";
-    })
   ];
 
   configureFlags = [
···
   dontUseCmakeConfigure = true;
 
   prePatch = ''
-    rmdir libglnx libdnf
-    cp --no-preserve=mode -r ${libglnx-src} libglnx
-    cp --no-preserve=mode -r ${libdnf-src} libdnf
-
     # According to #cmake on freenode, libdnf should bundle the FindLibSolv.cmake module
     cp ${libsolv}/share/cmake/Modules/FindLibSolv.cmake libdnf/cmake/modules/
-
-    # libdnf normally wants sphinx to build its hawkey manpages, but we don't care about those manpages since we don't use hawkey
-    substituteInPlace configure.ac --replace 'cmake \' 'cmake -DWITH_MAN=off \'
 
     # Let's not hardcode the rpm-gpg path...
     substituteInPlace libdnf/libdnf/dnf-keyring.cpp \
···
     platforms = platforms.linux;
   };
 }
-

pkgs/tools/misc/rpm-ostree/fix-introspection-build.patch

···
+--- a/configure.ac
++++ b/configure.ac
+@@ -103,7 +103,7 @@
+ 				     ostree-1 >= 2018.9
+ 				     libsystemd
+ 				     polkit-gobject-1
+-				     rpm librepo libsolv
++				     rpm librepo libsolv libcurl
+ 				     libarchive])
+ 
+ dnl -ldl: https://github.com/ostreedev/ostree/commit/1f832597fc83fda6cb8daf48c4495a9e1590774c

pkgs/tools/networking/urlwatch/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   name = "urlwatch-${version}";
-  version = "2.15";
+  version = "2.16";
 
   src = fetchFromGitHub {
     owner  = "thp";
     repo   = "urlwatch";
     rev    = version;
-    sha256 = "1bkd0r5arzdvinpn1n23cw1gf7byxml95hl6qvvf6mnggb1ifcwg";
+    sha256 = "1bkwr151bnv72aka2r9jwaq8lkz1p6031wr5pss4sij978qn5xld";
   };
 
   propagatedBuildInputs = with python3Packages; [
     appdirs
+    cssselect
     keyring
     lxml
     minidb

pkgs/top-level/all-packages.nix

···
   frostwire = callPackage ../applications/networking/p2p/frostwire { };
   frostwire-bin = callPackage ../applications/networking/p2p/frostwire/frostwire-bin.nix { };
 
-  ftgl = callPackage ../development/libraries/ftgl { };
+  ftgl = callPackage ../development/libraries/ftgl {
+    inherit (darwin.apple_sdk.frameworks) OpenGL;
+  };
 
   ftop = callPackage ../os-specific/linux/ftop { };
 
···
 
   papirus-icon-theme = callPackage ../data/icons/papirus-icon-theme { };
 
-  papis = python3Packages.callPackage ../tools/misc/papis { };
+  papis = callPackage ../tools/misc/papis { };
 
   pecita = callPackage ../data/fonts/pecita {};
 

pkgs/top-level/haskell-packages.nix

···
     "ghc863Binary"
     "ghc844"
     "ghcjs"
-    "ghcjs82"
     "ghcjs84"
+    "ghcjs86"
     "integer-simple"
   ];
 
···
       buildLlvmPackages = buildPackages.llvmPackages_6;
       llvmPackages = pkgs.llvmPackages_6;
     };
-    ghcjs = compiler.ghcjs84;
-    ghcjs82 = callPackage ../development/compilers/ghcjs-ng {
-      bootPkgs = packages.ghc822;
-      ghcjsSrcJson = ../development/compilers/ghcjs-ng/8.2/git.json;
-      stage0 = ../development/compilers/ghcjs-ng/8.2/stage0.nix;
-    };
+    ghcjs = compiler.ghcjs86;
     ghcjs84 = callPackage ../development/compilers/ghcjs-ng {
       bootPkgs = packages.ghc844;
       ghcjsSrcJson = ../development/compilers/ghcjs-ng/8.4/git.json;
       stage0 = ../development/compilers/ghcjs-ng/8.4/stage0.nix;
       ghcjsDepOverrides = callPackage ../development/compilers/ghcjs-ng/8.4/dep-overrides.nix {};
+    };
+    ghcjs86 = callPackage ../development/compilers/ghcjs-ng {
+      bootPkgs = packages.ghc863;
+      ghcjsSrcJson = ../development/compilers/ghcjs-ng/8.6/git.json;
+      stage0 = ../development/compilers/ghcjs-ng/8.6/stage0.nix;
+      ghcjsDepOverrides = callPackage ../development/compilers/ghcjs-ng/8.6/dep-overrides.nix {};
     };
 
     # The integer-simple attribute set contains all the GHC compilers
···
       ghc = bh.compiler.ghcHEAD;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-head.nix { };
     };
-    ghcjs = packages.ghcjs84;
-    ghcjs710 = callPackage ../development/haskell-modules rec {
-      buildHaskellPackages = ghc.bootPkgs;
-      ghc = bh.compiler.ghcjs710;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.10.x.nix { };
-      packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
-    };
-    ghcjs80 = callPackage ../development/haskell-modules rec {
-      buildHaskellPackages = ghc.bootPkgs;
-      ghc = bh.compiler.ghcjs80;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.0.x.nix { };
-      packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
-    };
-    ghcjs82 = callPackage ../development/haskell-modules rec {
-      buildHaskellPackages = ghc.bootPkgs;
-      ghc = bh.compiler.ghcjs82;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };
-      packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
-    };
+    ghcjs = packages.ghcjs86;
     ghcjs84 = callPackage ../development/haskell-modules rec {
       buildHaskellPackages = ghc.bootPkgs;
       ghc = bh.compiler.ghcjs84;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.4.x.nix { };
+      packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
+    };
+    ghcjs86 = callPackage ../development/haskell-modules rec {
+      buildHaskellPackages = ghc.bootPkgs;
+      ghc = bh.compiler.ghcjs86;
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.6.x.nix { };
       packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
     };
 

pkgs/top-level/python-packages.nix

···
 
   fb-re2 = callPackage ../development/python-modules/fb-re2 { };
 
+  filetype = callPackage ../development/python-modules/filetype { };
+
   flexmock = callPackage ../development/python-modules/flexmock { };
 
   flit = callPackage ../development/python-modules/flit { };
···
   imaplib2 = callPackage ../development/python-modules/imaplib2 { };
 
   ipfsapi = callPackage ../development/python-modules/ipfsapi { };
+
+  isbnlib = callPackage ../development/python-modules/isbnlib { };
 
   itsdangerous = callPackage ../development/python-modules/itsdangerous { };