Merge master into staging

lib/default.nix

···
  */
 let
 
-  callLibs = file: import file { inherit lib; };
+  inherit (import ./fixed-points.nix {}) makeExtensible;
 
-  lib = rec {
+  lib = makeExtensible (self: let
+    callLibs = file: import file { lib = self; };
+  in with self; {
 
     # often used, or depending on very little
     trivial = callLibs ./trivial.nix;
···
       mergeAttrsNoOverride mergeAttrByFunc mergeAttrsByFuncDefaults
       mergeAttrsByFuncDefaultsClean mergeAttrBy
       prepareDerivationArgs nixType imap overridableDelayableArgs;
-  };
+  });
 in lib

lib/modules.nix

···
         };
       };
 
-      closed = closeModules (modules ++ [ internalModule ]) ({ inherit config options; lib = import ./.; } // specialArgs);
+      closed = closeModules (modules ++ [ internalModule ]) ({ inherit config options lib; } // specialArgs);
 
       options = mergeModules prefix (reverseList (filterModules (specialArgs.modulesPath or "") closed));
 

maintainers/maintainer-list.nix

···
     github = "FireyFly";
     name = "Jonas Höglund";
   };
+  Fresheyeball = {
+    email = "[e-mail]";
+    github = "fresheyeball";
+    name = "Isaac Shapira";
+  };
   Gonzih = {
     email = "[e-mail]";
     github = "Gonzih";
···
   balajisivaraman = {
     email = "[e-mail]";
     name = "Balaji Sivaraman";
+  };
+  bandresen = {
+    email = "[e-mail]";
+    github = "bandresen";
+    name = "Benjamin Andresen";
   };
   barrucadu = {
     email = "[e-mail]";
···
     email = "[e-mail]";
     github = "ellis";
     name = "Ellis Whitehead";
+  };
+  elvishjerricco = {
+    email = "[e-mail]";
+    github = "ElvishJerricco";
+    name = "Will Fancher";
   };
   enzime = {
     email = "[e-mail]";

nixos/maintainers/scripts/gce/create-gce.sh

···
 
 set -euo pipefail
 
-BUCKET_NAME="${BUCKET_NAME:-nixos-images}"
+BUCKET_NAME="${BUCKET_NAME:-nixos-cloud-images}"
 TIMESTAMP="$(date +%Y%m%d%H%M)"
 export TIMESTAMP
 
···
 img_id=$(echo "$img_name" | sed 's|.raw.tar.gz$||;s|\.|-|g;s|_|-|g')
 if ! gsutil ls "gs://${BUCKET_NAME}/$img_name"; then
   gsutil cp "$img_path" "gs://${BUCKET_NAME}/$img_name"
+  gsutil acl ch -u AllUsers:R "gs://${BUCKET_NAME}/$img_name"
 fi
-gcloud compute images create "$img_id" --source-uri "gs://${BUCKET_NAME}/$img_name"

nixos/modules/services/misc/gitweb.nix

···
       example = ''
         $feature{'highlight'}{'default'} = [1];
         $feature{'ctags'}{'default'} = [1];
+        $feature{'avatar'}{'default'} = ['gravatar'];
       '';
     };
 

nixos/modules/services/torrent/transmission.nix

···
 
   # for users in group "transmission" to have access to torrents
   fullSettings = { umask = 2; download-dir = downloadDir; incomplete-dir = incompleteDir; } // cfg.settings;
+
+  # Directories transmission expects to exist and be ug+rwx.
+  directoriesToManage = [ homeDir settingsDir fullSettings.download-dir fullSettings.incomplete-dir ];
+
+  preStart = pkgs.writeScript "transmission-pre-start" ''
+    #!${pkgs.runtimeShell}
+    set -ex
+    for DIR in ${escapeShellArgs directoriesToManage}; do
+      mkdir -p "$DIR"
+      chmod 770 "$DIR"
+    done
+    cp -f ${settingsFile} ${settingsDir}/settings.json
+  '';
 in
 {
   options = {
···
 
       # 1) Only the "transmission" user and group have access to torrents.
       # 2) Optionally update/force specific fields into the configuration file.
-      serviceConfig.ExecStartPre = ''
-          ${pkgs.runtimeShell} -c "mkdir -p ${homeDir} ${settingsDir} ${fullSettings.download-dir} ${fullSettings.incomplete-dir} && chmod 770 ${homeDir} ${settingsDir} ${fullSettings.download-dir} ${fullSettings.incomplete-dir} && rm -f ${settingsDir}/settings.json && cp -f ${settingsFile} ${settingsDir}/settings.json"
-      '';
+      serviceConfig.ExecStartPre = preStart;
       serviceConfig.ExecStart = "${pkgs.transmission}/bin/transmission-daemon -f --port ${toString config.services.transmission.port}";
       serviceConfig.ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
       serviceConfig.User = "transmission";

nixos/modules/services/web-servers/nginx/gitweb.nix

···
 
   config = mkIf config.services.nginx.gitweb.enable {
 
-    systemd.sockets.gitweb = {
-      description = "GitWeb Listen Socket";
-      listenStreams = [ "/run/gitweb.sock" ];
-      socketConfig = {
-        Accept = "false";
-        SocketUser = "nginx";
-        SocketGroup = "nginx";
-        SocketMode = "0600";
-      };
-      wantedBy = [ "sockets.target" ];
-    };
     systemd.services.gitweb = {
       description = "GitWeb service";
-      script = "${git}/share/gitweb/gitweb.cgi --fcgi";
+      script = "${pkgs.git}/share/gitweb/gitweb.cgi --fastcgi --nproc=1";
+      environment  = {
+        FCGI_SOCKET_PATH = "/run/gitweb/gitweb.sock";
+      };
       serviceConfig = {
-        Type = "simple";
-        StandardInput = "socket";
         User = "nginx";
         Group = "nginx";
+        RuntimeDirectory = [ "gitweb" ];
       };
+      wantedBy = [ "multi-user.target" ];
     };
 
     services.nginx = {
       virtualHosts.default = {
-        locations."/gitweb" = {
-          root = "${pkgs.git}/share/gitweb";
+        locations."/gitweb/" = {
+          root = "${pkgs.git}/share";
+          tryFiles = "$uri @gitweb";
+        };
+        locations."@gitweb" = {
           extraConfig = ''
             include ${pkgs.nginx}/conf/fastcgi_params;
             fastcgi_param GITWEB_CONFIG ${cfg.gitwebConfigFile};
-            fastcgi_pass unix:/run/gitweb.sock;
+            fastcgi_pass unix:/run/gitweb/gitweb.sock;
           '';
         };
       };

nixos/modules/services/x11/desktop-managers/lxqt.nix

···
 
     environment.variables.GIO_EXTRA_MODULES = [ "${pkgs.gvfs}/lib/gio/modules" ];
 
+    services.upower.enable = config.powerManagement.enable;
   };
+
 
 }

nixos/modules/services/x11/desktop-managers/mate.nix

···
     services.gnome3.gnome-keyring.enable = true;
     services.upower.enable = config.powerManagement.enable;
 
+    security.pam.services."mate-screensaver".unixAuth = true;
+
     environment.pathsToLink = [ "/share" ];
   };
 

nixos/modules/virtualisation/google-compute-image.nix

···
   # Always include cryptsetup so that NixOps can use it.
   environment.systemPackages = [ pkgs.cryptsetup ];
 
+  # Make sure GCE image does not replace host key that NixOps sets
+  environment.etc."default/instance_configs.cfg".text = lib.mkDefault ''
+    [InstanceSetup]
+    set_host_keys = false
+  '';
+
   # Rely on GCP's firewall instead
   networking.firewall.enable = mkDefault false;
 
···
   networking.timeServers = [ "metadata.google.internal" ];
 
   networking.usePredictableInterfaceNames = false;
+
+  # GC has 1460 MTU
+  networking.interfaces.eth0.mtu = 1460;
 
   # allow the google-accounts-daemon to manage users
   users.mutableUsers = true;

nixos/release.nix

···
   tests.switchTest = callTest tests/switch-test.nix {};
   tests.taskserver = callTest tests/taskserver.nix {};
   tests.tomcat = callTest tests/tomcat.nix {};
+  tests.transmission = callTest tests/transmission.nix {};
   tests.udisks2 = callTest tests/udisks2.nix {};
   tests.vault = callTest tests/vault.nix {};
   tests.virtualbox = callSubTestsOnMatchingSystems ["x86_64-linux"] tests/virtualbox.nix {};

nixos/tests/transmission.nix

···
+import ./make-test.nix ({ pkgs, ...} : {
+  name = "transmission";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ coconnor ];
+  };
+
+  machine = { config, pkgs, ... }: {
+    imports = [ ../modules/profiles/minimal.nix ];
+
+    networking.firewall.allowedTCPPorts = [ 9091 ];
+
+    services.transmission.enable = true;
+  };
+
+  testScript =
+    ''
+      startAll;
+      $machine->waitForUnit("transmission");
+      $machine->shutdown;
+    '';
+})

pkgs/applications/audio/easytag/default.nix

···
 { stdenv, fetchurl, pkgconfig, intltool, gtk3, glib, libid3tag, id3lib, taglib
-, libvorbis, libogg, flac, itstool, libxml2, gsettings-desktop-schemas
+, libvorbis, libogg, opusfile, flac, itstool, libxml2, gsettings-desktop-schemas
 , gnome3, wrapGAppsHook
 }:
 
···
 
   nativeBuildInputs = [ pkgconfig intltool itstool libxml2 wrapGAppsHook ];
   buildInputs = [
-    gtk3 glib libid3tag id3lib taglib libvorbis libogg flac
+    gtk3 glib libid3tag id3lib taglib libvorbis libogg opusfile flac
     gsettings-desktop-schemas gnome3.defaultIconTheme
   ];
 

pkgs/applications/audio/elisa/default.nix

···
 
 mkDerivation rec {
   name = "elisa-${version}";
-  # 0.1 is expected in early/mid 2018-04
-  version = "0.0.20180320";
+  version = "0.1";
 
   src = fetchFromGitHub {
     owner  = "KDE";
     repo   = "elisa";
-    rev    = "9dd35d7244a8a3553275152f5b50fbe6d272ce64";
-    sha256 = "0mjqvcpk2y4jlwkka8gzl50wgqjjx9bzpbrj79cr0ib3jyviss4k";
+    rev    = version;
+    sha256 = "13i0fkpwrskric3gfalh7mcpp4l2knwnq7jpq391lgh6krq04r4w";
   };
 
   nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];

pkgs/applications/editors/atom/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "atom-${version}";
-  version = "1.25.0";
+  version = "1.25.1";
 
   src = fetchurl {
     url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "04iiw0qzl9025l4lasz42w5nfnvsmc7vwcf4a9c2hvl9xsyckajh";
+    sha256 = "0h0kr4w26c6i89rb9y4aw4l8f63al42i2cy3ddk16m1irzij9fk4";
     name = "${name}.deb";
   };
 

pkgs/applications/editors/focuswriter/default.nix

···
     description = "Simple, distraction-free writing environment";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ madjar ];
-    platforms = platforms.all;
+    platforms = platforms.linux;
     homepage = https://gottcode.org/focuswriter/;
   };
 }

pkgs/applications/editors/sublime/3/packages.nix

···
+{ callPackage }:
+
+let
+  common = opts: callPackage (import ./common.nix opts);
+in
+  rec {
+    sublime3-dev = common {
+      buildVersion = "3161";
+      x32sha256 = "0qrm2qmfsj71lr83c8zas2n3xk8hk9k4w8ygnasjhggmyjm3wy0q";
+      x64sha256 = "0cgadylm68s2jly10r038q1fvmbzmpc2nvqy86vlyq9avgqbm5pc";
+    } {};
+
+    sublime3 = common {
+      buildVersion = "3143";
+      x32sha256 = "0dgpx4wij2m77f478p746qadavab172166bghxmj7fb61nvw9v5i";
+      x64sha256 = "06b554d2cvpxc976rvh89ix3kqc7klnngvk070xrs8wbyb221qcw";    
+    } {};
+  }

pkgs/applications/editors/sublime3/default.nix pkgs/applications/editors/sublime/3/common.nix

···
+{buildVersion, x32sha256, x64sha256}:
+
 { fetchurl, stdenv, glib, xorg, cairo, gtk2, pango, makeWrapper, openssl, bzip2,
   pkexecPath ? "/run/wrappers/bin/pkexec", libredirect,
-  gksuSupport ? false, gksu, unzip, zip, bash }:
+  gksuSupport ? false, gksu, unzip, zip, bash}:
 
 assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";
 assert gksuSupport -> gksu != null;
 
 let
-  build = "3143";
+
   libPath = stdenv.lib.makeLibraryPath [glib xorg.libX11 gtk2 cairo pango];
   redirects = [ "/usr/bin/pkexec=${pkexecPath}" ]
     ++ stdenv.lib.optional gksuSupport "/usr/bin/gksudo=${gksu}/bin/gksudo";
 in let
+  archSha256 =
+    if stdenv.system == "i686-linux" then
+      x32sha256
+    else
+      x64sha256;
+
+  arch =
+    if stdenv.system == "i686-linux" then
+      "x32"
+    else
+      "x64";
+
   # package with just the binaries
   sublime = stdenv.mkDerivation {
-    name = "sublimetext3-${build}-bin";
-
+    name = "sublimetext3-${buildVersion}-bin";
     src =
-      if stdenv.system == "i686-linux" then
-        fetchurl {
-          name = "sublimetext-${build}.tar.bz2";
-          url = "https://download.sublimetext.com/sublime_text_3_build_${build}_x32.tar.bz2";
-          sha256 = "0dgpx4wij2m77f478p746qadavab172166bghxmj7fb61nvw9v5i";
-        }
-      else
-        fetchurl {
-          name = "sublimetext-${build}.tar.bz2";
-          url = "https://download.sublimetext.com/sublime_text_3_build_${build}_x64.tar.bz2";
-          sha256 = "06b554d2cvpxc976rvh89ix3kqc7klnngvk070xrs8wbyb221qcw";
-        };
+      fetchurl {
+        name = "sublimetext-${buildVersion}.tar.bz2";
+        url = "https://download.sublimetext.com/sublime_text_3_build_${buildVersion}_${arch}.tar.bz2";
+        sha256 = archSha256;
+      };
 
     dontStrip = true;
     dontPatchELF = true;
···
       wrapProgram $out/plugin_host --prefix LD_PRELOAD : ${stdenv.cc.cc.lib}/lib${stdenv.lib.optionalString stdenv.is64bit "64"}/libgcc_s.so.1:${openssl.out}/lib/libssl.so:${bzip2.out}/lib/libbz2.so
     '';
   };
-in stdenv.mkDerivation {
-  name = "sublimetext3-${build}";
+in stdenv.mkDerivation (rec {
+  name = "sublimetext3-${buildVersion}";
 
   phases = [ "installPhase" ];
 
···
     license = licenses.unfree;
     platforms = platforms.linux;
   };
-}
+})

pkgs/applications/misc/buku/default.nix

···
     homepage = https://github.com/jarun/Buku;
     license = licenses.gpl3;
     platforms = platforms.linux;
-    maintainers = with maintainers; [ matthiasbeyer infinisil ];
+    maintainers = with maintainers; [ infinisil ];
   };
 }
 

pkgs/applications/misc/calibre/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "3.20.0";
+  version = "3.21.0";
   name = "calibre-${version}";
 
   src = fetchurl {
     url = "https://download.calibre-ebook.com/${version}/${name}.tar.xz";
-    sha256 = "1rnmh24d9hqnncg6p6zwkb3y3m4k9n7pzma69haxnm7iaps84gmy";
+    sha256 = "0nd9lv7armmkjwxjhs5mhsksvig5n435kww1dy9fq5hxg7nkq5ip";
   };
 
   patches = [

pkgs/applications/misc/cataract/build.nix

···
     homepage = http://cgg.bzatek.net/;
     description = "a simple static web photo gallery, designed to be clean and easily usable";
     license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = with stdenv.lib.platforms; linux ++ darwin;
   };
 }

pkgs/applications/misc/cheat/default.nix

···
 buildPythonApplication rec {
   name = "${pname}-${version}";
   pname = "cheat";
-  version = "2.2.2";
+  version = "2.2.3";
 
   propagatedBuildInputs = [ docopt pygments ];
 
···
     owner = "chrisallenlane";
     repo = "cheat";
     rev = version;
-    sha256 = "1da4m4n6nivjakpll6jj0aszrv24g2zax74034lzpv3pbh84fvas";
+    sha256 = "1p9a54fax3b1ilqcwdlccy08ww3igwsyzcyikqivaxj5p6mqq6wl";
   };
   # no tests available
   doCheck = false;

pkgs/applications/misc/cli-visualizer/default.nix

···
     homepage = https://github.com/dpayne/cli-visualizer;
     description = "CLI based audio visualizer";
     license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/misc/ctodo/default.nix

···
     homepage = http://ctodo.apakoh.dk/;
     description = "A simple ncurses-based task list manager";
     license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/misc/gkrellm/default.nix

···
     homepage = http://gkrellm.srcbox.net;
     license = licenses.gpl3Plus;
     maintainers = [ ];
-    platforms = platforms.unix;
+    platforms = platforms.linux;
   };
 }

pkgs/applications/misc/haxor-news/default.nix

···
     homepage = https://github.com/donnemartin/haxor-news;
     description = "Browse Hacker News like a haxor";
     license = licenses.asl20;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
   };
 
 }

pkgs/applications/misc/hr/default.nix

···
     homepage = https://github.com/LuRsT/hr;
     description = "A horizontal bar for your terminal";
     license = licenses.mit;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
     platforms = platforms.unix;
   };
 }

pkgs/applications/misc/hstr/default.nix

···
     homepage = https://github.com/dvorka/hstr;
     description = "Shell history suggest box - easily view, navigate, search and use your command history";
     license = stdenv.lib.licenses.asl20;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = with stdenv.lib.platforms; linux; # Cannot test others
   };
 

pkgs/applications/misc/jgmenu/default.nix

···
     homepage = https://github.com/johanmalm/jgmenu;
     description = "Small X11 menu intended to be used with openbox and tint2";
     license = licenses.gpl2;
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     maintainers = [ maintainers.romildo ];
   };
 }

pkgs/applications/misc/josm/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "josm-${version}";
-  version = "13500";
+  version = "13576";
 
   src = fetchurl {
     url = "https://josm.openstreetmap.de/download/josm-snapshot-${version}.jar";
-    sha256 = "1dyys4y859dazjqpn3f7vd0cpyglk82y3igrdca293y0n0hrmi7v";
+    sha256 = "0pw7srvds8zs53ibvj779vj505h2gfrn7xqx13hkbacdg441jkd4";
   };
 
   buildInputs = [ jre8 makeWrapper ];

pkgs/applications/misc/khal/default.nix

···
     homepage = http://lostpackets.de/khal/;
     description = "CLI calendar application";
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer jgeerds ];
+    maintainers = with maintainers; [ jgeerds ];
   };
 }

pkgs/applications/misc/khard/default.nix

···
     homepage = https://github.com/scheibler/khard;
     description = "Console carddav client";
     license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
   };
 }

pkgs/applications/misc/mdp/default.nix

···
   meta = with stdenv.lib; {
     homepage = https://github.com/visit1985/mdp;
     description = "A command-line based markdown presentation tool";
-    maintainers = with maintainers; [ matthiasbeyer vrthra ];
+    maintainers = with maintainers; [ vrthra ];
     license = licenses.gpl3;
     platforms = with platforms; unix;
   };

pkgs/applications/misc/mwic/default.nix

···
     homepage = http://jwilk.net/software/mwic;
     description = "spell-checker that groups possible misspellings and shows them in their contexts";
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
   };
 }
 

pkgs/applications/misc/posterazor/default.nix

···
     homepage = http://posterazor.sourceforge.net/;
     description = "Cuts a raster image into pieces which can afterwards be printed out and assembled to a poster";
     maintainers = [ stdenv.lib.maintainers.madjar ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/misc/rtv/default.nix

···
     homepage = https://github.com/michael-lazar/rtv;
     description = "Browse Reddit from your Terminal";
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer jgeerds wedens ];
+    maintainers = with maintainers; [ jgeerds wedens ];
   };
 }

pkgs/applications/misc/sc-im/default.nix

···
     homepage = https://github.com/andmarti1424/sc-im;
     description = "SC-IM - Spreadsheet Calculator Improvised - SC fork";
     license = licenses.bsdOriginal;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
     platforms = platforms.linux; # Cannot test others
   };
 

pkgs/applications/misc/sigal/default.nix

···
     description = "Yet another simple static gallery generator";
     homepage    = http://sigal.saimon.org/en/latest/index.html;
     license     = licenses.mit;
-    maintainers = with maintainers; [ domenkozar matthiasbeyer ];
+    maintainers = with maintainers; [ domenkozar ];
   };
 }
 

pkgs/applications/misc/stag/default.nix

···
     homepage = https://github.com/seenaburns/stag;
     description = "Terminal streaming bar graph passed through stdin";
     license = stdenv.lib.licenses.bsdOriginal;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = stdenv.lib.platforms.unix;
   };
 }

pkgs/applications/misc/tasknc/default.nix

···
   meta = with stdenv.lib; {
     homepage = https://github.com/lharding/tasknc;
     description = "A ncurses wrapper around taskwarrior";
-    maintainers = with maintainers; [ matthiasbeyer infinisil ];
+    maintainers = with maintainers; [ infinisil ];
     platforms = platforms.linux; # Cannot test others
   };
 }

pkgs/applications/misc/tasksh/default.nix

···
     description = "REPL for taskwarrior";
     homepage = http://tasktools.org;
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/applications/misc/terminus/default.nix

···
+{ stdenv, lib, fetchurl, dpkg, gtk2, atk, glib, pango, gdk_pixbuf, cairo
+, freetype, fontconfig, dbus, libXi, libXcursor, libXdamage, libXrandr
+, libXcomposite, libXext, libXfixes, libXrender, libX11, libXtst, libXScrnSaver
+, libxcb, makeWrapper, nodejs
+, GConf, nss, nspr, alsaLib, cups, expat, libudev, libpulseaudio }:
+
+let
+  libPath = stdenv.lib.makeLibraryPath [
+    stdenv.cc.cc gtk2 atk glib pango gdk_pixbuf cairo freetype fontconfig dbus
+    libXi libXcursor libXdamage libXrandr libXcomposite libXext libXfixes libxcb
+    libXrender libX11 libXtst libXScrnSaver GConf nss nspr alsaLib cups expat libudev libpulseaudio
+  ];
+in
+stdenv.mkDerivation rec {
+  version = "1.0.0-alpha.42";
+  name = "terminus-${version}";
+  src = fetchurl {
+    url = "https://github.com/Eugeny/terminus/releases/download/v${version}/terminus_${version}_amd64.deb";
+    sha256 = "1r5n75n71zwahg4rxlnf9qzrb0651gxv0987m6bykqmfpnw91nmb";
+  };
+  buildInputs = [ dpkg makeWrapper ];
+  unpackPhase = ''
+    mkdir pkg
+    dpkg-deb -x $src pkg
+    sourceRoot=pkg
+  '';
+  installPhase = ''
+    mkdir -p "$out/bin"
+    mv opt "$out/"
+    ln -s "$out/opt/Terminus/terminus" "$out/bin/terminus"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "${libPath}:\$ORIGIN" "$out/opt/Terminus/terminus"
+    mv usr/* "$out/"
+    wrapProgram $out/bin/terminus --prefix PATH : ${lib.makeBinPath [ nodejs ]}
+  '';
+  dontPatchELF = true;
+  meta = with lib; {
+    description = "A terminal for a more modern age";
+    homepage    = https://eugeny.github.io/terminus/;
+    maintainers = with maintainers; [ jlesquembre ];
+    license     = licenses.mit;
+    platforms   = [ "x86_64-linux" ];
+  };
+}

pkgs/applications/misc/timewarrior/default.nix

···
     description = "A command-line time tracker";
     homepage = https://tasktools.org/projects/timewarrior.html;
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer mrVanDalo ];
+    maintainers = with maintainers; [ mrVanDalo ];
     platforms = platforms.linux ++ platforms.darwin;
   };
 }

pkgs/applications/misc/toot/default.nix

···
     description = "Mastodon CLI interface";
     homepage    = "https://github.com/ihabunek/toot";
     license     = licenses.mit;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
   };
 
 }

pkgs/applications/misc/vit/default.nix

···
 
   meta = {
     description = "Visual Interactive Taskwarrior";
-    maintainers = with pkgs.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with pkgs.lib.maintainers; [ ];
     platforms = pkgs.lib.platforms.linux;
     license = pkgs.lib.licenses.gpl3;
   };

pkgs/applications/misc/weather/default.nix

···
         homepage = http://fungi.yuggoth.org/weather;
         description = "Quick access to current weather conditions and forecasts";
         license = stdenv.lib.licenses.isc;
-        maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+        maintainers = with stdenv.lib.maintainers; [ ];
         platforms = with stdenv.lib.platforms; linux; # my only platform
     };
 }

pkgs/applications/misc/yaft/default.nix

···
     homepage = https://github.com/uobikiemukot/yaft;
     description = "Yet another framebuffer terminal";
     license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/networking/browsers/otter/default.nix

···
 { stdenv, cmake, openssl, gst_all_1, fetchFromGitHub
 , qtbase, qtmultimedia, qtwebengine
-, version ? "0.9.94"
-, sourceSha ? "19mfm0f6qqkd78aa6q4nq1y9gnlasqiyk68zgqjp1i03g70h08k5"
+, version ? "0.9.96"
+, sourceSha ? "1xzfy3jjx9sskwwbk7l8hnwnjf8af62p4kjkydp0ld0j50apc39p"
 }:
 stdenv.mkDerivation {
   name = "otter-browser-${version}";

pkgs/applications/networking/cluster/mesos/default.nix

···
 , leveldb, glog, perf, utillinux, libnl, iproute, openssl, libevent
 , ethtool, coreutils, which, iptables, maven
 , bash, autoreconfHook
+, withJava ? !stdenv.isDarwin
 }:
 
 let
···
     autoreconfHook
   ];
   buildInputs = [
-    makeWrapper curl sasl jdk
+    makeWrapper curl sasl
     python wrapPython boto setuptools leveldb
-    subversion apr glog openssl libevent maven
+    subversion apr glog openssl libevent
   ] ++ lib.optionals stdenv.isLinux [
     libnl
+  ] ++ lib.optionals withJava [
+    jdk maven
   ];
 
   propagatedBuildInputs = [
···
     "--with-libevent=${libevent.dev}"
     "--with-protobuf=${pythonProtobuf.protobuf}"
     "PROTOBUF_JAR=${mavenRepo}/com/google/protobuf/protobuf-java/3.3.0/protobuf-java-3.3.0.jar"
+    (if withJava then "--enable-java" else "--disable-java")
   ] ++ lib.optionals stdenv.isLinux [
     "--with-network-isolator"
     "--with-nl=${libnl.dev}"
···
   postInstall = ''
     rm -rf $out/var
     rm $out/bin/*.sh
-
-    mkdir -p $out/share/java
-    cp src/java/target/mesos-*.jar $out/share/java
-
-    MESOS_NATIVE_JAVA_LIBRARY=$out/lib/libmesos${stdenv.hostPlatform.extensions.sharedLibrary}
-
-    mkdir -p $out/nix-support
-    touch $out/nix-support/setup-hook
-    echo "export MESOS_NATIVE_JAVA_LIBRARY=$MESOS_NATIVE_JAVA_LIBRARY" >> $out/nix-support/setup-hook
-    echo "export MESOS_NATIVE_LIBRARY=$MESOS_NATIVE_JAVA_LIBRARY" >> $out/nix-support/setup-hook
 
     # Inspired by: pkgs/development/python-modules/generic/default.nix
     pushd src/python
···
       --old-and-unmanageable \
       --prefix="$out"
     popd
+  '' + stdenv.lib.optionalString withJava ''
+    mkdir -p $out/share/java
+    cp src/java/target/mesos-*.jar $out/share/java
+
+    MESOS_NATIVE_JAVA_LIBRARY=$out/lib/libmesos${stdenv.hostPlatform.extensions.sharedLibrary}
+
+    mkdir -p $out/nix-support
+    touch $out/nix-support/setup-hook
+    echo "export MESOS_NATIVE_JAVA_LIBRARY=$MESOS_NATIVE_JAVA_LIBRARY" >> $out/nix-support/setup-hook
+    echo "export MESOS_NATIVE_LIBRARY=$MESOS_NATIVE_JAVA_LIBRARY" >> $out/nix-support/setup-hook
   '';
 
   postFixup = ''
···
     license     = licenses.asl20;
     description = "A cluster manager that provides efficient resource isolation and sharing across distributed applications, or frameworks";
     maintainers = with maintainers; [ cstrahan kevincox offline ];
-    platforms   = platforms.linux;
+    platforms   = platforms.unix;
   };
 }

pkgs/applications/networking/cluster/terraform-provider-nixos/default.nix

···
+{ stdenv, lib, buildGoPackage, fetchFromGitHub }:
+buildGoPackage rec {
+  name = "terraform-provider-nixos-${version}";
+  version = "0.0.1";
+  goPackagePath = "github.com/tweag/terraform-provider-nixos";
+  src = fetchFromGitHub {
+    owner = "tweag";
+    repo = "terraform-provider-nixos";
+    sha256 = "00vz6qjq1pk39iqg4356b8g3c6slla9jifkv2knk46gc9q93q0lf";
+    rev = "v${version}";
+  };
+
+  # Terraform allow checking the provider versions, but this breaks
+  # if the versions are not provided via file paths.
+  postBuild = "mv go/bin/terraform-provider-nixos{,_v${version}}";
+
+  meta = with stdenv.lib; {
+    description = "Terraform plugin for outputting NixOS configuration files from Terraform resources.";
+    homepage = "https://github.com/tweag/terraform-provider-nixos";
+    license = licenses.mpl20;
+    maintainers = with maintainers; [ grahamc ];
+  };
+}

pkgs/applications/networking/instant-messengers/nheko/default.nix

···
+{ stdenv, fetchFromGitHub, fetchurl, cmake, doxygen, lmdb, qt5 }:
+
+let
+  json_hpp = fetchurl {
+    url = https://github.com/nlohmann/json/releases/download/v3.1.2/json.hpp;
+    sha256 = "fbdfec4b4cf63b3b565d09f87e6c3c183bdd45c5be1864d3fcb338f6f02c1733";
+  };
+
+  variant_hpp = fetchurl {
+    url = https://github.com/mpark/variant/releases/download/v1.3.0/variant.hpp;
+    sha256 = "1vjiz1x5l8ynqqyb5l9mlrzgps526v45hbmwjilv4brgyi5445fq";
+  };
+
+  matrix-structs = stdenv.mkDerivation rec {
+    name = "matrix-structs-git";
+
+    src = fetchFromGitHub {
+      owner = "mujx";
+      repo = "matrix-structs";
+      rev = "91bb2b85a75d664007ef81aeb500d35268425922";
+      sha256 = "1v544pv18sd91gdrhbk0nm54fggprsvwwrkjmxa59jrvhwdk7rsx";
+    };
+
+    postUnpack = ''
+      cp ${json_hpp} "$sourceRoot/include/json.hpp"
+      cp ${variant_hpp} "$sourceRoot/include/variant.hpp"
+    '';
+
+    patches = [ ./fetchurls.patch ];
+
+    nativeBuildInputs = [ cmake doxygen ];
+  };
+
+  tweeny = fetchFromGitHub {
+    owner = "mobius3";
+    repo = "tweeny";
+    rev = "b94ce07cfb02a0eb8ac8aaf66137dabdaea857cf";
+    sha256 = "1wyyq0j7dhjd6qgvnh3knr70li47hmf5394yznkv9b1indqjx4mi";
+  };
+
+  lmdbxx = fetchFromGitHub {
+    owner = "bendiken";
+    repo = "lmdbxx";
+    rev = "0b43ca87d8cfabba392dfe884eb1edb83874de02";
+    sha256 = "1whsc5cybf9rmgyaj6qjji03fv5jbgcgygp956s3835b9f9cjg1n";
+  };
+in
+stdenv.mkDerivation rec {
+  name = "nheko-${version}";
+  version = "0.3.0";
+
+  src = fetchFromGitHub {
+    owner = "mujx";
+    repo = "nheko";
+    rev = "v${version}";
+    sha256 = "178z64vkl7nmr1amgsgvdcwipj8czp7vbvidxllxiwal21yvqpky";
+  };
+
+  # This patch is likely not strictly speaking needed, but will help detect when
+  # a dependency is updated, so that the fetches up there can be updated too
+  patches = [ ./external-deps.patch ];
+
+  cmakeFlags = [
+    "-DMATRIX_STRUCTS_LIBRARY=${matrix-structs}/lib/static/libmatrix_structs.a"
+    "-DMATRIX_STRUCTS_INCLUDE_DIR=${matrix-structs}/include/matrix_structs"
+    "-DTWEENY_INCLUDE_DIR=${tweeny}/include"
+    "-DLMDBXX_INCLUDE_DIR=${lmdbxx}"
+  ];
+
+  nativeBuildInputs = [ cmake ];
+
+  buildInputs = [
+    lmdb lmdbxx matrix-structs qt5.qtbase qt5.qtmultimedia qt5.qttools tweeny
+  ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "Desktop client for the Matrix protocol";
+    maintainers = with maintainers; [ ekleog ];
+    platforms = platforms.all;
+  };
+}

pkgs/applications/networking/instant-messengers/nheko/external-deps.patch

···
+diff --git a/cmake/LMDBXX.cmake b/cmake/LMDBXX.cmake
+index 3b9817d..e69de29 100644
+--- a/cmake/LMDBXX.cmake
++++ b/cmake/LMDBXX.cmake
+@@ -1,23 +0,0 @@
+-include(ExternalProject)
+-
+-#
+-# Build lmdbxx.
+-#
+-
+-set(THIRD_PARTY_ROOT ${CMAKE_SOURCE_DIR}/.third-party)
+-set(LMDBXX_ROOT ${THIRD_PARTY_ROOT}/lmdbxx)
+-
+-set(LMDBXX_INCLUDE_DIR ${LMDBXX_ROOT})
+-
+-ExternalProject_Add(
+-  lmdbxx
+-
+-  GIT_REPOSITORY https://github.com/bendiken/lmdbxx
+-  GIT_TAG 0b43ca87d8cfabba392dfe884eb1edb83874de02
+-
+-  BUILD_IN_SOURCE 1
+-  SOURCE_DIR ${LMDBXX_ROOT}
+-  CONFIGURE_COMMAND ""
+-  BUILD_COMMAND ""
+-  INSTALL_COMMAND ""
+-)
+diff --git a/cmake/MatrixStructs.cmake b/cmake/MatrixStructs.cmake
+index cef00f6..e69de29 100644
+--- a/cmake/MatrixStructs.cmake
++++ b/cmake/MatrixStructs.cmake
+@@ -1,33 +0,0 @@
+-include(ExternalProject)
+-
+-#
+-# Build matrix-structs.
+-#
+-
+-set(THIRD_PARTY_ROOT ${CMAKE_SOURCE_DIR}/.third-party)
+-set(MATRIX_STRUCTS_ROOT ${THIRD_PARTY_ROOT}/matrix_structs)
+-set(MATRIX_STRUCTS_INCLUDE_DIR ${MATRIX_STRUCTS_ROOT}/include)
+-set(MATRIX_STRUCTS_LIBRARY matrix_structs)
+-
+-link_directories(${MATRIX_STRUCTS_ROOT})
+-
+-set(WINDOWS_FLAGS "")
+-
+-if(MSVC)
+-    set(WINDOWS_FLAGS "-DCMAKE_GENERATOR_PLATFORM=x64")
+-endif()
+-
+-ExternalProject_Add(
+-  MatrixStructs
+-
+-  GIT_REPOSITORY https://github.com/mujx/matrix-structs
+-  GIT_TAG 91bb2b85a75d664007ef81aeb500d35268425922
+-
+-  BUILD_IN_SOURCE 1
+-  SOURCE_DIR ${MATRIX_STRUCTS_ROOT}
+-  CONFIGURE_COMMAND ${CMAKE_COMMAND}
+-    -DCMAKE_BUILD_TYPE=Release ${MATRIX_STRUCTS_ROOT}
+-    ${WINDOWS_FLAGS}
+-  BUILD_COMMAND ${CMAKE_COMMAND} --build ${MATRIX_STRUCTS_ROOT} --config Release
+-  INSTALL_COMMAND ""
+-)
+diff --git a/cmake/Tweeny.cmake b/cmake/Tweeny.cmake
+index 537ac92..e69de29 100644
+--- a/cmake/Tweeny.cmake
++++ b/cmake/Tweeny.cmake
+@@ -1,23 +0,0 @@
+-include(ExternalProject)
+-
+-#
+-# Build tweeny
+-#
+-
+-set(THIRD_PARTY_ROOT ${CMAKE_SOURCE_DIR}/.third-party)
+-set(TWEENY_ROOT ${THIRD_PARTY_ROOT}/tweeny)
+-
+-set(TWEENY_INCLUDE_DIR ${TWEENY_ROOT}/include)
+-
+-ExternalProject_Add(
+-  Tweeny
+-
+-  GIT_REPOSITORY https://github.com/mobius3/tweeny
+-  GIT_TAG b94ce07cfb02a0eb8ac8aaf66137dabdaea857cf
+-
+-  BUILD_IN_SOURCE 1
+-  SOURCE_DIR ${TWEENY_ROOT}
+-  CONFIGURE_COMMAND ""
+-  BUILD_COMMAND ""
+-  INSTALL_COMMAND ""
+-)

pkgs/applications/networking/instant-messengers/nheko/fetchurls.patch

···
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 077ac37..c639d71 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -18,16 +18,6 @@ include(Doxygen)
+ #
+ include(CompilerFlags)
+ 
+-file(DOWNLOAD
+-    "https://github.com/nlohmann/json/releases/download/v3.1.2/json.hpp"
+-    ${PROJECT_SOURCE_DIR}/include/json.hpp
+-    EXPECTED_HASH SHA256=fbdfec4b4cf63b3b565d09f87e6c3c183bdd45c5be1864d3fcb338f6f02c1733)
+-
+-file(DOWNLOAD
+-    "https://github.com/mpark/variant/releases/download/v1.3.0/variant.hpp"
+-    ${PROJECT_SOURCE_DIR}/include/variant.hpp
+-    EXPECTED_MD5 "be0ce322cdd408e1b347b9f1d59ea67a")
+-
+ include_directories(include)
+ 
+ set(SRC

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

···
 
   postInstall = ''
     cp ${muttWrapper} $out/bin/mutt
-    wrapProgram "$out/bin/neomutt" --prefix PATH : "$out/lib/neomutt"
+    wrapProgram "$out/bin/neomutt" --prefix PATH : "$out/libexec/neomutt"
   '';
 
   doCheck = true;

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

···
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  version = "0.26";
+  version = "0.26.1";
   name = "notmuch-${version}";
 
   passthru = {
···
 
   src = fetchurl {
     url = "http://notmuchmail.org/releases/${name}.tar.gz";
-    sha256 = "1pvn1n7giv8n3xlazi3wpscdqhd2yak0fgv68aj23myr5bnr9s6k";
+    sha256 = "0dx8nhdmkaqabxcgxfa757m99fi395y76h9ynx8539yh9m7y9xyk";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/applications/networking/offrss/default.nix

···
     description = "Offline RSS/Atom reader";
     license="AGPLv3+";
     maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; all;
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/office/beancount/bean-add.nix

···
     # The (only) source file states:
     #   License: "Do what you feel is right, but don't be a jerk" public license.
 
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
   };
 }
 

pkgs/applications/office/beancount/default.nix

···
         generate a variety of reports from them, and provides a web interface.
     '';
     license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
   };
 }
 

pkgs/applications/office/cb2bib/default.nix

···
 stdenv.mkDerivation rec {
   name = pname + "-" + version;
   pname = "cb2bib";
-  version = "1.9.2";
+  version = "1.9.7";
   src = fetchurl {
     url = "http://www.molspaces.com/dl/progs/${name}.tar.gz";
-    sha256 = "0yz79v023w1229wzck3gij0iqah1xg8rg4a352q8idvg7bdmyfin";
+    sha256 = "0gr8vmlz1ikw0jiwwac2ays20z26cdv3bjdx9m1nc450hl6m5s7s";
   };
   buildInputs = [ qtbase qtwebkit qtx11extras lzo libX11 ];
   nativeBuildInputs = [ qmake ];

pkgs/applications/office/fava/default.nix

···
     homepage = https://beancount.github.io/fava;
     description = "Web interface for beancount";
     license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
   };
 }
 

pkgs/applications/office/wordgrinder/default.nix

···
     description = "Text-based word processor";
     homepage = https://cowlark.com/wordgrinder;
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
     platforms = with stdenv.lib.platforms; linux ++ darwin;
   };
 }

pkgs/applications/science/biology/bcftools/default.nix

···
-{ stdenv, fetchurl, htslib, zlib, bzip2, lzma, curl, perl, bash }:
+{ stdenv, fetchurl, htslib, zlib, bzip2, lzma, curl, perl, python, bash }:
 
 stdenv.mkDerivation rec {
   name = "${pname}-${version}";
   pname = "bcftools";
-  version = "1.7";
+  version = "1.8";
 
   src = fetchurl {
     url = "https://github.com/samtools/bcftools/releases/download/${version}/${name}.tar.bz2";
-    sha256 = "1l82sgw86l1626b7kxv3h0696lbj7317bb48rvqb1zqd3gcn6kyx";
+    sha256 = "1vgw2mwngq20c530zim52zvgmw1lci8rzl33pvh44xqk3xlzvjsa";
   };
 
-  nativeBuildInputs = [ perl ];
-
-  buildInputs = [ htslib zlib bzip2 lzma curl ];
+  buildInputs = [ htslib zlib bzip2 lzma curl perl python ];
 
   makeFlags = [
     "HSTDIR=${htslib}"

pkgs/applications/science/logic/beluga/default.nix

···
+{ stdenv, fetchFromGitHub, ocamlPackages, omake }:
+
+stdenv.mkDerivation {
+  name = "beluga-20180403";
+
+  src = fetchFromGitHub {
+    owner  = "Beluga-lang";
+    repo   = "Beluga";
+    rev    = "046aa59f008be70a7c4700b723bed0214ea8b687";
+    sha256 = "0m68y0r0wdw3mg2jks68bihaww7sg305zdfnic1rkndq2cxv0mld";
+  };
+
+  nativeBuildInputs = with ocamlPackages; [ findlib ocamlbuild omake ];
+  buildInputs = with ocamlPackages; [ ocaml ulex ocaml_extlib ];
+
+  installPhase = ''
+    mkdir -p $out
+    cp -r bin $out/
+
+    mkdir -p $out/share/beluga
+    cp -r tools/ examples/ $out/share/beluga
+
+    mkdir -p $out/share/emacs/site-lisp/beluga/
+    cp -r tools/beluga-mode.el $out/share/emacs/site-lisp/beluga
+  '';
+
+  meta = {
+    description = "A functional language for reasoning about formal systems";
+    homepage    = http://complogic.cs.mcgill.ca/beluga/;
+    license     = stdenv.lib.licenses.gpl3Plus;
+    maintainers = [ stdenv.lib.maintainers.bcdarwin ];
+    platforms   = stdenv.lib.platforms.unix;
+  };
+}

pkgs/applications/science/logic/z3/4.5.0.nix

···
-{ stdenv, fetchFromGitHub, python2, fixDarwinDylibNames }:
-
-let
-  python = python2;
-in stdenv.mkDerivation rec {
-  name = "z3-${version}";
-  version = "4.5.0";
-
-  src = fetchFromGitHub {
-    owner  = "Z3Prover";
-    repo   = "z3";
-    rev    = "z3-4.5.0";
-    sha256 = "0ssp190ksak93hiz61z90x6hy9hcw1ywp8b2dzmbhn6fbd4bnxzp";
-  };
-
-  buildInputs = [ python fixDarwinDylibNames ];
-  enableParallelBuilding = true;
-
-  configurePhase = ''
-    ${python.interpreter} scripts/mk_make.py --prefix=$out --python --pypkgdir=$out/${python.sitePackages}
-    cd build
-  '';
-
-  meta = {
-    description = "A high-performance theorem prover and SMT solver";
-    homepage    = "https://github.com/Z3Prover/z3";
-    license     = stdenv.lib.licenses.mit;
-    platforms   = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
-  };
-}

pkgs/applications/science/math/weka/default.nix

···
-{ stdenv, fetchurl, jre, unzip }:
+{ stdenv, fetchurl, jre, unzip, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "weka-${version}";
-  version = "3.8.2";
+  version = "3.9.2";
 
   src = fetchurl {
     url = "mirror://sourceforge/weka/${stdenv.lib.replaceChars ["."]["-"] name}.zip";
-    sha256 = "0p353lhhcv3swwn1bl64vkyjk480vv9ghhlyqjxiar4p3xifjayb";
+    sha256 = "0zwmhspmqb0a7cm6k6i0s6q3w19ws1g9dx3cp2v3g3vsif6cdh31";
   };
 
-  buildInputs = [ unzip ];
+  buildInputs = [ unzip makeWrapper ];
 
   # The -Xmx1000M comes suggested from their download page:
   # http://www.cs.waikato.ac.nz/ml/weka/downloading.html
   installPhase = ''
-    mkdir -pv $out/share/weka $out/bin
+    mkdir -pv $out/share/weka
     cp -Rv * $out/share/weka
 
-    cat > $out/bin/weka << EOF
-    #!${stdenv.shell}
-    ${jre}/bin/java -Xmx1000M -jar $out/share/weka/weka.jar
-    EOF
-
-    chmod +x $out/bin/weka
+    makeWrapper ${jre}/bin/java $out/bin/weka \
+      --add-flags "-Xmx1000M -jar $out/share/weka/weka.jar"
   '';
 
   meta = {

pkgs/applications/search/catfish/default.nix

···
       options.
     '';
     license = licenses.gpl2Plus;
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     maintainers = [ maintainers.romildo ];
   };
 }

pkgs/applications/version-management/bugseverywhere/default.nix

···
         homepage = http://www.bugseverywhere.org/;
         license = licenses.gpl2Plus;
         platforms = platforms.all;
-        maintainers = [ maintainers.matthiasbeyer ];
+        maintainers = [ ];
     };
 }
 

pkgs/applications/version-management/git-and-tools/git-dit/default.nix

···
     inherit (src.meta) homepage;
     description = "Decentralized Issue Tracking for git";
     license = licenses.gpl2;
-    maintainers = with maintainers; [ Profpatsch matthiasbeyer ];
+    maintainers = with maintainers; [ Profpatsch ];
   };
 }

pkgs/applications/video/obs-studio/default.nix

···
   optional = stdenv.lib.optional;
 in stdenv.mkDerivation rec {
   name = "obs-studio-${version}";
-  version = "21.0.3";
+  version = "21.1.1";
 
   src = fetchFromGitHub {
     owner = "jp9000";
     repo = "obs-studio";
     rev = "${version}";
-    sha256 = "1mrihhzlsc66w5lr1lcm8c8jg6z0iwmmckr3pk3gk92z4s55969q";
+    sha256 = "11gr4szjypihp0562r23pvkmaln6vjz1z4y4ls34bmc8n9ixrdcv";
   };
 
   patches = [ ./find-xcb.patch ];

pkgs/applications/virtualization/qemu/riscv-initrd.patch

···
-From 44b0f612499764dad425d467aadacb01fbd4a920 Mon Sep 17 00:00:00 2001
-From: Shea Levy <[e-mail]>
-Date: Tue, 20 Feb 2018 07:59:43 -0500
-Subject: [PATCH] riscv: Respect the -initrd flag.
-
-Logic for initrd start address borrowed from arm/boot.c
----
- hw/riscv/virt.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++---
- 1 file changed, 46 insertions(+), 3 deletions(-)
-
-diff --git a/hw/riscv/virt.c b/hw/riscv/virt.c
-index 46d95b2b79..5c7d191a3f 100644
---- a/hw/riscv/virt.c
-+++ b/hw/riscv/virt.c
-@@ -77,7 +77,35 @@ static uint64_t load_kernel(const char *kernel_filename)
-     return kernel_entry;
- }
- 
--static void create_fdt(RISCVVirtState *s, const struct MemmapEntry *memmap,
-+static hwaddr load_initrd(const char *filename, uint64_t mem_size,
-+                          uint64_t kernel_entry, hwaddr *start)
-+{
-+    int size;
-+
-+    /* We want to put the initrd far enough into RAM that when the
-+     * kernel is uncompressed it will not clobber the initrd. However
-+     * on boards without much RAM we must ensure that we still leave
-+     * enough room for a decent sized initrd, and on boards with large
-+     * amounts of RAM we must avoid the initrd being so far up in RAM
-+     * that it is outside lowmem and inaccessible to the kernel.
-+     * So for boards with less  than 256MB of RAM we put the initrd
-+     * halfway into RAM, and for boards with 256MB of RAM or more we put
-+     * the initrd at 128MB.
-+     */
-+    *start = kernel_entry + MIN(mem_size / 2, 128 * 1024 * 1024);
-+
-+    size = load_ramdisk(filename, *start, mem_size - *start);
-+    if (size == -1) {
-+        size = load_image_targphys(filename, *start, mem_size - *start);
-+        if (size == -1) {
-+          error_report("qemu: could not load ramdisk '%s'", filename);
-+          exit(1);
-+        }
-+    }
-+    return *start + size;
-+}
-+
-+static void *create_fdt(RISCVVirtState *s, const struct MemmapEntry *memmap,
-     uint64_t mem_size, const char *cmdline)
- {
-     void *fdt;
-@@ -233,6 +261,8 @@ static void create_fdt(RISCVVirtState *s, const struct MemmapEntry *memmap,
-     qemu_fdt_setprop_string(fdt, "/chosen", "stdout-path", nodename);
-     qemu_fdt_setprop_string(fdt, "/chosen", "bootargs", cmdline);
-     g_free(nodename);
-+
-+    return fdt;
- }
- 
- static void riscv_virt_board_init(MachineState *machine)
-@@ -246,6 +276,7 @@ static void riscv_virt_board_init(MachineState *machine)
-     char *plic_hart_config;
-     size_t plic_hart_config_len;
-     int i;
-+    void *fdt;
- 
-     /* Initialize SOC */
-     object_initialize(&s->soc, sizeof(s->soc), TYPE_RISCV_HART_ARRAY);
-@@ -265,7 +296,8 @@ static void riscv_virt_board_init(MachineState *machine)
-         main_mem);
- 
-     /* create device tree */
--    create_fdt(s, memmap, machine->ram_size, machine->kernel_cmdline);
-+    fdt = create_fdt(s, memmap, machine->ram_size,
-+                     machine->kernel_cmdline);
- 
-     /* boot rom */
-     memory_region_init_ram(boot_rom, NULL, "riscv_virt_board.bootrom",
-@@ -273,7 +305,18 @@ static void riscv_virt_board_init(MachineState *machine)
-     memory_region_add_subregion(system_memory, 0x0, boot_rom);
- 
-     if (machine->kernel_filename) {
--        load_kernel(machine->kernel_filename);
-+        uint64_t kernel_entry = load_kernel(machine->kernel_filename);
-+
-+        if (machine->initrd_filename) {
-+            hwaddr start;
-+            hwaddr end = load_initrd(machine->initrd_filename,
-+                                     machine->ram_size, kernel_entry,
-+                                     &start);
-+            qemu_fdt_setprop_cell(fdt, "/chosen",
-+                                  "linux,initrd-start", start);
-+            qemu_fdt_setprop_cell(fdt, "/chosen", "linux,initrd-end",
-+                                  end);
-+        }
-     }
- 
-     /* reset vector */

pkgs/applications/virtualization/qemu/riscv.nix

···
 { qemu, fetchFromGitHub, lib }: let
   src = fetchFromGitHub {
-    owner = "riscv";
-    repo = "riscv-qemu";
-    rev = "af435b709d4a5de3ec2e59ff4dcd05b0b295a730";
-    sha256 = "1kqcsn8yfdg3zyd991i4v5dxznd1l4a4hjry9304lvsm3sz2wllw";
+    owner  = "riscv";
+    repo   = "riscv-qemu";
+    rev    = "f733c7b5f86147216e14aff90c03ccdd76056bef";
+    sha256 = "1ppr9qqwi7qqh8m6dgk1hrzg8zri240il27l67vfayd8ijagb9zq";
     fetchSubmodules = true;
   };
-  version = "2.11.50";
-  revCount = "58771";
-  shortRev = "af435b709d";
+  version = "2.11.92";
+  revCount = "60378";
+  shortRev = builtins.substring 0 9 src.rev;
   targets = [ "riscv32-linux-user" "riscv32-softmmu"
               "riscv64-linux-user" "riscv64-softmmu"
             ];
 in lib.overrideDerivation qemu (orig: {
   name = "${(builtins.parseDrvName qemu.name).name}-${version}pre${revCount}_${shortRev}";
   inherit src;
-  # https://github.com/riscv/riscv-qemu/pull/109
-  patches = [ ./no-etc-install.patch ./statfs-flags.patch ./riscv-initrd.patch ];
+# <<<<<<< HEAD
+#   # https://github.com/riscv/riscv-qemu/pull/109
+#   patches = [ ./no-etc-install.patch ./statfs-flags.patch ./riscv-initrd.patch ];
+# =======
+  # The pulseaudio and statfs patches are in 2.12.0+, which this is based on
+  patches = [
+    ./force-uid0-on-9p.patch
+    ./no-etc-install.patch
+  ];
+
   configureFlags = orig.configureFlags ++ [ "--target-list=${lib.concatStringsSep "," targets}" ];
   postInstall = null;
 })

pkgs/applications/window-managers/icewm/default.nix

···
     homepage = http://www.icewm.org/;
     license = licenses.lgpl2;
     maintainers = [ maintainers.AndersonTorres ];
-    platforms = platforms.unix;
+    platforms = platforms.linux;
   };
 }

pkgs/build-support/rust/default.nix

···
     inherit stdenv cacert git rust cargo-vendor;
   };
 in
-{ name, cargoSha256 ? null
+{ name, cargoSha256 ? "unset"
 , src ? null
 , srcs ? null
 , sourceRoot ? null
···
 , cargoVendorDir ? null
 , ... } @ args:
 
-assert cargoVendorDir == null -> cargoSha256 != null;
+assert cargoVendorDir == null -> cargoSha256 != "unset";
 
 let
   lib = stdenv.lib;

pkgs/data/fonts/emojione/default.nix

···
     description = "Open source emoji set";
     homepage = http://emojione.com/;
     license = licenses.cc-by-40;
-    platforms = platforms.all;
+    platforms = platforms.linux;
     maintainers = with maintainers; [ abbradar ];
   };
 }

pkgs/desktops/mate/mate-calc/default.nix

···
     description = "Calculator for the MATE desktop";
     homepage = http://mate-desktop.org;
     license = [ licenses.gpl2Plus ];
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     maintainers = [ maintainers.romildo ];
   };
 }

pkgs/desktops/mate/mate-icon-theme/default.nix

···
   nativeBuildInputs = [ pkgconfig intltool iconnamingutils ];
 
   buildInputs = [ librsvg hicolor-icon-theme ];
-  
+
   postInstall = ''
     for theme in "$out"/share/icons/*; do
       "${gtk3.out}/bin/gtk-update-icon-cache" "$theme"
     done
   '';
-  
+
   meta = {
     description = "Icon themes from MATE";
     homepage = http://mate-desktop.org;
     license = stdenv.lib.licenses.lgpl3;
-    platforms = stdenv.lib.platforms.unix;
+    platforms = stdenv.lib.platforms.linux;
     maintainers = [ stdenv.lib.maintainers.romildo ];
   };
 }

pkgs/desktops/xfce/panel-plugins/xfce4-mailwatch-plugin.nix

···
     homepage = "http://goodies.xfce.org/projects/panel-plugins/${p_name}";
     description = "Mailwatch plugin for Xfce panel";
     platforms = platforms.linux;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
   };
 }

pkgs/desktops/xfce/panel-plugins/xfce4-mpc-plugin.nix

···
     homepage = "http://goodies.xfce.org/projects/panel-plugins/${p_name}";
     description = "MPD plugin for Xfce panel";
     platforms = platforms.linux;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
   };
 }

pkgs/desktops/xfce/panel-plugins/xfce4-timer-plugin.nix

···
     description = "Battery plugin for Xfce panel";
     platforms = platforms.linux;
     license = licenses.gpl2;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
   };
 }

pkgs/development/compilers/ghcjs/base.nix

···
   description = "A Haskell to JavaScript compiler that uses the GHC API";
   license = stdenv.lib.licenses.bsd3;
   platforms = ghc.meta.platforms;
-  maintainers = with stdenv.lib.maintainers; [ jwiegley cstrahan dmjio ];
+  maintainers = with stdenv.lib.maintainers; [ jwiegley cstrahan dmjio elvishjerricco ];
   hydraPlatforms = if broken then [] else ghc.meta.platforms;
   inherit broken;
 })

pkgs/development/compilers/julia/0.6.nix

···
   '';
 
   postInstall = ''
-    for prog in "$out/bin/julia" "$out/bin/julia-debug"; do
-        wrapProgram "$prog" \
-            --prefix LD_LIBRARY_PATH : "$LD_LIBRARY_PATH:$out/lib/julia" \
-            --prefix PATH : "${stdenv.lib.makeBinPath [ curl ]}"
+    # Symlink shared libraries from LD_LIBRARY_PATH into lib/julia,
+    # as using a wrapper with LD_LIBRARY_PATH causes segmentation
+    # faults when program returns an error:
+    #   $ julia -e 'throw(Error())'
+    find $(echo $LD_LIBRARY_PATH | sed 's|:| |g') -maxdepth 1 -name '*.${if stdenv.isDarwin then "dylib" else "so"}*' | while read lib; do
+      if [[ ! -e $out/lib/julia/$(basename $lib) ]]; then
+        ln -sv $lib $out/lib/julia/$(basename $lib)
+      fi
     done
   '';
 

pkgs/development/guile-modules/guile-fibers/default.nix

···
     homepage = https://github.com/wingo/fibers;
     license = licenses.lgpl3Plus;
     maintainers = with maintainers; [ vyp ];
-    platforms = platforms.all;
+    platforms = platforms.linux;
   };
 }

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

···
   });
 
 }
+
+//
+
+(let
+  amazonkaOverrides = self: super: {
+    conduit = self.conduit_1_2_13_1;
+    conduit-extra = self.conduit-extra_1_2_3_2;
+    resourcet = self.resourcet_1_1_11;
+    xml-conduit = self.xml-conduit_1_7_1_2;
+    http-conduit = self.http-conduit_2_2_4;
+  };
+  amazonka-core = super.amazonka-core.overrideScope amazonkaOverrides;
+  amazonka = super.amazonka.overrideScope amazonkaOverrides;
+  amazonka-test = super.amazonka-test.overrideScope amazonkaOverrides;
+in {
+  inherit amazonka amazonka-core amazonka-test;
+})

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

···
   gtk3 = disableHardening (super.gtk3.override { inherit (pkgs) gtk3; }) ["fortify"];
   gtk = disableHardening (addPkgconfigDepend (addBuildTool super.gtk self.gtk2hs-buildtools) pkgs.gtk2) ["fortify"];
   gtksourceview2 = addPkgconfigDepend super.gtksourceview2 pkgs.gtk2;
+  gtk-traymanager = addPkgconfigDepend super.gtk-traymanager pkgs.gtk3;
 
   # Need WebkitGTK, not just webkit.
   webkit = super.webkit.override { webkit = pkgs.webkitgtk24x-gtk2; };

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

···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "AlgoRhythm" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default, derive
+     , directory, Euterpea, HCodecs, HUnit, kmeans, lilypond, midi, mtl
+     , prettify, QuickCheck, random, template-haskell, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "AlgoRhythm";
+       version = "0.1.0.0";
+       sha256 = "03rmcafbnbb43fww1y6rfi8dpbl85yi71rjxmz7mqxh4zn5c9jwz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-default derive Euterpea HCodecs kmeans
+         lilypond midi mtl prettify QuickCheck random template-haskell text
+         transformers
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base bytestring derive directory Euterpea HCodecs HUnit lilypond
+         QuickCheck random test-framework test-framework-hunit
+         test-framework-quickcheck2 transformers
+       ];
+       homepage = "http://github.com/omelkonian/AlgoRhythm/";
+       description = "Algorithmic music composition";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "AlgorithmW" = callPackage
     ({ mkDerivation, base, containers, mtl, pretty }:
      mkDerivation {
···
        pname = "JuicyPixels-scale-dct";
        version = "0.1.1.2";
        sha256 = "15py0slh1jij8wrd68q0fqs9yarnabr470xm04i92904a809vgcs";
-       revision = "2";
-       editedCabalFile = "04g0yga3v0922aysqv2m2h7vxbaaxfdb7lafsakpzlp0w659f930";
+       revision = "3";
+       editedCabalFile = "0z1ks049q9jsc5ysh12idkqf3rz0bnvv74rhlaw24r5q2xj8lv8i";
        libraryHaskellDepends = [
          base base-compat carray fft JuicyPixels
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "ONC-RPC" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, cereal, containers
+     , filepath, haskell-src-exts, network, parsec, random, time, unix
+     , vector
+     }:
+     mkDerivation {
+       pname = "ONC-RPC";
+       version = "0.1";
+       sha256 = "19smd0rp0jx9i59jgjk149g4czpwjx173szhp1z9dvm5j0pdwyy5";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [
+         base bytestring Cabal cereal containers filepath haskell-src-exts
+         parsec vector
+       ];
+       libraryHaskellDepends = [
+         base bytestring Cabal cereal containers filepath haskell-src-exts
+         network parsec random time unix vector
+       ];
+       executableHaskellDepends = [ base filepath ];
+       description = "ONC RPC (aka Sun RPC) and XDR library";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "OSM" = callPackage
     ({ mkDerivation, base, comonad-transformers, containers, data-lens
      , hxt, newtype
···
      }) {};
 
   "OddWord" = callPackage
-    ({ mkDerivation, base, QuickCheck }:
+    ({ mkDerivation, base, criterion, QuickCheck }:
      mkDerivation {
        pname = "OddWord";
-       version = "1.0.1.0";
-       sha256 = "0aa3pp2ivbddn3632cnkxd3bj8373ns1nf4v2jvz7zcijiz4chx1";
+       version = "1.0.1.1";
+       sha256 = "0sb0hmvvp6cdxf8siqfp7wvcxq8rbiz7h9mxmbkcksscjp8m02mm";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
+       benchmarkHaskellDepends = [ base criterion ];
        homepage = "http://www.gekkou.co.uk/";
        description = "Provides a wrapper for deriving word types with fewer bits";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "YamlReference" = callPackage
-    ({ mkDerivation, base, bytestring, containers, directory, dlist
-     , hashmap, HUnit, mtl, regex-compat
+    ({ mkDerivation, base, bytestring, Cabal, containers, directory
+     , dlist, hashmap, HUnit, mtl, regex-compat
      }:
      mkDerivation {
        pname = "YamlReference";
        version = "0.10.0";
        sha256 = "01cjddbg98vs1bd66n0v58i415kqn7cfi6cslk384p7j2ivwv2ad";
-       revision = "1";
-       editedCabalFile = "1pcrd8ww4fm9big1bcafkmsl9kifixkyny9b3z172w8yhamk2wwq";
+       revision = "2";
+       editedCabalFile = "023997365188qvgrfg8wshmmlrjr7z435329pxcsvmfcywnc739a";
        isLibrary = true;
        isExecutable = true;
+       setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base bytestring containers dlist regex-compat
        ];
···
        homepage = "http://www.haskell.org/haskellwiki/Yampa";
        description = "Library for programming hybrid systems";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "Yampa_0_11" = callPackage
+    ({ mkDerivation, base, deepseq, random }:
+     mkDerivation {
+       pname = "Yampa";
+       version = "0.11";
+       sha256 = "0frybgsj73r57rd6ckv9pgd9ff1g72qrlad90plb13cf2s6jdp3f";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base deepseq random ];
+       testHaskellDepends = [ base ];
+       homepage = "http://www.haskell.org/haskellwiki/Yampa";
+       description = "Library for programming hybrid systems";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "Yampa-core" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "accelerate-bignum_0_2_0_0" = callPackage
+    ({ mkDerivation, accelerate, accelerate-io, accelerate-llvm
+     , accelerate-llvm-native, accelerate-llvm-ptx, base, criterion
+     , ghc-prim, hedgehog, llvm-hs-pure, mwc-random, tasty
+     , tasty-hedgehog, template-haskell, vector, vector-th-unbox
+     , wide-word
+     }:
+     mkDerivation {
+       pname = "accelerate-bignum";
+       version = "0.2.0.0";
+       sha256 = "0xhnd39fb17kb7q5z9z8svn8zlv6j1wxrbkv3vij4f1q2hkqkl0p";
+       libraryHaskellDepends = [
+         accelerate accelerate-llvm accelerate-llvm-native
+         accelerate-llvm-ptx base ghc-prim llvm-hs-pure template-haskell
+       ];
+       testHaskellDepends = [
+         accelerate accelerate-llvm-native accelerate-llvm-ptx base hedgehog
+         tasty tasty-hedgehog
+       ];
+       benchmarkHaskellDepends = [
+         accelerate accelerate-io accelerate-llvm-native accelerate-llvm-ptx
+         base criterion mwc-random vector vector-th-unbox wide-word
+       ];
+       homepage = "https://github.com/tmcdonell/accelerate-bignum";
+       description = "Fixed-length large integer arithmetic for Accelerate";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "accelerate-blas" = callPackage
     ({ mkDerivation, accelerate, accelerate-llvm
      , accelerate-llvm-native, accelerate-llvm-ptx, base, blas-hs
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "accelerate-blas_0_2_0_0" = callPackage
+    ({ mkDerivation, accelerate, accelerate-llvm
+     , accelerate-llvm-native, accelerate-llvm-ptx, base, blas-hs
+     , bytestring, containers, criterion, cublas, cuda, deepseq
+     , file-embed, hedgehog, hmatrix, llvm-hs-pure, mtl, mwc-random
+     , mwc-random-accelerate, tasty, tasty-hedgehog
+     }:
+     mkDerivation {
+       pname = "accelerate-blas";
+       version = "0.2.0.0";
+       sha256 = "0y77wsdw0i7b5bzlfrrn9q4d8q95r8z71g8qy77n24db1pwmjqy9";
+       libraryHaskellDepends = [
+         accelerate accelerate-llvm accelerate-llvm-native
+         accelerate-llvm-ptx base blas-hs bytestring containers cublas cuda
+         file-embed llvm-hs-pure mtl
+       ];
+       testHaskellDepends = [
+         accelerate accelerate-llvm-native accelerate-llvm-ptx base hedgehog
+         tasty tasty-hedgehog
+       ];
+       benchmarkHaskellDepends = [
+         accelerate accelerate-llvm-native accelerate-llvm-ptx base
+         criterion deepseq hmatrix mwc-random mwc-random-accelerate
+       ];
+       description = "Numeric Linear Algebra in Accelerate";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "accelerate-cublas" = callPackage
     ({ mkDerivation, accelerate, accelerate-arithmetic, accelerate-cuda
      , accelerate-io, accelerate-utility, base, cublas, cuda, hmatrix
···
 
   "accelerate-examples" = callPackage
     ({ mkDerivation, accelerate, accelerate-fft, accelerate-io
-     , accelerate-llvm-native, accelerate-llvm-ptx, ansi-wl-pprint
-     , array, base, binary, bmp, bytestring, bytestring-lexing, cereal
+     , accelerate-llvm-native, accelerate-llvm-ptx, ansi-wl-pprint, base
+     , binary, bmp, bytestring, bytestring-lexing, cereal
      , colour-accelerate, containers, criterion, directory, fclabels
      , filepath, gloss, gloss-accelerate, gloss-raster-accelerate
      , gloss-rendering, HUnit, lens-accelerate, linear
      , linear-accelerate, matrix-market-attoparsec, mwc-random
-     , normaldistribution, pipes, QuickCheck, random, repa, repa-io
-     , scientific, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, vector, vector-algorithms
+     , normaldistribution, QuickCheck, random, repa, repa-io, scientific
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , vector, vector-algorithms
      }:
      mkDerivation {
        pname = "accelerate-examples";
-       version = "1.1.0.0";
-       sha256 = "0zpjmk6v314jfda7fy22xghfqlqfh8vyf938qwyp6xjf1mpq1r1x";
-       revision = "3";
-       editedCabalFile = "1ir5i8skpyzpvwa17yw02j9rn9c5qjjincwrnjdwaixcdc7lsy4b";
+       version = "1.2.0.0";
+       sha256 = "1gb4m1ri461f78x913ipxh14ybwl9wzbv81w8943whiwrmb3p5pc";
        configureFlags = [ "-f-opencl" ];
        isLibrary = true;
        isExecutable = true;
···
          test-framework-quickcheck2
        ];
        executableHaskellDepends = [
-         accelerate accelerate-fft accelerate-io array base binary bmp
-         bytestring bytestring-lexing cereal colour-accelerate containers
-         criterion directory fclabels filepath gloss gloss-accelerate
-         gloss-raster-accelerate gloss-rendering HUnit lens-accelerate
+         accelerate accelerate-fft accelerate-io base binary bmp bytestring
+         bytestring-lexing cereal colour-accelerate containers criterion
+         directory fclabels filepath gloss gloss-accelerate
+         gloss-raster-accelerate gloss-rendering lens-accelerate
          linear-accelerate matrix-market-attoparsec mwc-random
-         normaldistribution pipes QuickCheck random repa repa-io scientific
-         test-framework test-framework-hunit test-framework-quickcheck2
-         vector vector-algorithms
+         normaldistribution random repa repa-io scientific vector
+         vector-algorithms
        ];
        homepage = "https://github.com/AccelerateHS/accelerate-examples";
        description = "Examples using the Accelerate library";
···
          accelerate accelerate-llvm accelerate-llvm-native
          accelerate-llvm-ptx base bytestring carray cuda cufft fft
          file-embed storable-complex
+       ];
+       homepage = "https://github.com/AccelerateHS/accelerate-fft";
+       description = "FFT using the Accelerate library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "accelerate-fft_1_2_0_0" = callPackage
+    ({ mkDerivation, accelerate, accelerate-llvm
+     , accelerate-llvm-native, accelerate-llvm-ptx, base, bytestring
+     , carray, containers, cuda, cufft, fft, file-embed, hashable
+     , hedgehog, lens-accelerate, mtl, tasty, tasty-hedgehog
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "accelerate-fft";
+       version = "1.2.0.0";
+       sha256 = "19p9d59vdd3nq97xjprlb6fz2ajlk6gl37cdyvrm9inag4nnk6lp";
+       libraryHaskellDepends = [
+         accelerate accelerate-llvm accelerate-llvm-native
+         accelerate-llvm-ptx base bytestring carray containers cuda cufft
+         fft file-embed hashable lens-accelerate mtl unordered-containers
+       ];
+       testHaskellDepends = [
+         accelerate accelerate-llvm-native accelerate-llvm-ptx base hedgehog
+         tasty tasty-hedgehog
        ];
        homepage = "https://github.com/AccelerateHS/accelerate-fft";
        description = "FFT using the Accelerate library";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "accelerate-io_1_2_0_0" = callPackage
+    ({ mkDerivation, accelerate, array, base, bmp, bytestring, hedgehog
+     , primitive, repa, tasty, tasty-hedgehog, vector
+     }:
+     mkDerivation {
+       pname = "accelerate-io";
+       version = "1.2.0.0";
+       sha256 = "13pqqsd5pbxmgsxnp9w141mnwscnlmbhxaz6f5jx4ssipnma2pwf";
+       libraryHaskellDepends = [
+         accelerate array base bmp bytestring primitive repa vector
+       ];
+       testHaskellDepends = [
+         accelerate array base hedgehog tasty tasty-hedgehog vector
+       ];
+       homepage = "https://github.com/AccelerateHS/accelerate-io";
+       description = "Read and write Accelerate arrays in various formats";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "accelerate-llvm" = callPackage
     ({ mkDerivation, abstract-deque, accelerate, base, bytestring
      , chaselev-deque, containers, data-default-class, deepseq
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "aeson_1_3_0_0" = callPackage
+  "aeson_1_3_1_0" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat, base-orphans
      , base16-bytestring, bytestring, containers, deepseq, directory
      , dlist, filepath, generic-deriving, ghc-prim, hashable
···
      }:
      mkDerivation {
        pname = "aeson";
-       version = "1.3.0.0";
-       sha256 = "1glrwccp5hi9zn8d34761zinvpmbd4dsbgzqg2qxk6glp928phna";
+       version = "1.3.1.0";
+       sha256 = "0ljndkgibz3qbddz2451v1r9w8i440kpslg3al3m7gc82mxz2xrr";
        libraryHaskellDepends = [
          attoparsec base base-compat bytestring containers deepseq dlist
          ghc-prim hashable scientific tagged template-haskell text
···
 
   "aivika" = callPackage
     ({ mkDerivation, array, base, binary, containers, deepseq, mtl
-     , mwc-random, random, vector
+     , mwc-random, random, semigroups, vector
      }:
      mkDerivation {
        pname = "aivika";
-       version = "5.5";
-       sha256 = "0phzdgdxcdzdvgllp7c3b8bffdr8xhpid0yify7yrpnxc4y4rw5s";
+       version = "5.6";
+       sha256 = "0gri5kwzw2a9fjcr7924kdaxgs9zl4j8brgknwyxrky0p93a8zry";
        libraryHaskellDepends = [
-         array base binary containers deepseq mtl mwc-random random vector
+         array base binary containers deepseq mtl mwc-random random
+         semigroups vector
        ];
        homepage = "http://www.aivikasoft.com";
        description = "A multi-method simulation library";
···
 
   "aivika-transformers" = callPackage
     ({ mkDerivation, aivika, array, base, containers, mtl, mwc-random
-     , random, vector
+     , random, semigroups, vector
      }:
      mkDerivation {
        pname = "aivika-transformers";
-       version = "5.5";
-       sha256 = "09q221ayhfx5h51cc0h8lsx4b1cnzk3bssr5bf28xixaf3j4faj5";
+       version = "5.6";
+       sha256 = "0vy3d4vldifiwc12j6746axhb1k3ir703wzgycvk4xn60qhjp4g9";
        libraryHaskellDepends = [
-         aivika array base containers mtl mwc-random random vector
+         aivika array base containers mtl mwc-random random semigroups
+         vector
        ];
        homepage = "http://www.aivikasoft.com";
        description = "Transformers for the Aivika simulation library";
···
      }:
      mkDerivation {
        pname = "argon2";
-       version = "1.3.0.0";
-       sha256 = "0sszifmi74b2n19d4f5f30pfnivqm6n1jdwf2j402schkd1wz7cp";
+       version = "1.3.0.1";
+       sha256 = "1v0clf78hykdyhv81z8v3kwp86hjgqh6b8a7wfbjv0fyy55bwxry";
        libraryHaskellDepends = [ base bytestring deepseq text-short ];
        testHaskellDepends = [
          base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
···
        pname = "attoparsec-iso8601";
        version = "1.0.0.0";
        sha256 = "12l55b76bhya9q89mfmqmy6sl5v39b6gzrw5rf3f70vkb23nsv5a";
+       revision = "1";
+       editedCabalFile = "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4";
        libraryHaskellDepends = [ attoparsec base base-compat text time ];
        homepage = "https://github.com/bos/aeson";
        description = "Parsing of ISO 8601 dates, originally from aeson";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "b9_0_5_43" = callPackage
+    ({ mkDerivation, aeson, async, base, bifunctors, binary, boxes
+     , bytestring, conduit, conduit-extra, ConfigFile, directory
+     , filepath, free, hashable, hspec, hspec-expectations, lens, mtl
+     , optparse-applicative, parallel, parsec, pretty, pretty-show
+     , process, QuickCheck, random, shake, syb, template, text, time
+     , transformers, unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "b9";
+       version = "0.5.43";
+       sha256 = "168rgqqnxi8f39dg510nxlh813ch4dkdxxd4rymf09dkn87w1snk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async base bifunctors binary boxes bytestring conduit
+         conduit-extra ConfigFile directory filepath free hashable lens mtl
+         parallel parsec pretty pretty-show process QuickCheck random shake
+         syb template text time transformers unordered-containers vector
+         yaml
+       ];
+       executableHaskellDepends = [
+         base bytestring directory lens optparse-applicative
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec hspec-expectations QuickCheck text
+         unordered-containers vector yaml
+       ];
+       homepage = "https://github.com/sheyll/b9-vm-image-builder";
+       description = "A tool and library for building virtual machine images";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "babl" = callPackage
     ({ mkDerivation, babl, base }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "base-compat_0_10_0" = callPackage
+    ({ mkDerivation, base, unix }:
+     mkDerivation {
+       pname = "base-compat";
+       version = "0.10.0";
+       sha256 = "0s46gkixvnafc9rj7sqn4m6bl0457myhn8lp65d5s579zrj8y43i";
+       libraryHaskellDepends = [ base unix ];
+       description = "A compatibility layer for base";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "base-compat-batteries" = callPackage
+    ({ mkDerivation, base, base-compat, hspec, hspec-discover
+     , QuickCheck
+     }:
+     mkDerivation {
+       pname = "base-compat-batteries";
+       version = "0.10.0";
+       sha256 = "0zyhl2yfycwcgvf8kh8g3y8zkp21b0wd4nnhvgjdcw11gn6nb26x";
+       libraryHaskellDepends = [ base base-compat ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "base-compat with extra batteries";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "base-encoding" = callPackage
     ({ mkDerivation, base, base16-bytestring, base64-bytestring
      , bytestring, text
···
      }:
      mkDerivation {
        pname = "battleplace";
-       version = "0.1.0.0";
-       sha256 = "1p3dxz8a752wc6fmj6kip4gcwj77c96ic5wzlhgv670xsh4ac1qg";
+       version = "0.1.0.1";
+       sha256 = "1zjjmz36lxxrxgx449212q878mzavjpwx5jad0lk9ninpas16h5v";
        libraryHaskellDepends = [
          aeson base bytestring cereal data-default hashable memory servant
          text vector
···
 
   "beam-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, dlist, free
-     , ghc-prim, hashable, microlens, mtl, network-uri, tasty
+     , ghc-prim, hashable, microlens, mtl, network-uri, tagged, tasty
      , tasty-hunit, text, time, vector-sized
      }:
      mkDerivation {
        pname = "beam-core";
-       version = "0.6.0.0";
-       sha256 = "1pnxmy5xv84fng0391cckizwdrwzh0p0v3g0vc29z5vpksqr24kg";
+       version = "0.7.0.0";
+       sha256 = "1qpgcr5a1r7ck0mxh70akz32zb4vm30is2dpsxgcdza5zshmnvcb";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist free ghc-prim hashable
-         microlens mtl network-uri text time vector-sized
+         microlens mtl network-uri tagged text time vector-sized
        ];
        testHaskellDepends = [
          base bytestring tasty tasty-hunit text time
···
      }:
      mkDerivation {
        pname = "bits-extra";
-       version = "0.0.0.1";
-       sha256 = "1yggdh8j2hqhyskyqq4gci4hg1kdglzw7sfd7gdf4fsw9l6g8rq0";
-       revision = "1";
-       editedCabalFile = "13rmw51xqbz0zjn2g0135m2f5qqsba3l5w02pb16dkfq4gbhmblx";
+       version = "0.0.0.2";
+       sha256 = "067k2kczi56454mgv86x9r0fpzdc0v3m8z4rc0jb93bqd33knq7r";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [
          base ghc-prim hedgehog hspec hw-hedgehog hw-hspec-hedgehog
···
      }) {};
 
   "blank-canvas" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
-     , bytestring, colour, containers, data-default-class, directory
-     , http-types, kansas-comet, mime-types, process, scotty, semigroups
-     , shake, stm, text, text-show, time, transformers, unix, vector
-     , wai, wai-extra, warp
+    ({ mkDerivation, aeson, base, base-compat-batteries
+     , base64-bytestring, bytestring, colour, containers
+     , data-default-class, directory, http-types, kansas-comet
+     , mime-types, process, scotty, semigroups, shake, stm, text
+     , text-show, time, transformers, unix, vector, wai, wai-extra, warp
      }:
      mkDerivation {
        pname = "blank-canvas";
-       version = "0.6.2";
-       sha256 = "1qhdvxia8wlnv0ss9dsrxdfw3qsf376ypnpsijz7vxkj9dmzyq84";
-       revision = "3";
-       editedCabalFile = "0fanap927iszy3vkymkjcmzd74gripbbp222zcmzl5gkn3l4g931";
+       version = "0.6.3";
+       sha256 = "1d10ngvsgi2hz6xick59rkq1wzfbsgckply2jmg6gz9mf3zj97bk";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson base base-compat base64-bytestring bytestring colour
-         containers data-default-class http-types kansas-comet mime-types
-         scotty semigroups stm text text-show transformers vector wai
-         wai-extra warp
+         aeson base base-compat-batteries base64-bytestring bytestring
+         colour containers data-default-class http-types kansas-comet
+         mime-types scotty semigroups stm text text-show transformers vector
+         wai wai-extra warp
        ];
        testHaskellDepends = [
-         base containers directory process shake stm text time unix vector
+         base base-compat-batteries containers directory process shake stm
+         text time unix vector
        ];
        homepage = "https://github.com/ku-fpg/blank-canvas/wiki";
        description = "HTML5 Canvas Graphics Library";
···
        pname = "brittany";
        version = "0.9.0.1";
        sha256 = "1ndmnakzq6kiyxlxmgrjmzzpknrn4ib5ck5vxxr90qw8rw6yqi88";
+       revision = "1";
+       editedCabalFile = "1ac9g160kaaz78xk6xdfpkm0qadgkanjghi8g0b9fy17983fiw7a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "brittany";
        version = "0.10.0.0";
        sha256 = "1fm6l4ial8kp4mafwkp7w79nklc46c07i12p1in3dqxz9r5817r1";
+       revision = "1";
+       editedCabalFile = "1mq1hgakxwzk4k4d8gwfbngprcprjagnvkvq389z1m1vda3w80i8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        homepage = "https://github.com/ekmett/bytes";
        description = "Sharing code for serialization between binary and cereal";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "bytes_0_15_4" = callPackage
+    ({ mkDerivation, base, binary, bytestring, Cabal, cabal-doctest
+     , cereal, containers, directory, doctest, filepath, hashable, mtl
+     , scientific, text, time, transformers, transformers-compat
+     , unordered-containers, void
+     }:
+     mkDerivation {
+       pname = "bytes";
+       version = "0.15.4";
+       sha256 = "121x3iqlm8pghw8cd9g30cnqbl7jrdpfjxdanmqdqllajw6xivrm";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base binary bytestring cereal containers hashable mtl scientific
+         text time transformers transformers-compat unordered-containers
+         void
+       ];
+       testHaskellDepends = [ base directory doctest filepath ];
+       homepage = "https://github.com/ekmett/bytes";
+       description = "Sharing code for serialization between binary and cereal";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "byteset" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "cache_0_1_1_0" = callPackage
+    ({ mkDerivation, base, clock, hashable, hspec, stm, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "cache";
+       version = "0.1.1.0";
+       sha256 = "1zvq5dwckkngf6kzh04pa59kgxf44fx9kli0c7zaz4g9hf1nyx8l";
+       libraryHaskellDepends = [
+         base clock hashable stm transformers unordered-containers
+       ];
+       testHaskellDepends = [ base clock hspec stm transformers ];
+       homepage = "https://github.com/hverr/haskell-cache#readme";
+       description = "An in-memory key/value store with expiration support";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "cached-io" = callPackage
     ({ mkDerivation, base, stm, time, transformers }:
      mkDerivation {
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "casing_0_1_3_0" = callPackage
+  "casing_0_1_4_0" = callPackage
     ({ mkDerivation, base, split, tasty, tasty-hunit }:
      mkDerivation {
        pname = "casing";
-       version = "0.1.3.0";
-       sha256 = "08cklvgm2c2519c4xm22mxfkjmizky8j64a98cqgdgz9rl6ryq9m";
+       version = "0.1.4.0";
+       sha256 = "1mznhlbg8qd2yrjg23rq7s77bijn92nrfx7bvx9sw8sqxwqkd2lf";
        libraryHaskellDepends = [ base split ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Convert between various source code casing conventions";
···
      }:
      mkDerivation {
        pname = "cli-setup";
-       version = "0.2.0.2";
-       sha256 = "1pyfnrmn7jp9n9xjgq43kcr9gz0wnrsrwrg530vi11cc77np8piq";
+       version = "0.2.0.3";
+       sha256 = "1macadfh1dqd6n2cc5rlyn74fz450livy1bg0qns3kcijqilk0p4";
        libraryHaskellDepends = [
          base bytestring directory file-embed process
        ];
···
      }:
      mkDerivation {
        pname = "codec-beam";
-       version = "0.1.0";
-       sha256 = "0c5l4ss3pf55s8mwk01ncl5nnry9c1ha5drfmax53z40hyrxhmy8";
+       version = "0.1.1";
+       sha256 = "1d6dsa4di4wil6wqc2jpfqvf09vk4zw9c2905py5vygl87q1y9jq";
        libraryHaskellDepends = [ base bytestring containers text zlib ];
        testHaskellDepends = [ base bytestring filepath process text ];
        homepage = "https://github.com/hkgumbs/codec-beam#readme";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "colour-accelerate_0_3_0_0" = callPackage
+    ({ mkDerivation, accelerate, base }:
+     mkDerivation {
+       pname = "colour-accelerate";
+       version = "0.3.0.0";
+       sha256 = "0zvzra2w0sajw0hzg2k25khv8c5j1i17g8dnga70w73f3mmh3gbz";
+       libraryHaskellDepends = [ accelerate base ];
+       homepage = "https://github.com/tmcdonell/colour-accelerate";
+       description = "Working with colours in Accelerate";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "colour-space" = callPackage
     ({ mkDerivation, base, colour, constrained-categories, JuicyPixels
      , linear, linearmap-category, manifolds, semigroups, vector-space
···
      }:
      mkDerivation {
        pname = "composite-aeson";
-       version = "0.5.3.0";
-       sha256 = "0pmgrdlrk4l7bmbfvsbvysa3n2h14ca919fl7cr1bg9yk2mb2s7s";
+       description = "A named lock that is created on demand";
+       sha256 = "08rmv82v5ipkcb46pcadx1s8c1v532l8ma2qlgiflq6jnxf7y0zn";
        libraryHaskellDepends = [
          aeson aeson-better-errors base composite-base containers
          contravariant generic-deriving hashable lens mmorph mtl profunctors
···
      }:
      mkDerivation {
        pname = "composite-aeson-refined";
-       version = "0.5.3.0";
-       sha256 = "07ps031qnkhd5yb7w0c9y69n22npa5y9rzxy934p6x32ni5v0mvz";
+       description = "A named lock that is created on demand";
+       sha256 = "1x5vkxzj0afar4w2djx9s7h3vy9aa5my9wfks8n4ajlv92fch1zm";
        libraryHaskellDepends = [
          aeson-better-errors base composite-aeson mtl refined
        ];
···
      }:
      mkDerivation {
        pname = "composite-base";
-       version = "0.5.3.0";
-       sha256 = "0xz264i115nj2b6k74s1csi29lrszambbhy7ibz7nwqr2qs56yzw";
+       description = "A named lock that is created on demand";
+       sha256 = "0brycxdwf4051qvad4b4ak47dl27qn3izv1bcqlpva01jvb6h21j";
        libraryHaskellDepends = [
          base exceptions lens monad-control mtl profunctors template-haskell
          text transformers transformers-base vinyl
···
      }) {};
 
   "composite-ekg" = callPackage
-    ({ mkDerivation, base, composite-base, ekg, ekg-core, lens, text
-     , vinyl
+    ({ mkDerivation, base, composite-base, ekg-core, lens, text, vinyl
      }:
      mkDerivation {
        pname = "composite-ekg";
-       version = "0.5.3.0";
-       sha256 = "0fw6rsz7arndmp9d6xgvkx9vqqrv6kvhgchl0hqv4jfaxhwdv3gc";
+       description = "A named lock that is created on demand";
+       sha256 = "051dw8ncpsk2k05ipvlnkwv2gy6719w69v1hhwrryy3dad0f4wc3";
        libraryHaskellDepends = [
-         base composite-base ekg ekg-core lens text vinyl
+         base composite-base ekg-core lens text vinyl
        ];
        homepage = "https://github.com/ConferHealth/composite#readme";
        description = "EKG Metrics for Vinyl/Frames records";
···
      }:
      mkDerivation {
        pname = "composite-opaleye";
-       version = "0.5.3.0";
-       sha256 = "09sjvs7bxca789pfrhgbsy2v08060mraciwl867byq3s8aq5c971";
+       description = "A named lock that is created on demand";
+       sha256 = "1k71v4dz4vl70ignjp6hgw6j4c9hdgafd9x973dk7w332m2vjdpn";
        libraryHaskellDepends = [
          base bytestring composite-base lens opaleye postgresql-simple
          product-profunctors profunctors template-haskell text vinyl
···
        description = "Opaleye SQL for Frames records";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "composite-swagger" = callPackage
+    ({ mkDerivation, base, composite-aeson, composite-base, hspec
+     , insert-ordered-containers, lens, QuickCheck, swagger2
+     , template-haskell, text, vinyl
+     }:
+     mkDerivation {
+       pname = "composite-swagger";
+       description = "A named lock that is created on demand";
+       sha256 = "0i2jfchl88mrk9kmf8yv7cbv006ghilqsnbic7ddsbkzrjy1vdw0";
+       libraryHaskellDepends = [
+         base composite-base insert-ordered-containers lens swagger2
+         template-haskell text vinyl
+       ];
+       testHaskellDepends = [
+         base composite-aeson composite-base hspec insert-ordered-containers
+         lens QuickCheck swagger2 template-haskell text vinyl
+       ];
+       homepage = "https://github.com/ConferHealth/composite#readme";
+       description = "Swagger for Vinyl/Frames records";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "composition" = callPackage
···
      }) {};
 
   "convert" = callPackage
-    ({ mkDerivation, base, bytestring, containers, either, lens, mtl
-     , old-locale, old-time, template-haskell, text, time
+    ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
+     , data-default, lens, template-haskell, text, utf8-string
      }:
      mkDerivation {
        pname = "convert";
-       version = "1.0.2";
-       sha256 = "0vwy2j2b0jw435mxmi95q61zmldjqlahhlbf4x9x28qm6kmh519q";
+       version = "1.4.2";
+       sha256 = "0lmbshg6nx0ifnc6qmhvacr5lr5nlay3sjkjg2n5624qm7aiq806";
        libraryHaskellDepends = [
-         base bytestring containers either lens mtl old-locale old-time
-         template-haskell text time
+         ansi-wl-pprint base bytestring containers data-default lens
+         template-haskell text utf8-string
        ];
-       homepage = "https://github.com/wdanilo/convert";
+       homepage = "https://github.com/luna/convert";
        description = "Safe and unsafe data conversion utilities with strong type-level operation. checking.";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }) {};
 
   "coordinate" = callPackage
-    ({ mkDerivation, base, directory, doctest, filepath, lens
-     , QuickCheck, template-haskell, transformers
-     }:
+    ({ mkDerivation, base, HUnit, lens, papa, transformers }:
      mkDerivation {
        pname = "coordinate";
-       version = "0.1.2";
-       sha256 = "0lphvgjs9nkrp37hirhi88d285rqbgk7qjz23rbl94v6qrk3x8nv";
-       libraryHaskellDepends = [ base lens transformers ];
-       testHaskellDepends = [
-         base directory doctest filepath QuickCheck template-haskell
-       ];
-       homepage = "https://github.com/NICTA/coordinate";
+       version = "0.2";
+       sha256 = "1sph59d8008amhb4pi4gk8ymwjf2r6iy378phriqb42zy01bn0vb";
+       libraryHaskellDepends = [ base lens papa transformers ];
+       testHaskellDepends = [ base HUnit lens ];
+       homepage = "https://github.com/qfpl/coordinate";
        description = "A representation of latitude and longitude";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        pname = "criterion";
        version = "1.3.0.0";
        sha256 = "0csgk6njr6a3i895d10pajf7z4r9hx8aj2r0c3rj5li6vrm37f8q";
-       revision = "2";
-       editedCabalFile = "1yyv34f9yk8d67x18l1al5csd383ypmdwnz73gq0agmw4k2f9c54";
+       revision = "3";
+       editedCabalFile = "0bdz45r1mf6ydcs7l333xn7da9p583g9y7n3dzvnry4by0fkcqw6";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "criterion_1_4_0_0" = callPackage
-    ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat, binary
-     , bytestring, cassava, code-page, containers, deepseq, directory
-     , exceptions, filepath, Glob, HUnit, js-flot, js-jquery
-     , microstache, mtl, mwc-random, optparse-applicative, parsec
-     , QuickCheck, semigroups, statistics, tasty, tasty-hunit
-     , tasty-quickcheck, text, time, transformers, transformers-compat
-     , vector, vector-algorithms
+  "criterion_1_4_1_0" = callPackage
+    ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat
+     , base-compat-batteries, binary, bytestring, cassava, code-page
+     , containers, deepseq, directory, exceptions, filepath, Glob, HUnit
+     , js-flot, js-jquery, microstache, mtl, mwc-random
+     , optparse-applicative, parsec, QuickCheck, semigroups, statistics
+     , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers
+     , transformers-compat, vector, vector-algorithms
      }:
      mkDerivation {
        pname = "criterion";
-       version = "1.4.0.0";
-       sha256 = "0shsqq36z1q8ckic3nfb3rdbxhlb0faxl5d7ly5a4wlka4fcfrfc";
-       revision = "1";
-       editedCabalFile = "056p7d95ynrpsm5jr479r9xk7ksniqkz4bza0zdn9a8vmrx591qh";
+       version = "1.4.1.0";
+       sha256 = "0v429araqkcw3wwwi6fsp0g7g1hy3l47p061lcy7r4m7d9khd4y4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson ansi-wl-pprint base base-compat binary bytestring cassava
-         code-page containers deepseq directory exceptions filepath Glob
-         js-flot js-jquery microstache mtl mwc-random optparse-applicative
-         parsec semigroups statistics text time transformers
-         transformers-compat vector vector-algorithms
+         aeson ansi-wl-pprint base base-compat-batteries binary bytestring
+         cassava code-page containers deepseq directory exceptions filepath
+         Glob js-flot js-jquery microstache mtl mwc-random
+         optparse-applicative parsec semigroups statistics text time
+         transformers transformers-compat vector vector-algorithms
        ];
        executableHaskellDepends = [
-         base base-compat optparse-applicative semigroups
+         base base-compat-batteries optparse-applicative semigroups
        ];
        testHaskellDepends = [
-         aeson base base-compat bytestring deepseq directory HUnit
-         QuickCheck statistics tasty tasty-hunit tasty-quickcheck vector
+         aeson base base-compat base-compat-batteries bytestring deepseq
+         directory HUnit QuickCheck statistics tasty tasty-hunit
+         tasty-quickcheck vector
        ];
        homepage = "http://www.serpentine.com/criterion";
        description = "Robust, reliable performance measurement and analysis";
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) openssl;};
 
+  "cryptonite-openssl_0_7" = callPackage
+    ({ mkDerivation, base, basement, bytestring, cryptonite, memory
+     , openssl, tasty, tasty-hunit, tasty-kat, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "cryptonite-openssl";
+       version = "0.7";
+       sha256 = "1xj41354dx24rfh6i7av7qamvin34z4g6m1hxw1fc9jg4q41qkly";
+       libraryHaskellDepends = [
+         base basement bytestring cryptonite memory
+       ];
+       librarySystemDepends = [ openssl ];
+       testHaskellDepends = [
+         base bytestring cryptonite tasty tasty-hunit tasty-kat
+         tasty-quickcheck
+       ];
+       homepage = "https://github.com/haskell-crypto/cryptonite-openssl";
+       description = "Crypto stuff using OpenSSL cryptographic library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) openssl;};
+
   "cryptsy-api" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, either
      , http-client, http-client-tls, old-locale, pipes-attoparsec
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "czipwith_1_0_1_0" = callPackage
+    ({ mkDerivation, base, template-haskell, transformers }:
+     mkDerivation {
+       pname = "czipwith";
+       version = "1.0.1.0";
+       sha256 = "0s1gz76789w5grm121fikgrxz1hjca6v6dwmds5zg63j6iir3f0p";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base transformers ];
+       homepage = "https://github.com/lspitzner/czipwith/";
+       description = "CZipWith class and deriving via TH";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "d-bus" = callPackage
     ({ mkDerivation, async, attoparsec, base, binary, blaze-builder
      , bytestring, conduit, conduit-extra, containers
···
 
   "darcs" = callPackage
     ({ mkDerivation, array, async, attoparsec, base, base16-bytestring
-     , binary, bytestring, cmdargs, containers, cryptohash, curl
+     , binary, bytestring, Cabal, cmdargs, containers, cryptohash, curl
      , data-ordlist, directory, fgl, filepath, FindBin, graphviz
      , hashable, haskeline, html, HTTP, HUnit, mmap, mtl, network
      , network-uri, old-time, parsec, process, QuickCheck, random
-     , regex-applicative, regex-compat-tdfa, sandi, shelly, split, tar
-     , terminfo, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, text, time, transformers
-     , transformers-compat, unix, unix-compat, utf8-string, vector
-     , zip-archive, zlib
+     , regex-applicative, regex-compat-tdfa, sandi, shelly, split, stm
+     , tar, temporary, terminfo, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text, time, transformers, unix
+     , unix-compat, utf8-string, vector, zip-archive, zlib
      }:
      mkDerivation {
        pname = "darcs";
-       version = "2.12.5";
-       sha256 = "0lrm0sal5pl453mkqn8b9fc9l7lwinc140iqihya9g17bk408nrm";
+       version = "2.14.0";
+       sha256 = "00r8g27sgwlw5r8gx89q99n2hawcacfz1mjj0nmh6ps8l610iyhr";
        revision = "1";
-       editedCabalFile = "0if3ww0xhi8k5c8a9yb687gjjdp2k4q2896qn7vgwwzg360slx8n";
+       editedCabalFile = "0kxvr0rv5936x460k5ydyy85lgjhmrlkrm60zhbqkqks304abs1h";
        configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
        isLibrary = true;
        isExecutable = true;
+       setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [
          array async attoparsec base base16-bytestring binary bytestring
          containers cryptohash data-ordlist directory fgl filepath graphviz
          hashable haskeline html HTTP mmap mtl network network-uri old-time
-         parsec process random regex-applicative regex-compat-tdfa sandi tar
-         terminfo text time transformers transformers-compat unix
-         unix-compat utf8-string vector zip-archive zlib
+         parsec process random regex-applicative regex-compat-tdfa sandi stm
+         tar temporary terminfo text time transformers unix unix-compat
+         utf8-string vector zip-archive zlib
        ];
        librarySystemDepends = [ curl ];
        executableHaskellDepends = [ base ];
···
        '';
        homepage = "http://darcs.net/";
        description = "a distributed, interactive, smart revision control system";
-       license = "GPL";
+       license = stdenv.lib.licenses.gpl2;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) curl;};
 
···
        pname = "dlist-nonempty";
        version = "0.1.1";
        sha256 = "0csbspdy43pzvasb5mhs5pz2f49ws78pi253cx7pp84wjx6ads20";
-       revision = "1";
-       editedCabalFile = "0dcqfyp38f792nzsv4977dcv4zr4xdrg780lz6bpf2hn7ikdglz9";
+       revision = "2";
+       editedCabalFile = "1968b6i0azv0bi3x6cw85ga89md1dh1wdmly3ivvvyb6i9mgwrn6";
        libraryHaskellDepends = [
          base base-compat deepseq dlist semigroupoids
        ];
···
      }:
      mkDerivation {
        pname = "dual-tree";
-       version = "0.2.1";
-       sha256 = "06azc2lwli9aw81a23g82yxiann2qjc3bk7cdyh9kiwimdyj8r94";
+       version = "0.2.1.1";
+       sha256 = "1wzv6rrhz2kz0v1wirgs28fdlr0r4nwxlix9xda4fphzpp922gzr";
        libraryHaskellDepends = [
          base monoid-extras newtype-generics semigroups
        ];
···
      }:
      mkDerivation {
        pname = "etc";
-       version = "0.3.0.0";
-       sha256 = "04cma6lzgz3sm9riyy8cx1dlkz90yxqqpyirvdn5n3bxdnj1sa3g";
+       version = "0.3.1.0";
+       sha256 = "0l938jhlx1jgb46b9ykdc741r0v7wkklrc1ga5v81r3b52civb1c";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base hashable rio text typed-process unliftio
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "eve-cli" = callPackage
+    ({ mkDerivation, base, bytestring, eve, lens, mtl, text, vty }:
+     mkDerivation {
+       pname = "eve-cli";
+       version = "0.2.0.0";
+       sha256 = "0l9c7mpmw7i9kgmirnkb84q6lfw0ry5z5j2049sv47klczdv285a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring eve lens mtl text vty ];
+       executableHaskellDepends = [
+         base bytestring eve lens mtl text vty
+       ];
+       testHaskellDepends = [ base bytestring eve lens mtl text vty ];
+       homepage = "https://github.com/ChrisPenner/eve-cli#readme";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "event" = callPackage
     ({ mkDerivation, base, containers, semigroups, transformers }:
      mkDerivation {
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "extensible-effects_2_5_1_2" = callPackage
+  "extensible-effects_2_5_2_0" = callPackage
     ({ mkDerivation, base, criterion, HUnit, monad-control, mtl
      , QuickCheck, silently, test-framework, test-framework-hunit
      , test-framework-quickcheck2, test-framework-th, transformers-base
      }:
      mkDerivation {
        pname = "extensible-effects";
-       version = "2.5.1.2";
-       sha256 = "0hz0vn2az6dsbhxzlz4xvz6gybmbmxqji4s7d325ybpapj4pky6f";
+       version = "2.5.2.0";
+       sha256 = "12rj2b1zn3lqk5anv01lf95mmadazripa6731jf3m2m5di00i4sc";
        libraryHaskellDepends = [ base monad-control transformers-base ];
        testHaskellDepends = [
          base HUnit monad-control QuickCheck silently test-framework
···
      }) {};
 
   "fast-arithmetic" = callPackage
-    ({ mkDerivation, arithmoi, ats-pkg, base, Cabal, combinat
+    ({ mkDerivation, arithmoi, ats-pkg, base, Cabal, combinat-compat
      , composition-prelude, criterion, gmpint, hspec, numbertheory
      , QuickCheck
      }:
      mkDerivation {
        pname = "fast-arithmetic";
-       version = "0.3.3.4";
-       sha256 = "176qm6d9rqq85cbpq6n0fmqwvyi529ml6z346k9a1mfpzi85w3xy";
+       version = "0.3.3.6";
+       sha256 = "1crs7ymdvizb0s0i3didi429b3wym01iinm7ryy3z6i198ls1pga";
        setupHaskellDepends = [ ats-pkg base Cabal ];
        libraryHaskellDepends = [ base composition-prelude gmpint ];
        librarySystemDepends = [ numbertheory ];
-       testHaskellDepends = [ arithmoi base combinat hspec QuickCheck ];
-       benchmarkHaskellDepends = [ arithmoi base combinat criterion ];
+       testHaskellDepends = [
+         arithmoi base combinat-compat hspec QuickCheck
+       ];
+       benchmarkHaskellDepends = [
+         arithmoi base combinat-compat criterion
+       ];
        homepage = "https://github.com/vmchale/fast-arithmetic#readme";
        description = "Fast functions on integers";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "file-embed-lzma" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, directory, filepath
+     , lzma, template-haskell, text, th-lift-instances, transformers
+     }:
+     mkDerivation {
+       pname = "file-embed-lzma";
+       version = "0";
+       sha256 = "0xqcgx4ysyjqrygnfabs169y4w986kwzvsaqh64h7x3wfi7z8v78";
+       revision = "1";
+       editedCabalFile = "18q9dgfdsr7r5mlqzhhgbx0bp4bv2xkpcsrihl655pwaj1lz1v2s";
+       libraryHaskellDepends = [
+         base base-compat bytestring directory filepath lzma
+         template-haskell text th-lift-instances transformers
+       ];
+       testHaskellDepends = [ base bytestring ];
+       homepage = "https://github.com/phadej/file-embed-lzma";
+       description = "Use Template Haskell to embed (LZMA compressed) data";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "file-embed-poly" = callPackage
     ({ mkDerivation, base, bytestring, directory, file-embed, filepath
      , hspec, template-haskell
···
      }:
      mkDerivation {
        pname = "fltkhs";
-       version = "0.5.4.4";
-       sha256 = "1bv7djak2ilirk7ajm8w6100bk6vx14znf3699blih72kyql6rgh";
+       version = "0.5.4.5";
+       sha256 = "17iqpnn0zgwifb937kllkfyz8qf37da90z8iyay348gy3siwjxic";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal directory filepath ];
···
      }) {};
 
   "funcons-tools" = callPackage
-    ({ mkDerivation, base, bv, containers, directory, mtl, multiset
-     , parsec, split, text, vector
+    ({ mkDerivation, base, bv, containers, directory, funcons-values
+     , gll, mtl, multiset, random-strings, regex-applicative, split
+     , text, TypeCompose, vector
      }:
      mkDerivation {
        pname = "funcons-tools";
-       version = "0.1.0.0";
-       sha256 = "1vwnznj92cm2g1m2xlvj8b5qzaspl3zrygr5z7b8593qylm6bwlr";
-       revision = "2";
-       editedCabalFile = "0530f406ykmb4xxmh7knmaxgcpym7n2wl6d2ylvrn3azqfdsvsgy";
+       version = "0.2.0.1";
+       sha256 = "1a27xhzakvrc29kli293ivkzmqfma71s942a9bsyvss15g1881fn";
+       revision = "1";
+       editedCabalFile = "1lfqgrrc814j0zyx2z8v0nx367bgifr93gb86dd4hshz2vvq5b49";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bv containers directory mtl multiset parsec split text vector
+         base bv containers directory funcons-values gll mtl multiset
+         random-strings regex-applicative split text TypeCompose vector
        ];
        executableHaskellDepends = [
-         base bv containers directory mtl multiset parsec split text vector
+         base bv containers directory funcons-values gll mtl multiset
+         random-strings regex-applicative split text TypeCompose vector
        ];
        homepage = "http://plancomps.org";
        description = "A modular interpreter for executing funcons";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "funcons-values" = callPackage
+    ({ mkDerivation, base, bv, containers, multiset, random-strings
+     , text, vector
+     }:
+     mkDerivation {
+       pname = "funcons-values";
+       version = "0.1.0.2";
+       sha256 = "0pywpqnjhwny1l1kz6hn135rbmgdglzpvfvq4ffjllzdj2w9ciy2";
+       libraryHaskellDepends = [
+         base bv containers multiset random-strings text vector
+       ];
+       homepage = "http://plancomps.org";
+       description = "Library providing values and operations on values";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "function-combine" = callPackage
···
      }) {};
 
   "functor-utils" = callPackage
-    ({ mkDerivation, base, ghc-prim }:
+    ({ mkDerivation, base, ghc-prim, lens }:
      mkDerivation {
        pname = "functor-utils";
-       version = "1.1";
-       sha256 = "1finmjwpw4sjzwifjmcpb90wmy7abhdnrhz2p5s7fxw68vccnm50";
-       libraryHaskellDepends = [ base ghc-prim ];
-       homepage = "https://github.com/wdanilo/functor-utils";
+       version = "1.17.1";
+       sha256 = "1ixssxdhw94l1kjxd5k4gvq8wz4b9d0vww5mg2al9q3vzb7d4pld";
+       libraryHaskellDepends = [ base ghc-prim lens ];
+       homepage = "https://github.com/luna/functor-utils";
        description = "Collection of functor utilities, providing handy operators, like generalization of (.).";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "generic-lens_1_0_0_1" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, doctest, HUnit
+     , inspection-testing, lens, profunctors, QuickCheck, tagged
+     }:
+     mkDerivation {
+       pname = "generic-lens";
+       version = "1.0.0.1";
+       sha256 = "0j83ynggqfaxp9g36lkjl9af57qixid9j1x1ljglny1zxqkgm888";
+       libraryHaskellDepends = [ base profunctors tagged ];
+       testHaskellDepends = [
+         base doctest HUnit inspection-testing lens profunctors
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq lens QuickCheck
+       ];
+       homepage = "https://github.com/kcsongor/generic-lens";
+       description = "Generically derive traversals, lenses and prisms";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "generic-lens-labels" = callPackage
     ({ mkDerivation, base, generic-lens }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "generics-eot_0_3" = callPackage
+  "generics-eot_0_4" = callPackage
     ({ mkDerivation, base, directory, doctest, filepath, hspec
-     , hspec-discover, interpolate, markdown-unlit, mockery, QuickCheck
-     , shake
+     , interpolate, markdown-unlit, mockery, QuickCheck, shake, silently
      }:
      mkDerivation {
        pname = "generics-eot";
-       version = "0.3";
-       sha256 = "1r0qh27jpika9wfxk0i6kywsclrdqhaphl1qw26vfzka4dsfbjrb";
-       libraryHaskellDepends = [ base markdown-unlit ];
+       version = "0.4";
+       sha256 = "16yfzv9aqyizm57r5m5ddwdnlh05fvlrxjn6m3vqz33kvy3drgjs";
+       libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base directory doctest filepath hspec interpolate markdown-unlit
-         mockery QuickCheck shake
+         mockery QuickCheck shake silently
        ];
-       testToolDepends = [ hspec-discover ];
-       homepage = "https://github.com/soenkehahn/generics-eot#readme";
+       homepage = "https://generics-eot.readthedocs.io/";
        description = "A library for generic programming that aims to be easy to understand";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "gi-gio";
-       version = "2.0.17";
-       sha256 = "1yf0wav5mgy0aj1j4jcmip71isz91m99rbjpmqgwakvjcs2x5gm3";
+       version = "2.0.18";
+       sha256 = "0h7liqxf63wmhjzgbjshv7pa4fx743jpvkphn5yyjkc0bnfcvsqk";
        setupHaskellDepends = [ base Cabal haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "githud";
-       version = "2.0.1";
-       sha256 = "0qmc51dpsmil72xvv3g7mylr39ignrm8az6jv92b767s8ijqk5lh";
+       version = "2.0.2";
+       sha256 = "0nhik30c7xzn3aqj8d8b8rk05viqmhl8q9ymswxxn9ws2nkm7rk8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec process text unix ];
···
      }:
      mkDerivation {
        pname = "gll";
-       version = "0.4.0.4";
-       sha256 = "01qnvynldllb4qdvg29r64qq17qb1fs8yg7jgyj3f8ajgyi5jn9q";
+       version = "0.4.0.5";
+       sha256 = "09z7i4h5zwgyh3gg5w0l6p0ch1lhzmsnbmk1yfbc9b21gbxna5js";
        libraryHaskellDepends = [
          array base containers pretty regex-applicative text TypeCompose
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "gloss-accelerate_2_0_0_1" = callPackage
+    ({ mkDerivation, accelerate, base, gloss, gloss-rendering }:
+     mkDerivation {
+       pname = "gloss-accelerate";
+       version = "2.0.0.1";
+       sha256 = "106z8kax0m3hzk0381l8m7gxdapl3wf0fdr1ljwb5fgcjc00pac2";
+       libraryHaskellDepends = [ accelerate base gloss gloss-rendering ];
+       description = "Extras to interface Gloss and Accelerate";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "gloss-algorithms" = callPackage
     ({ mkDerivation, base, containers, ghc-prim, gloss }:
      mkDerivation {
···
        pname = "gloss-raster-accelerate";
        version = "2.0.0.0";
        sha256 = "1i0qx9wybr66i1x4n3p8ai2z6qx0k5lac422mhh4rvimcjx2bc9d";
-       revision = "1";
-       editedCabalFile = "07c56r31akmq7hq0cyw4lc4h5370laand231wjd5ffwk369x2prg";
+       revision = "2";
+       editedCabalFile = "0k0a562qa8khj39zpgp4sr8kh8h2q4krjjhbvpbsll4r83067ahj";
        libraryHaskellDepends = [
          accelerate base colour-accelerate gloss gloss-accelerate
        ];
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "gtk-strut" = callPackage
+    ({ mkDerivation, base, gi-gdk, gi-gtk, text, transformers }:
+     mkDerivation {
+       pname = "gtk-strut";
+       version = "0.1.1.0";
+       sha256 = "1g88afi75a727s85v37n4mvqr5zp4849s2kc1zdx3pvc9a15i9pd";
+       libraryHaskellDepends = [ base gi-gdk gi-gtk text transformers ];
+       homepage = "https://github.com/IvanMalison/gtk-strut#readme";
+       description = "Libary for creating strut windows with gi-gtk";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "gtk-toggle-button-list" = callPackage
     ({ mkDerivation, base, gtk }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hasbolt-extras";
-       version = "0.0.0.2";
-       sha256 = "1wjyqm606iflxsgjp7bj7b7avi07jhskxypahzlr02k7k7k9swm2";
+       version = "0.0.0.4";
+       sha256 = "0dclanbd07knph3bxn5a3kyl9qkqcwhy00y5jnah9sxk4qqhjkk5";
        libraryHaskellDepends = [
          base containers hasbolt lens neat-interpolation template-haskell
          text th-lift-instances
···
      }:
      mkDerivation {
        pname = "heavy-logger";
-       version = "0.3.1.0";
-       sha256 = "0cmanxnahxgk52ffpni0zx4z22vdrh6r5my4llvsdd94bpfmxpi4";
+       version = "0.3.2.0";
+       sha256 = "1kx6l7ysniqjzzp7l74vjcfbi8qz5xqjqvisb49k18cnf22mikvv";
        libraryHaskellDepends = [
          attoparsec base bytestring containers data-default fast-logger
          hsyslog lifted-base monad-control monad-logger mtl stm
···
        description = "heavy-logger compatibility with amazonka-core logging";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "heavy-logger-instances" = callPackage
+    ({ mkDerivation, base, binary, exceptions, heavy-logger, hsyslog
+     , mtl, template-haskell, text, text-format-heavy
+     }:
+     mkDerivation {
+       pname = "heavy-logger-instances";
+       version = "0.2.0.0";
+       sha256 = "0flh5j79ijkvdwhjg1gn3qkhybzspvg1jh8nib18fgzmvcx8zckm";
+       libraryHaskellDepends = [
+         base binary exceptions heavy-logger hsyslog mtl template-haskell
+         text text-format-heavy
+       ];
+       testHaskellDepends = [
+         base binary exceptions heavy-logger hsyslog mtl template-haskell
+         text text-format-heavy
+       ];
+       homepage = "https://github.com/portnov/heavy-logger#readme";
+       description = "Orphan instances for data types in heavy-logger package";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "hebrew-time" = callPackage
···
 
   "hedn" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat, bytestring
-     , containers, deepseq, hspec, HUnit, mtl, QuickCheck, scientific
-     , stringsearch, template-haskell, text, time, time-locale-compat
-     , utf8-string, vector
+     , containers, deepseq, hspec, hspec-contrib, HUnit, mtl, QuickCheck
+     , scientific, stringsearch, template-haskell, text, time
+     , time-locale-compat, utf8-string, vector
      }:
      mkDerivation {
        pname = "hedn";
-       version = "0.1.8.2";
-       sha256 = "15f1zrp5cb1m2xhy974v8f67xg08yks6w43m3sbky4v5mbfy12ig";
+       description = "A named lock that is created on demand";
+       sha256 = "077wf446x0rrac3bdzmyhpacb54smx02msdz45cra3yzn3n0rq7l";
        libraryHaskellDepends = [
          attoparsec base base-compat bytestring containers deepseq mtl
          scientific stringsearch text time time-locale-compat utf8-string
          vector
        ];
        testHaskellDepends = [
-         base bytestring containers hspec HUnit QuickCheck template-haskell
-         text time vector
+         base bytestring containers hspec hspec-contrib HUnit QuickCheck
+         template-haskell text time vector
        ];
        homepage = "https://bitbucket.org/dpwiz/hedn";
        description = "EDN parsing and encoding";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "heist_1_0_1_3" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bifunctors, blaze-builder
+     , blaze-html, bytestring, containers, criterion, directory
+     , directory-tree, dlist, filepath, hashable, HUnit, lens
+     , lifted-base, map-syntax, monad-control, mtl, process, QuickCheck
+     , random, statistics, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text, time, transformers
+     , transformers-base, unordered-containers, vector, xmlhtml
+     }:
+     mkDerivation {
+       pname = "heist";
+       version = "1.0.1.3";
+       sha256 = "0gy1s30sv9g1ybazh2md7scr1z2lqixl374h108zfp6f66iq450z";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder blaze-html bytestring
+         containers directory directory-tree dlist filepath hashable
+         lifted-base map-syntax monad-control mtl process random text time
+         transformers transformers-base unordered-containers vector xmlhtml
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base bifunctors blaze-builder blaze-html
+         bytestring containers directory directory-tree dlist filepath
+         hashable HUnit lens lifted-base map-syntax monad-control mtl
+         process QuickCheck random test-framework test-framework-hunit
+         test-framework-quickcheck2 text time transformers transformers-base
+         unordered-containers vector xmlhtml
+       ];
+       benchmarkHaskellDepends = [
+         aeson attoparsec base blaze-builder blaze-html bytestring
+         containers criterion directory directory-tree dlist filepath
+         hashable HUnit lifted-base map-syntax monad-control mtl process
+         random statistics test-framework test-framework-hunit text time
+         transformers transformers-base unordered-containers vector xmlhtml
+       ];
+       homepage = "http://snapframework.com/";
+       description = "An Haskell template system supporting both HTML5 and XML";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "heist-aeson" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
      , heist, monads-fd, text, vector, xmlhtml
···
        pname = "hledger-iadd";
        version = "1.3.3";
        sha256 = "0fm5y2qyrg661q7y23f5abg78rbwz4jqkvlar8ns8wz9qwbml0ix";
+       revision = "1";
+       editedCabalFile = "09dvjyl9irq0cc8k4nwxdkjvj13dwk1n5lij7ykka6a658y9gzp5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "hpath" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions
-     , hspec, HUnit, process, QuickCheck, simple-sendfile, unix
+     , hspec, HUnit, IfElse, process, QuickCheck, simple-sendfile, unix
      , unix-bytestring, utf8-string, word8
      }:
      mkDerivation {
        pname = "hpath";
-       version = "0.8.0";
-       sha256 = "19xbzgz51dwjm5w11j170bp8nv0b19qk6b8mx75c367n4xshgxc3";
+       version = "0.8.1";
+       sha256 = "0k1g27lnm2c61wva03gh5qrjpc26xh6alxkv8xx36miw06fz88hv";
        libraryHaskellDepends = [
-         base bytestring deepseq exceptions hspec simple-sendfile unix
-         unix-bytestring utf8-string word8
+         base bytestring deepseq exceptions hspec IfElse simple-sendfile
+         unix unix-bytestring utf8-string word8
        ];
        testHaskellDepends = [
-         base bytestring doctest hspec HUnit process QuickCheck unix
+         base bytestring doctest hspec HUnit IfElse process QuickCheck unix
          unix-bytestring utf8-string
        ];
        description = "Support for well-typed paths";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {xenctrl = null;};
 
+  "hsaml2" = callPackage
+    ({ mkDerivation, asn1-encoding, asn1-types, base, base64-bytestring
+     , bytestring, cryptonite, data-default, http-types, HUnit, hxt
+     , hxt-charproperties, hxt-http, hxt-unicode, invertible
+     , invertible-hxt, lens, libxml2, memory, mtl, network-uri, process
+     , semigroups, template-haskell, time, x509, zlib
+     }:
+     mkDerivation {
+       pname = "hsaml2";
+       version = "0.1";
+       sha256 = "0mpw13cicx16zhsk7km2qsndah9cdmyylz4r5ank5cxj0rzmkjck";
+       libraryHaskellDepends = [
+         asn1-encoding asn1-types base base64-bytestring bytestring
+         cryptonite data-default http-types hxt hxt-charproperties
+         hxt-unicode invertible invertible-hxt lens memory mtl network-uri
+         process semigroups template-haskell time x509 zlib
+       ];
+       libraryPkgconfigDepends = [ libxml2 ];
+       testHaskellDepends = [
+         base bytestring HUnit hxt hxt-http network-uri semigroups time x509
+       ];
+       description = "OASIS Security Assertion Markup Language (SAML) V2.0";
+       license = stdenv.lib.licenses.asl20;
+     }) {inherit (pkgs) libxml2;};
+
   "hsass" = callPackage
     ({ mkDerivation, base, bytestring, data-default-class, filepath
      , hlibsass, hspec, hspec-discover, monad-loops, temporary
···
        description = "Command line client and library for SoundCloud.com";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "hscharm" = callPackage
+    ({ mkDerivation, base, random, random-shuffle }:
+     mkDerivation {
+       pname = "hscharm";
+       version = "0.0.2";
+       sha256 = "17713j542kph74n8rvjrx847r19yk96dz80n04nl8w6vzabj5wng";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       executableHaskellDepends = [ base random random-shuffle ];
+       description = "minimal ncurses-like library";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "hsclock" = callPackage
···
   "htoml-megaparsec" = callPackage
     ({ mkDerivation, aeson, base, bytestring, composition-prelude
      , containers, criterion, deepseq, file-embed, hspec, megaparsec
-     , mtl, old-locale, tasty, tasty-hspec, tasty-hunit, text, time
+     , mtl, tasty, tasty-hspec, tasty-hunit, text, time
      , unordered-containers, vector
      }:
      mkDerivation {
        pname = "htoml-megaparsec";
-       version = "1.1.0.2";
-       sha256 = "0w59c20d4g64lldd6xfs82di56dbixmh6win6x80ddb1m0y9iaxd";
+       version = "1.1.0.3";
+       sha256 = "0bzja2n7hxj530d3pfh58zn29vapl341fy7x6ggvp5sfgsysg7ll";
        libraryHaskellDepends = [
-         base composition-prelude containers deepseq megaparsec mtl
-         old-locale text time unordered-containers vector
+         base composition-prelude containers deepseq megaparsec mtl text
+         time unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base bytestring containers file-embed hspec megaparsec tasty
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hw-hspec-hedgehog_0_1_0_3" = callPackage
+    ({ mkDerivation, base, call-stack, hedgehog, hspec, HUnit }:
+     mkDerivation {
+       pname = "hw-hspec-hedgehog";
+       version = "0.1.0.3";
+       sha256 = "0bnqvbh8jkpnannfgx1ghv5b4qvj37w1p29ap730s2bbfpsaldq2";
+       libraryHaskellDepends = [ base call-stack hedgehog hspec HUnit ];
+       testHaskellDepends = [ base hedgehog hspec ];
+       homepage = "https://github.com/haskell-works/hw-hspec-hedgehog#readme";
+       description = "Interoperability between hspec and hedgehog";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hw-int" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
     ({ mkDerivation, base, lens }:
      mkDerivation {
        pname = "impossible";
-       version = "1.0.0";
-       sha256 = "1qkpwa2am439bpngiiwgh14cg19d4mp6s9qqa890rvm5pqh8skvz";
+       version = "1.1.1";
+       sha256 = "0drq4rzbljql51hc2d8ldsm6xhsj7imlsxclivmf3lr9lykkp0p1";
        libraryHaskellDepends = [ base lens ];
-       homepage = "https://github.com/wdanilo/impossible";
+       homepage = "https://github.com/luna/impossible";
        description = "Set of data and type definitions of impossible types. Impossible types are useful when declaring type classes / type families instances that should not be expanded by GHC until a specific type is provided in order to keep the types nice and readable.";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "jose_0_7_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , bytestring, concise, containers, cryptonite, hspec, lens, memory
+     , monad-time, mtl, network-uri, QuickCheck, quickcheck-instances
+     , safe, semigroups, tasty, tasty-hspec, tasty-quickcheck
+     , template-haskell, text, time, unordered-containers, vector, x509
+     }:
+     mkDerivation {
+       pname = "jose";
+       version = "0.7.0.0";
+       sha256 = "051rjqfskizgm9j927zh500q54lii3scldsymgcdfbaw40d0mncc";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring concise
+         containers cryptonite lens memory monad-time mtl network-uri
+         QuickCheck quickcheck-instances safe semigroups template-haskell
+         text time unordered-containers vector x509
+       ];
+       executableHaskellDepends = [ aeson base bytestring lens mtl ];
+       testHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring concise
+         containers cryptonite hspec lens memory monad-time mtl network-uri
+         QuickCheck quickcheck-instances safe semigroups tasty tasty-hspec
+         tasty-quickcheck template-haskell text time unordered-containers
+         vector x509
+       ];
+       homepage = "https://github.com/frasertweedale/hs-jose";
+       description = "Javascript Object Signing and Encryption and JSON Web Token library";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "jose-jwt" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
      , containers, criterion, cryptonite, doctest, either, hspec, HUnit
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "jot" = callPackage
+    ({ mkDerivation, base, data-default, dhall, docopt, extra, filepath
+     , process, time, turtle, yaml
+     }:
+     mkDerivation {
+       pname = "jot";
+       version = "0.1.0.3";
+       sha256 = "1rw5ah60kfazycpf2f0sin98rba99d06gkqfci30m64wpkcm9l4g";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base data-default dhall docopt extra filepath process time turtle
+         yaml
+       ];
+       homepage = "http://gitlab.com/locallycompact/jot";
+       description = "Tiny markdown notebook";
+       license = stdenv.lib.licenses.isc;
+     }) {};
+
   "jpeg" = callPackage
     ({ mkDerivation, base, mtl }:
      mkDerivation {
···
        description = "A named lock that is created on demand";
        description = "A named lock that is created on demand";
        description = "A named lock that is created on demand";
-       revision = "3";
-       description = "A named lock that is created on demand";
+       revision = "4";
+       editedCabalFile = "19nasv4sxjn3j0xvr1pd9x6bf8f8566wwd15y3wwll89bpnyd4z9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        description = "A named lock that is created on demand";
-       description = "A named lock that is created on demand";
-       description = "A named lock that is created on demand";
+       version = "0.2.4.5";
+       sha256 = "0pcxmsf18ykvf1mbm3w8qn86rdmr69ilcakrgidl1ag6liq1s6zc";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        description = "A named lock that is created on demand";
-       description = "A named lock that is created on demand";
-       description = "A named lock that is created on demand";
+       version = "1.2.0.5";
+       sha256 = "13slgzdcgdbibxnk4nk6xgkvhsz2f87m6xj0mz5ccmjfb35hv63d";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
        description = "A named lock that is created on demand";
···
        pname = "lattices";
        version = "1.7.1";
        sha256 = "0bcv28dazaz0n166jbd579vim0hr4c20rmg0s34284fdr6p50m3x";
-       revision = "1";
-       editedCabalFile = "1h68xxzy90i7nggyh67f4744zk9a4zv4lb5ag9dwp126acvg2c9n";
+       revision = "2";
+       editedCabalFile = "0ngxvs48hqdr5353fbblcrq5hqrwr89xl39akxg8rkridkr3hq96";
        libraryHaskellDepends = [
          base base-compat containers deepseq hashable semigroupoids tagged
          universe-base universe-reverse-instances unordered-containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "layered-state" = callPackage
+    ({ mkDerivation, base, constraints, criterion, data-default
+     , deepseq, either, exceptions, kan-extensions, lens, lens-utils
+     , monad-branch, monoid, mtl, mtl-c, primitive, profunctors
+     , prologue, timeit, transformers, typelevel
+     }:
+     mkDerivation {
+       pname = "layered-state";
+       version = "1.1.2";
+       sha256 = "1z9xz9nvzlqvzrp4dva9skci70g70lzzf5d5d38ilxvfk7kh56h6";
+       libraryHaskellDepends = [
+         base constraints data-default exceptions lens lens-utils
+         monad-branch monoid mtl primitive profunctors prologue transformers
+         typelevel
+       ];
+       benchmarkHaskellDepends = [
+         criterion deepseq either kan-extensions mtl-c timeit
+       ];
+       homepage = "https://github.com/luna/layered-state";
+       description = "Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types.";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "layers" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
        homepage = "https://github.com/elliottt/layout-rules";
        description = "A collection of different layout implementations";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "layouting" = callPackage
+    ({ mkDerivation, base, container, layered-state, prologue
+     , terminal-text, text
+     }:
+     mkDerivation {
+       pname = "layouting";
+       version = "1.1.2";
+       sha256 = "1j3bki62ldi5gbl3asa31rjjlah2842rhgylxwab13c3r50a7p85";
+       libraryHaskellDepends = [
+         base container layered-state prologue terminal-text text
+       ];
+       homepage = "https://github.com/luna/layouting";
+       description = "General layouting library. Currently supports layouting 2D areas and can be used as a backend for text pretty printing or automatic windows layouting managers.";
+       license = stdenv.lib.licenses.asl20;
      }) {};
 
   "lazy-csv" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "left4deadrl" = callPackage
+    ({ mkDerivation, base, hscharm, random, random-shuffle }:
+     mkDerivation {
+       pname = "left4deadrl";
+       version = "0.0.2";
+       sha256 = "1lwpkhlhiy8dbw3ln0dz65ci8my7cmqs7d08f5wy728ixmmcn84w";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [ base hscharm random random-shuffle ];
+       description = "left4dead-inspired roguelike";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "legion" = callPackage
     ({ mkDerivation, aeson, base, binary, binary-conduit, bytestring
      , canteven-http, conduit, conduit-extra, containers
···
        homepage = "https://github.com/tmcdonell/lens-accelerate";
        description = "Instances to mix lens with accelerate";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "lens-accelerate_0_2_0_0" = callPackage
+    ({ mkDerivation, accelerate, base, lens }:
+     mkDerivation {
+       pname = "lens-accelerate";
+       version = "0.2.0.0";
+       sha256 = "099vvakv7gq9sr9mh3hxj5byxxb4dw8lw7y1g3c4j1kz4gf2vxfk";
+       libraryHaskellDepends = [ accelerate base lens ];
+       homepage = "https://github.com/tmcdonell/lens-accelerate";
+       description = "Instances to mix lens with accelerate";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "lens-action" = callPackage
···
      }) {};
 
   "lens-utils" = callPackage
-    ({ mkDerivation, base, lens }:
+    ({ mkDerivation, aeson, base, containers, data-default, lens
+     , monoid, template-haskell
+     }:
      mkDerivation {
        pname = "lens-utils";
-       version = "1.2";
-       sha256 = "1ysr9ph03f8klvnbhvzjn45vsnxbfp1ry34lbcrhdm6gy7x0maib";
-       libraryHaskellDepends = [ base lens ];
-       homepage = "https://github.com/wdanilo/lens-utils";
+       version = "1.4.2";
+       sha256 = "1sgsahb2cgfhbv3vw0h1cqls5g5kgbq9crx4w0rfjxcwk9d5jzds";
+       libraryHaskellDepends = [
+         aeson base containers data-default lens monoid template-haskell
+       ];
+       homepage = "https://github.com/luna/lens-utils";
        description = "Collection of missing lens utilities";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "lentil_1_0_11_3" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, csv, directory, filemanip
+     , filepath, hspec, natural-sort, optparse-applicative, parsec
+     , pipes, regex-tdfa, semigroups, terminal-progress-bar, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "lentil";
+       version = "1.0.11.3";
+       sha256 = "0kb9fydcv0skp94bhvhbqggam8vrq2wv5iradxmggaf41h0ly123";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         ansi-wl-pprint base csv directory filemanip filepath natural-sort
+         optparse-applicative parsec pipes regex-tdfa semigroups
+         terminal-progress-bar text transformers
+       ];
+       testHaskellDepends = [
+         ansi-wl-pprint base csv directory filemanip filepath hspec
+         natural-sort optparse-applicative parsec pipes regex-tdfa
+         semigroups terminal-progress-bar text transformers
+       ];
+       homepage = "http://www.ariis.it/static/articles/lentil/page.html";
+       description = "frugal issue tracker";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "lenz" = callPackage
     ({ mkDerivation, base, base-unicode-symbols, hs-functors
      , transformers
···
        homepage = "http://github.com/ekmett/linear-accelerate/";
        description = "Lifting linear vector spaces into Accelerate";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "linear-accelerate_0_6_0_0" = callPackage
+    ({ mkDerivation, accelerate, base, Cabal, cabal-doctest
+     , distributive, doctest, lens, linear
+     }:
+     mkDerivation {
+       pname = "linear-accelerate";
+       version = "0.6.0.0";
+       sha256 = "1bwqbs4816xrrc0bcf3nllad1an7c8gv2n9d1qv3ybk7s4fw288s";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         accelerate base distributive lens linear
+       ];
+       testHaskellDepends = [ base doctest ];
+       homepage = "http://github.com/ekmett/linear-accelerate/";
+       description = "Lifting linear vector spaces into Accelerate";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "linear-algebra-cblas" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "log-warper_1_8_11" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, async, base, containers
+     , data-default, deepseq, directory, filepath, fmt, hspec
+     , hspec-discover, HUnit, lifted-async, markdown-unlit, microlens
+     , microlens-mtl, microlens-platform, mmorph, monad-control
+     , monad-loops, mtl, o-clock, QuickCheck, text, time, transformers
+     , transformers-base, universum, unix, unordered-containers, vector
+     , yaml
+     }:
+     mkDerivation {
+       pname = "log-warper";
+       version = "1.8.11";
+       sha256 = "0xhvipk5dlv7r2pmgn5mf46rrz092xhm6ar611y5lrr99i2kg172";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base containers deepseq directory filepath fmt
+         lifted-async microlens-platform mmorph monad-control monad-loops
+         mtl o-clock text time transformers transformers-base universum unix
+         unordered-containers vector yaml
+       ];
+       executableHaskellDepends = [
+         base markdown-unlit microlens monad-control mtl o-clock text
+         universum yaml
+       ];
+       testHaskellDepends = [
+         async base data-default directory filepath hspec HUnit
+         microlens-mtl QuickCheck universum unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       homepage = "https://github.com/serokell/log-warper";
+       description = "Flexible, configurable, monadic and pretty logging";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "log2json" = callPackage
     ({ mkDerivation, base, containers, json, parsec }:
      mkDerivation {
···
        pname = "lrucaching";
        version = "0.3.3";
        sha256 = "192a2zap1bmxa2y48n48rmngf18fr8k0az4a230hziv3g795yzma";
-       revision = "1";
-       editedCabalFile = "0axg26s9gssg3ig613rnqj5v4aczki4kgyqmnd208kljkawq6c7k";
+       revision = "2";
+       editedCabalFile = "0ypilhv8im5vqwdy6wk9ql2dlpr4cykag6ikvyjapl8bpyfm44xa";
        libraryHaskellDepends = [
          base base-compat deepseq hashable psqueues vector
        ];
···
        pname = "lucid";
        version = "2.9.10";
        sha256 = "14238cnrvkbr81hpaqg1r342sryj8k0p6igkwf140s9phfpdzry0";
+       revision = "1";
+       editedCabalFile = "0n94x2havrvks85z8azsa4pvz33amhb444cias3kfxmkyvypn5ah";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers hashable mmorph mtl text
          transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "madlang";
-       version = "4.0.2.2";
-       sha256 = "1g02ky5a1fy9g8sp1i3r7m1gjkajza3npj8dqr0chfxkm8ki6hfx";
+       version = "4.0.2.6";
+       sha256 = "079100sdqh4g7mlbf7p1j04r7g6c6b3q58nm4qiy8yrdvbzjdrhv";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cli-setup ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "main-tester" = callPackage
+    ({ mkDerivation, base, bytestring, directory, doctest, hspec
+     , hspec-core, QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "main-tester";
+       version = "0.1.0.0";
+       sha256 = "0sagm9fkdgjv8x602bjj32glcrivjf3yz47gpbbm48k0mk0dj2dc";
+       libraryHaskellDepends = [ base bytestring directory ];
+       testHaskellDepends = [
+         base bytestring doctest hspec hspec-core QuickCheck text
+       ];
+       homepage = "https://gitlab.com/igrep/main-tester#readme";
+       description = "Capture stdout/stderr/exit code, and replace stdin of your main function";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "mainland-pretty" = callPackage
     ({ mkDerivation, base, containers, srcloc, text, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "matterhorn";
-       version = "40800.0.0";
-       sha256 = "0wzgy39halqd6bm0wvcsnk4l5ngdr4nwqbqk46jgnfb99nwsd3z6";
+       version = "40800.0.2";
+       sha256 = "0fgk0my3r0vcw545xqjcda8ikj5cbfzgg9vxfs3jzdcnsa0rgcyf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
          base base-compat brick bytestring cheapskate checkers config-ini
          connection containers directory filepath hashable Hclip
          mattermost-api mattermost-api-qc microlens-platform mtl process
-         quickcheck-text stm strict string-conversions tasty tasty-hunit
-         tasty-quickcheck text text-zipper time timezone-olson
+         quickcheck-text semigroups stm strict string-conversions tasty
+         tasty-hunit tasty-quickcheck text text-zipper time timezone-olson
          timezone-series transformers Unique unordered-containers vector vty
          xdg-basedir
        ];
···
      }:
      mkDerivation {
        pname = "mattermost-api";
-       version = "40800.0.0";
-       sha256 = "0yjs97c4rf2idj88y5gnkdvshlaz49zna1ssx1d910gm5b5cnqy5";
+       version = "40800.0.2";
+       sha256 = "1l2yb9nvy2haw5kyjjij465g45w8xm8vm97jbkx5jb3p4cs44xl8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "mattermost-api-qc";
-       version = "40800.0.0";
-       sha256 = "1j9f291s51a8i55y338kcvfkmlb3xsd0c4cjh0nl97x7p30dxcm6";
+       version = "40800.0.2";
+       sha256 = "04whpcbcd5cqnwfrskk3r2gjmyvap2m7d8xsjdry56kil6iqznk5";
        libraryHaskellDepends = [
          base containers mattermost-api QuickCheck text time
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "mltool_0_2_0_0" = callPackage
+    ({ mkDerivation, ascii-progress, base, deepseq, hmatrix
+     , hmatrix-gsl, hmatrix-morpheus, HUnit, MonadRandom, random
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , vector
+     }:
+     mkDerivation {
+       pname = "mltool";
+       version = "0.2.0.0";
+       sha256 = "0yjq9wbvni9sgh966jccfcsm6ajicrfkgvwg08383rwnsqbbjm8q";
+       libraryHaskellDepends = [
+         ascii-progress base deepseq hmatrix hmatrix-gsl hmatrix-morpheus
+         MonadRandom random vector
+       ];
+       testHaskellDepends = [
+         base hmatrix hmatrix-morpheus HUnit MonadRandom random
+         test-framework test-framework-hunit test-framework-quickcheck2
+         vector
+       ];
+       homepage = "https://github.com/alexander-ignatyev/mltool";
+       description = "Machine Learning Toolbox";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mmap" = callPackage
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
···
        doHaddock = false;
        description = "This package has been removed";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "monad-branch" = callPackage
+    ({ mkDerivation, base, mtl, transformers }:
+     mkDerivation {
+       pname = "monad-branch";
+       version = "1.0.3";
+       sha256 = "15nk9lvwz4s6lx8g08x5npai0bk13s6mj26vz6biwy3shpf5v11r";
+       libraryHaskellDepends = [ base mtl transformers ];
+       homepage = "https://github.com/luna/monad-branch";
+       description = "Monadic abstraction for computations that can be branched and run independently";
+       license = stdenv.lib.licenses.asl20;
      }) {};
 
   "monad-classes" = callPackage
···
        homepage = "https://github.com/oisdk/mono-traversable-wrapper";
        description = "Wrapper providing Foldable instance for MonoFoldables";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "monoid" = callPackage
+    ({ mkDerivation, base, containers, lens, mtl }:
+     mkDerivation {
+       pname = "monoid";
+       version = "0.1.8";
+       sha256 = "15mwj4w46wszawhiabykamaf020m795zg017jb2j49gpzk8abqjf";
+       libraryHaskellDepends = [ base containers lens mtl ];
+       homepage = "https://github.com/luna/monoid";
+       description = "Monoid type classes, designed in modular way, distinguish Monoid from Mempty and Semigroup. This design allows mempty operation don't bring Semigroups related constraints until (<>) is used.";
+       license = stdenv.lib.licenses.asl20;
      }) {};
 
   "monoid-absorbing" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "monoid-extras_0_4_3" = callPackage
+    ({ mkDerivation, base, criterion, groups, semigroupoids, semigroups
+     }:
+     mkDerivation {
+       pname = "monoid-extras";
+       version = "0.4.3";
+       sha256 = "1c2zdsyq0iyagzp9y64j75nxvpbjr5y3fdg8cd1pkfqgms977qsr";
+       revision = "1";
+       editedCabalFile = "08961ibwiqks8qw5cwpkzpz3acrlrd48l2sl1qny96gycaslzrps";
+       libraryHaskellDepends = [ base groups semigroupoids semigroups ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "Various extra monoid-related definitions and utilities";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "monoid-owns" = callPackage
     ({ mkDerivation, base, bytestring, containers }:
      mkDerivation {
···
     ({ mkDerivation, base, netlist, pretty }:
      mkDerivation {
        pname = "netlist-to-vhdl";
-       version = "0.3.2";
-       sha256 = "107pkkihj62qjkfwrnhwfscpph5r76lx6r3s0m3b0dbsf1jy2a61";
+       version = "0.3.3";
+       sha256 = "1f62l4i1l1z47gbrv49xx5y78ykcf6iq6bish3sx5fw46mhcr1j4";
        libraryHaskellDepends = [ base netlist pretty ];
        description = "Convert a Netlist AST to VHDL";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
        broken = true;
      }) {Nmis = null;};
+
+  "nn" = callPackage
+    ({ mkDerivation, base, random, split, tasty, tasty-hspec
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "nn";
+       version = "0.2.0";
+       sha256 = "1jl267495x7rc34x35dzrwb05z57w1w97vzgj774ld6z2w1yri7l";
+       libraryHaskellDepends = [ base random split ];
+       testHaskellDepends = [ base tasty tasty-hspec tasty-quickcheck ];
+       homepage = "https://github.com/saschagrunert/nn#readme";
+       description = "A tiny neural network";
+       license = stdenv.lib.licenses.mit;
+     }) {};
 
   "nntp" = callPackage
     ({ mkDerivation, base, bytestring, monad-loops, mtl, network
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "numhask_0_2_0_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "numhask";
+       version = "0.2.0.0";
+       sha256 = "1n465rjgmpwjixnnwn054323rg55abbj98brqzw4ff17hrvy97g0";
+       libraryHaskellDepends = [ base ];
+       homepage = "https://github.com/tonyday567/numhask#readme";
+       description = "numeric classes";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "numhask-array" = callPackage
     ({ mkDerivation, adjunctions, base, deepseq, dimensions
-     , distributive, doctest, ghc-typelits-natnormalise, numhask
-     , protolude, QuickCheck, singletons, tasty, tasty-quickcheck
-     , typelits-witnesses, vector
+     , distributive, doctest, numhask-prelude, protolude, QuickCheck
+     , singletons, tasty, tasty-quickcheck, vector
      }:
      mkDerivation {
        pname = "numhask-array";
-       version = "0.1.1.0";
-       sha256 = "0qdlc8ipjb6p5hcp7kvjspa3yjjdsjah1k5c35w6njy0ld9rdi54";
+       version = "0.2.0.1";
+       sha256 = "05y41d8xnrzgrb5w6skkac5hr6c7npwzmryx308cd0lp4nbfmvql";
        libraryHaskellDepends = [
-         adjunctions base deepseq dimensions distributive
-         ghc-typelits-natnormalise numhask protolude QuickCheck singletons
-         typelits-witnesses vector
+         adjunctions base deepseq dimensions distributive numhask-prelude
+         protolude QuickCheck singletons vector
        ];
        testHaskellDepends = [
-         base doctest numhask QuickCheck tasty tasty-quickcheck
+         base doctest numhask-prelude tasty tasty-quickcheck
        ];
        homepage = "https://github.com/tonyday567/numhask-array#readme";
-       description = "See readme.md";
+       description = "n-dimensional arrays";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "numhask-histogram" = callPackage
-    ({ mkDerivation, base, containers, doctest, foldl, HUnit, numhask
-     , numhask-range, protolude, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, tdigest
+    ({ mkDerivation, base, containers, doctest, foldl, numhask-prelude
+     , numhask-range, protolude, tasty, tdigest
      }:
      mkDerivation {
        pname = "numhask-histogram";
-       version = "0.0.1.0";
-       sha256 = "1s8z2fwgrnsaq0w9zda5rpf9dcrd51dqaq118r6pi2r7y1vwzd6k";
+       version = "0.1.0.0";
+       sha256 = "1ql07s8l9ci4k69y8g7x4227z5shdi5y8crqxqv45m6xcafhrv46";
        libraryHaskellDepends = [
-         base containers foldl numhask numhask-range protolude tdigest
-       ];
-       testHaskellDepends = [
-         base doctest HUnit protolude QuickCheck tasty tasty-hunit
-         tasty-quickcheck
+         base containers foldl numhask-prelude numhask-range tdigest
        ];
+       testHaskellDepends = [ base doctest protolude tasty ];
        homepage = "https://github.com/tonyday567/numhask-histogram#readme";
        description = "See readme.md";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "numhask-prelude" = callPackage
+    ({ mkDerivation, base, doctest, numhask, protolude, QuickCheck
+     , tasty, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "numhask-prelude";
+       version = "0.0.3.0";
+       sha256 = "128hnq32826d2rmrlik4p0c72jnsy586gz9lgfk7hnx0fqpr94gy";
+       libraryHaskellDepends = [
+         base numhask protolude QuickCheck tasty tasty-quickcheck
+       ];
+       testHaskellDepends = [ base doctest tasty ];
+       homepage = "https://github.com/tonyday567/numhask#readme";
+       description = "A numeric prelude";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "numhask-range" = callPackage
     ({ mkDerivation, adjunctions, base, distributive, doctest, numhask
      , protolude, QuickCheck, semigroupoids, tasty
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "numhask-range_0_2_0_0" = callPackage
+    ({ mkDerivation, adjunctions, base, distributive, doctest
+     , numhask-prelude, protolude, QuickCheck, semigroupoids, tasty
+     }:
+     mkDerivation {
+       pname = "numhask-range";
+       version = "0.2.0.0";
+       sha256 = "16al3f6w7g3616baz2xqp7pxlhzikchkr0l7qn7qif827qxmwgrz";
+       libraryHaskellDepends = [
+         adjunctions base distributive numhask-prelude protolude QuickCheck
+         semigroupoids
+       ];
+       testHaskellDepends = [ base doctest numhask-prelude tasty ];
+       homepage = "https://github.com/tonyday567/numhask-range#readme";
+       description = "Numbers that are range representations";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "nums" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
        description = "Client to the OANDA REST API";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "oasis-xrd" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
+     , text, time, uri-bytestring, xml-conduit, xml-conduit-writer
+     }:
+     mkDerivation {
+       pname = "oasis-xrd";
+       version = "1.0";
+       sha256 = "105m258yqfdmp1n7gd824gsry07xqlhfnpla2kb7sn36nckqr3a0";
+       revision = "1";
+       editedCabalFile = "1jwvncyyn8njzhjdgqwakqfddp34h26abnhypzbdsgn4nyxad1qs";
+       libraryHaskellDepends = [
+         aeson base bytestring containers text time uri-bytestring
+         xml-conduit xml-conduit-writer
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty base bytestring containers text time
+         uri-bytestring xml-conduit xml-conduit-writer
+       ];
+       homepage = "https://gitlab.com/dpwiz/oasis-xrd";
+       description = "Extensible Resource Descriptor";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "oauth10a" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "online_0_2_2_0" = callPackage
+    ({ mkDerivation, base, doctest, foldl, formatting, numhask-prelude
+     , optparse-generic, perf, protolude, scientific, tasty, tdigest
+     , text, vector, vector-algorithms
+     }:
+     mkDerivation {
+       pname = "online";
+       version = "0.2.2.0";
+       sha256 = "0k51wjj6ik7r65gp1kzkq1n7y8yxjiracs8i1yx2slz9jnfasgy5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base foldl numhask-prelude protolude tdigest vector
+         vector-algorithms
+       ];
+       executableHaskellDepends = [
+         base foldl formatting numhask-prelude optparse-generic perf
+         protolude scientific tdigest text
+       ];
+       testHaskellDepends = [ base doctest protolude tasty ];
+       homepage = "https://github.com/tonyday567/online#readme";
+       description = "online statistics";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "only" = callPackage
     ({ mkDerivation, base, parsec, regex-compat }:
      mkDerivation {
···
        pname = "opaleye";
        version = "0.6.1.0";
        sha256 = "0vjiwpdrff4nrs5ww8q3j77ysrq0if20yfk4gy182lr7nzhhwz0l";
+       revision = "1";
+       editedCabalFile = "07sz4a506hlx8da2ppiglja6hm9ipb2myh6s702ac6xx700cnl7f";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "packcheck";
-       version = "0.2.0";
-       sha256 = "0frxr78vkwm0yjxz1rq71h8b01krdidi19ld1yragkfk54krcz1n";
+       version = "0.3.0";
+       sha256 = "02ixa91wp0jxdc046gi5qxyyw332znkgknfz5chf4j3ydn7qjlha";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        benchmarkHaskellDepends = [ base ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "pads-haskell" = callPackage
+    ({ mkDerivation, base, byteorder, bytestring, Cabal, containers
+     , directory, Glob, haskell-src, haskell-src-meta, HUnit
+     , mainland-pretty, mtl, normaldistribution, old-locale, parsec
+     , QuickCheck, random, regex-posix, syb, template-haskell
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , th-lift, time, transformers
+     }:
+     mkDerivation {
+       pname = "pads-haskell";
+       version = "0.0.0.1";
+       sha256 = "1glf9zfzl8lg6hvqzh76y7kpi1d8jhxgxplnkzz4pdzrh1dfzm9a";
+       revision = "1";
+       editedCabalFile = "1nfh2i2g4xzqr534hkwa7gygkgsdvyjk4g075n78dp6r48zynbz6";
+       libraryHaskellDepends = [
+         base byteorder bytestring containers Glob haskell-src
+         haskell-src-meta HUnit mainland-pretty normaldistribution
+         old-locale parsec random regex-posix syb template-haskell th-lift
+         time transformers
+       ];
+       testHaskellDepends = [
+         base byteorder bytestring Cabal containers directory Glob
+         haskell-src haskell-src-meta HUnit mainland-pretty mtl old-locale
+         parsec QuickCheck regex-posix syb template-haskell test-framework
+         test-framework-hunit test-framework-quickcheck2 th-lift time
+         transformers
+       ];
+       homepage = "http://www.padsproj.org";
+       description = "PADS data description language for Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "pagarme" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, lens, text
      , wreq
···
     ({ mkDerivation, base, semigroups }:
      mkDerivation {
        pname = "papa-base-export";
-       version = "0.3.1";
-       sha256 = "13gd3ldpiwmms3di80smk68x4mf9nigy0irz506cayd9bwqpw3jv";
+       version = "0.4";
+       sha256 = "120b3ks9h3m9w6z365hmqrcp349kh3w8ii4kgki1zxjhh9z05mnm";
        libraryHaskellDepends = [ base semigroups ];
        homepage = "https://github.com/qfpl/papa";
        description = "Prelude with only useful functions";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "perf_0_4_0_1" = callPackage
+    ({ mkDerivation, base, containers, deepseq, doctest, foldl, rdtsc
+     , text, time, transformers
+     }:
+     mkDerivation {
+       pname = "perf";
+       version = "0.4.0.1";
+       sha256 = "1am2wzj43gi0naz5mwpvja9i005g05d6gpkqw0qvdy63mddz9b96";
+       libraryHaskellDepends = [
+         base containers deepseq foldl rdtsc text time transformers
+       ];
+       testHaskellDepends = [ base doctest ];
+       homepage = "https://github.com/tonyday567/perf#readme";
+       description = "Low-level run time measurement";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "perfect-hash-generator" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, data-ordlist
      , directory, filepath, hashable, HUnit, optparse-applicative
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "pig" = callPackage
+    ({ mkDerivation, base, containers, random, random-shuffle }:
+     mkDerivation {
+       pname = "pig";
+       version = "0.0.1";
+       sha256 = "0fh8lv85h2w6gs7zv1bqb4gc4id84c3vp3ivdrd9cvnxksr50ffr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers random random-shuffle ];
+       executableHaskellDepends = [
+         base containers random random-shuffle
+       ];
+       description = "dice game";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "piki" = callPackage
     ({ mkDerivation, base, mtl, parsec, text }:
      mkDerivation {
···
     ({ mkDerivation, base, bifunctors, bytestring, conceit, doctest
      , foldl, free, microlens, pipes, pipes-bytestring
      , pipes-concurrency, pipes-group, pipes-parse, pipes-safe
-     , pipes-text, tasty, tasty-hunit, text, transformers, void
+     , pipes-text, streaming, tasty, tasty-hunit, text, transformers
+     , void
      }:
      mkDerivation {
        pname = "pipes-transduce";
-       version = "0.4.1";
-       sha256 = "10lf6fnnq1zf9v04l00f1nd4s6qq6a0pcdl72vxczmj6rn3c0kgq";
+       version = "0.4.3.2";
+       sha256 = "0q4xc2r0yzyj6gpg16z9scdxm0a3fjzsm1r6qihkr2zks9sac36x";
        libraryHaskellDepends = [
          base bifunctors bytestring conceit foldl free microlens pipes
          pipes-bytestring pipes-concurrency pipes-group pipes-parse
-         pipes-safe pipes-text text transformers void
+         pipes-safe pipes-text streaming text transformers void
        ];
        testHaskellDepends = [
          base doctest foldl free pipes tasty tasty-hunit text
···
        homepage = "https://github.com/pjones/playlists-http";
        description = "Library to glue together playlists and http-client";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "plex" = callPackage
+    ({ mkDerivation, async, base, bytestring, deepseq, hspec
+     , QuickCheck, unix
+     }:
+     mkDerivation {
+       pname = "plex";
+       version = "0.2.0.0";
+       sha256 = "0y0a3d30k4d3111smfidzzv1z7cq0i47wxvyh9iwbnn223s3446y";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ async base bytestring deepseq unix ];
+       testHaskellDepends = [
+         async base bytestring deepseq hspec QuickCheck unix
+       ];
+       homepage = "https://github.com/phlummox/hs-plex#readme";
+       description = "run a subprocess, combining stdout and stderr";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "plist" = callPackage
···
   "preamble" = callPackage
     ({ mkDerivation, aeson, base, basic-prelude, exceptions
      , fast-logger, lens, lifted-base, monad-control, monad-logger
-     , MonadRandom, mtl, network, resourcet, safe, shakers
-     , template-haskell, text, text-manipulate, time, transformers-base
+     , MonadRandom, mtl, network, resourcet, safe, template-haskell
+     , text, text-manipulate, time, transformers-base
      , unordered-containers, uuid
      }:
      mkDerivation {
        pname = "preamble";
-       version = "0.0.59";
-       sha256 = "0i9blxkdjm4fm288qr6isl3jyjrw6x6x58z6lvaj62xr3y4rqd43";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.0.60";
+       sha256 = "1ygpyaniv4f9ahmnrpkirhmfry40afqwaici4ksrnr3pz64fsll5";
        libraryHaskellDepends = [
          aeson base basic-prelude exceptions fast-logger lens lifted-base
          monad-control monad-logger MonadRandom mtl network resourcet safe
          template-haskell text text-manipulate time transformers-base
        description = "A named lock that is created on demand";
        ];
-       executableHaskellDepends = [ base shakers ];
        homepage = "https://github.com/swift-nav/preamble";
        description = "Yet another prelude";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "process-streaming";
-       version = "0.9.2.1";
-       sha256 = "1p1nfb09sg9krwm7k6j8y5ggbc28yddlkf2yifs06iqfkcmbsbm6";
+       version = "0.9.3.0";
+       sha256 = "06x2xcjbhwhnwyml8kxqa5wl89mr9fbbpgplysd68d01yhm2dnmr";
        libraryHaskellDepends = [
          base bifunctors bytestring conceit free kan-extensions pipes
          pipes-bytestring pipes-concurrency pipes-parse pipes-safe
···
        homepage = "https://github.com/tomjaguarpaw/product-profunctors";
        description = "product-profunctors";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "product-profunctors_0_10_0_0" = callPackage
+    ({ mkDerivation, base, bifunctors, contravariant, criterion
+     , deepseq, profunctors, tagged, template-haskell
+     }:
+     mkDerivation {
+       pname = "product-profunctors";
+       version = "0.10.0.0";
+       sha256 = "0s0ssl2900r16992mgl0idkryg3l7psp8nljyg9brr7fqa3pd3dd";
+       libraryHaskellDepends = [
+         base bifunctors contravariant profunctors tagged template-haskell
+       ];
+       testHaskellDepends = [ base profunctors ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
+       homepage = "https://github.com/tomjaguarpaw/product-profunctors";
+       description = "product-profunctors";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "prof2dot" = callPackage
···
      }) {};
 
   "prologue" = callPackage
-    ({ mkDerivation, base, bifunctors, binary, cond, container, convert
-     , data-default, data-layer, errors, functor-utils, impossible, lens
-     , lens-utils, mtl, pretty-show, string-qq, text, transformers
-     , transformers-base, tuple, typelevel, vector
+    ({ mkDerivation, base, bifunctors, binary, comonad, cond, container
+     , convert, data-default, deepseq, deriving-compat, either, errors
+     , exceptions, functor-utils, ghc-prim, impossible, lens, lens-utils
+     , monoid, mtl, neat-interpolation, placeholders, pointed
+     , pretty-show, primitive, raw-strings-qq, recursion-schemes
+     , semigroupoids, string-qq, template-haskell, text, transformers
+     , transformers-base, typelevel, vector
      }:
      mkDerivation {
        pname = "prologue";
-       version = "1.0.7";
-       sha256 = "0nwk6m93c2mgzagzad1zkp5p6wnjdz668bw109vwwb0yi23c3s1p";
+       version = "3.1.3";
+       sha256 = "1nzm4hgjwpbxmvd1y1x58smxbk5ahfyygi22jwwyzqaknrgs5ara";
        libraryHaskellDepends = [
-         base bifunctors binary cond container convert data-default
-         data-layer errors functor-utils impossible lens lens-utils mtl
-         pretty-show string-qq text transformers transformers-base tuple
-         typelevel vector
+         base bifunctors binary comonad cond container convert data-default
+         deepseq deriving-compat either errors exceptions functor-utils
+         ghc-prim impossible lens lens-utils monoid mtl neat-interpolation
+         placeholders pointed pretty-show primitive raw-strings-qq
+         recursion-schemes semigroupoids string-qq template-haskell text
+         transformers transformers-base typelevel vector
        ];
        homepage = "https://github.com/wdanilo/prologue";
        description = "Better, more general Prelude exporting common utilities";
···
      }:
      mkDerivation {
        pname = "ptr";
-       version = "0.16.2";
-       sha256 = "0sa3akkhydyxr7caig8z6bjwiaarr171qazfbwm9kh8x1pdah5dv";
+       version = "0.16.4";
+       sha256 = "0na3by8mh43cd0xn1s1l7hi3mmm3damr9swgv6mzyg9lhilsndxb";
        libraryHaskellDepends = [
          base base-prelude bug bytestring contravariant mtl profunctors
          semigroups text time transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "pusher-http-haskell_1_5_1_4" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , cryptonite, hashable, hspec, http-client, http-types, memory
+     , QuickCheck, scientific, text, time, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "pusher-http-haskell";
+       version = "1.5.1.4";
+       sha256 = "1h6dl0h9ybbnjqs834bd1n5w4cx0vdbmi52mqdk2y9y267qc9k4a";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptonite hashable
+         http-client http-types memory text time transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptonite hspec
+         http-client http-types QuickCheck scientific text time transformers
+         unordered-containers vector
+       ];
+       homepage = "https://github.com/pusher-community/pusher-http-haskell";
+       description = "Haskell client library for the Pusher HTTP API";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "pusher-ws" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, deepseq
      , hashable, http-conduit, lens, lens-aeson, network, scientific
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "quickcheck-classes_0_4_8" = callPackage
+  "quickcheck-classes_0_4_9" = callPackage
     ({ mkDerivation, aeson, base, bifunctors, containers, primitive
      , QuickCheck, semigroupoids, semigroups, tagged, transformers
      , vector
      }:
      mkDerivation {
        pname = "quickcheck-classes";
-       version = "0.4.8";
-       sha256 = "1smsm1jjb2sr6b1d064yf7cj5bad22v4xv6rmjb3adaif34iw5fy";
+       version = "0.4.9";
+       sha256 = "1m5qszs50hjfycds84arfcfqj7z4l622479bd2w55vin49mp12pn";
        libraryHaskellDepends = [
          aeson base bifunctors containers primitive QuickCheck semigroupoids
          semigroups tagged transformers
···
        pname = "quickcheck-instances";
        version = "0.3.18";
        sha256 = "1bh1pzz5fdcqvzdcirqxna6fnjms02min5md716299g5niz46w55";
+       revision = "1";
+       editedCabalFile = "1sngfq3v71bvgjsl8cj5kh65m3fziwy8dkvwjzs0kxfrzr87faly";
        libraryHaskellDepends = [
          array base base-compat bytestring case-insensitive containers
          hashable old-time QuickCheck scientific tagged text time
···
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Test properties and default-mains for QuickCheck";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "quickcheck-simple_0_1_0_3" = callPackage
+    ({ mkDerivation, base, QuickCheck }:
+     mkDerivation {
+       pname = "quickcheck-simple";
+       version = "0.1.0.3";
+       sha256 = "08f87mqnm04sgi21q5snvr4li3zm4m86jydc3s4b71i9czy4q8wg";
+       libraryHaskellDepends = [ base QuickCheck ];
+       description = "Test properties and default-mains for QuickCheck";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "quickcheck-special" = callPackage
···
      }) {};
 
   "radian" = callPackage
-    ({ mkDerivation, base, directory, doctest, filepath, lens
-     , profunctors, QuickCheck, template-haskell
-     }:
+    ({ mkDerivation, base, HUnit, lens, profunctors }:
      mkDerivation {
        pname = "radian";
-       version = "0.0.6";
-       sha256 = "0p6caw8vnlzmamcka9wfsbgsfffgp2y6jjf5yyibvnb9av8zdnzp";
+       version = "0.1";
+       sha256 = "150vb9wk73avh8rrsz92y1fcwlm30w4k23lbdncb8ivinqhdi4pv";
        libraryHaskellDepends = [ base profunctors ];
-       testHaskellDepends = [
-         base directory doctest filepath lens QuickCheck template-haskell
-       ];
-       homepage = "https://github.com/NICTA/radian";
+       testHaskellDepends = [ base HUnit lens ];
+       homepage = "https://github.com/qfpl/radian";
        description = "Isomorphisms for measurements that use radians";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "rio";
-       version = "0.0.3.0";
-       sha256 = "1mbxd2v0n0hbrmb1xh27snxxp1r8k87g4ijqsp99hnis8vmqmz84";
+       version = "0.1.0.0";
+       sha256 = "0k3r7859in1dyybc7lr3bqh91harf7g5yknwxmmsqnhlffzc6ygr";
        libraryHaskellDepends = [
          base bytestring containers deepseq directory exceptions filepath
          hashable microlens mtl primitive process text time typed-process
···
        ];
        homepage = "https://github.com/commercialhaskell/rio#readme";
        description = "A standard library for Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "rio-orphans" = callPackage
+    ({ mkDerivation, base, exceptions, hspec, monad-control, resourcet
+     , rio, transformers-base
+     }:
+     mkDerivation {
+       pname = "rio-orphans";
+       version = "0.1.0.0";
+       sha256 = "09wy9h6smh532lrh13qzmni91yfb702x8i97r24d3ny6i3krzqi7";
+       libraryHaskellDepends = [
+         base exceptions monad-control resourcet rio transformers-base
+       ];
+       testHaskellDepends = [
+         base exceptions hspec monad-control resourcet rio transformers-base
+       ];
+       homepage = "https://github.com/commercialhaskell/rio#readme";
+       description = "Orphan instances for the RIO type in the rio package";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "scotty_0_11_1" = callPackage
+    ({ mkDerivation, aeson, async, base, blaze-builder, bytestring
+     , case-insensitive, data-default-class, directory, exceptions, fail
+     , hpc-coveralls, hspec, hspec-discover, hspec-wai, http-types
+     , lifted-base, monad-control, mtl, nats, network, regex-compat
+     , text, transformers, transformers-base, transformers-compat, wai
+     , wai-extra, warp
+     }:
+     mkDerivation {
+       pname = "scotty";
+       version = "0.11.1";
+       sha256 = "1xcdfx43v1p2a20jjmnb70v2sm34iprn17ssa81fcfnabcn4blhw";
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring case-insensitive
+         data-default-class exceptions fail http-types monad-control mtl
+         nats network regex-compat text transformers transformers-base
+         transformers-compat wai wai-extra warp
+       ];
+       testHaskellDepends = [
+         async base bytestring data-default-class directory hpc-coveralls
+         hspec hspec-wai http-types lifted-base network text wai
+       ];
+       testToolDepends = [ hspec-discover ];
+       homepage = "https://github.com/scotty-web/scotty";
+       description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "scotty-binding-play" = callPackage
     ({ mkDerivation, base, bytestring, hspec, http-client, HUnit, mtl
      , scotty, template-haskell, text, transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "servant-github-webhook_0_4_1_0" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , cryptonite, github, github-webhooks, http-types, memory, servant
+     , servant-server, string-conversions, text, transformers
+     , unordered-containers, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-github-webhook";
+       version = "0.4.1.0";
+       sha256 = "0v6gd7swhl58x3sqbb5cmn5ac6x1p5mg7jqbwk9ny9bzggz9pglb";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptonite github
+         github-webhooks http-types memory servant servant-server
+         string-conversions text transformers unordered-containers wai
+       ];
+       testHaskellDepends = [
+         aeson base bytestring servant-server text transformers wai warp
+       ];
+       homepage = "https://github.com/tsani/servant-github-webhook";
+       description = "Servant combinators to facilitate writing GitHub webhooks";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "servant-haxl-client" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , deepseq, either, exceptions, hashable, haxl, hspec, http-client
···
     ({ mkDerivation, base, safe, servant, servant-server, text }:
      mkDerivation {
        pname = "servant-pagination";
-       version = "1.0.0";
-       sha256 = "1cxd9sqryk619ss7x55w8xh4y3dkxl0gcdr3kawryzcm64qlgyja";
-       revision = "1";
-       editedCabalFile = "0y9mg8jaag07f89krsk2n3y635rjgmcym1kx130s7hb3h3ly7713";
+       version = "2.0.0";
+       sha256 = "1z6sr43ir9sl85x65yfj21s77y1fqwzfmrfgjlqdas2zygd3fhh3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base safe servant servant-server text ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "shake_0_16_4" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, directory
+     , extra, filepath, hashable, js-flot, js-jquery, primitive, process
+     , QuickCheck, random, time, transformers, unix
+     , unordered-containers, utf8-string
+     }:
+     mkDerivation {
+       pname = "shake";
+       version = "0.16.4";
+       sha256 = "0dhlkcn1zsg1w97vzs1yrpkn6iwhlzh36dwclx2lafzbdjja6cmp";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base binary bytestring deepseq directory extra filepath hashable
+         js-flot js-jquery primitive process random time transformers unix
+         unordered-containers utf8-string
+       ];
+       executableHaskellDepends = [
+         base binary bytestring deepseq directory extra filepath hashable
+         js-flot js-jquery primitive process random time transformers unix
+         unordered-containers utf8-string
+       ];
+       testHaskellDepends = [
+         base binary bytestring deepseq directory extra filepath hashable
+         js-flot js-jquery primitive process QuickCheck random time
+         transformers unix unordered-containers utf8-string
+       ];
+       homepage = "https://shakebuild.com";
+       description = "Build system library, like Make, but more accurate dependencies";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "shake-ats" = callPackage
     ({ mkDerivation, base, binary, dependency, directory, hashable
      , hs2ats, language-ats, microlens, microlens-th, shake, shake-ext
···
      }) {};
 
   "shake-ext" = callPackage
-    ({ mkDerivation, base, Cabal, composition-prelude, directory, shake
-     , template-haskell
+    ({ mkDerivation, base, Cabal, composition-prelude, cpphs, directory
+     , shake, template-haskell
      }:
      mkDerivation {
        pname = "shake-ext";
-       version = "2.9.0.1";
-       sha256 = "1znql8sddxm8xxzhz4ibhvc29ni345airily5ky51vq6qbs0g4r2";
+       version = "2.11.0.0";
+       sha256 = "1ny8fj8wdshwp5df8skl3lsl5rp30fa8yclhh696pwk433pijc8f";
        libraryHaskellDepends = [
-         base Cabal composition-prelude directory shake template-haskell
+         base Cabal composition-prelude cpphs directory shake
+         template-haskell
        ];
        homepage = "https://hub.darcs.net/vmchale/shake-ext";
        description = "Helper functions for linting with shake";
···
      }) {};
 
   "shakers" = callPackage
-    ({ mkDerivation, base, basic-prelude, deepseq, directory
-     , lifted-base, regex-compat, shake
+    ({ mkDerivation, base, basic-prelude, directory, lifted-base, shake
      }:
      mkDerivation {
        pname = "shakers";
-       version = "0.0.42";
-       sha256 = "020j1j5lpl5x0hxgscy1skx1fqw77w184h86rvgkq1kli7pp9kpk";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.0.45";
+       sha256 = "0abzw28861k3larph3i6kaqsx4zcbk25f69y47v4i61riwdxcj0j";
        libraryHaskellDepends = [
-         base basic-prelude deepseq directory lifted-base regex-compat shake
+         base basic-prelude directory lifted-base shake
        ];
-       executableHaskellDepends = [ base ];
        homepage = "https://github.com/swift-nav/shakers";
        description = "Shake helpers";
        license = stdenv.lib.licenses.mit;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "simple-src-utils" = callPackage
+    ({ mkDerivation, base, extra, tasty, tasty-hunit, text }:
+     mkDerivation {
+       pname = "simple-src-utils";
+       version = "0.1";
+       sha256 = "0cfa2l7a0c8kgr0707jnk2qzh12a2564bdzzynjzcdjdqda6d5ch";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [ base extra text ];
+       testHaskellDepends = [ base extra tasty tasty-hunit text ];
+       homepage = "https://github.com/elaforge/simple-src-utils";
+       description = "source code editing utilities";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "simple-stacked-vm" = callPackage
     ({ mkDerivation, array, base, binary-state, containers, filepath
      , mtl, parsec
···
      }:
      mkDerivation {
        pname = "slate";
-       version = "0.9.0.0";
-       sha256 = "19619ladqp1faqdn4z2yrxvffpcr9k0s942s6rjg73i229hccv8f";
+       version = "0.10.0.0";
+       sha256 = "0f21bmv0dckdim27mm5m7vphci45h6fjbxyzpahai2nlydilhnc6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
-  "sparse-linear-algebra_0_3" = callPackage
+  "sparse-linear-algebra_0_3_1" = callPackage
     ({ mkDerivation, base, containers, exceptions, hspec
      , matrix-market-attoparsec, mtl, mwc-random, primitive, QuickCheck
      , scientific, transformers, vector, vector-algorithms
      }:
      mkDerivation {
        pname = "sparse-linear-algebra";
-       version = "0.3";
-       sha256 = "10s3z0mva8hf9f2ckbpfkzdkhnixp73xli5yigh4d44662rzwqn1";
+       version = "0.3.1";
+       sha256 = "1jfwydr0pzph932h7jvnmp1d8qqrhxsq7rbb6cjbmga55s5pfqn7";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers exceptions hspec mtl primitive QuickCheck
···
        pname = "splitmix";
        version = "0";
        sha256 = "0qa86iflw1v8vqci8krj4kdvp648hnl8wx3wyhnd1c95jrla0fpi";
-       revision = "1";
-       editedCabalFile = "0dh4p3rzvx3zwj0bh5flf4qsiw831rb4vxmbh5jq45qkvry8z8hy";
+       revision = "2";
+       editedCabalFile = "0fl7z9lxkyvqk0d14d778j3lk8zi8jgncwq41gqi4z78a20xb2pg";
        libraryHaskellDepends = [ base random time ];
        testHaskellDepends = [
          base base-compat bytestring random tf-random
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "squeal-postgresql_0_2_0_1" = callPackage
+  "squeal-postgresql_0_2_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, doctest
      , generics-sop, lifted-base, mmorph, monad-control, mtl, network-ip
      , postgresql-binary, postgresql-libpq, resource-pool, scientific
···
      }:
      mkDerivation {
        pname = "squeal-postgresql";
-       version = "0.2.0.1";
-       sha256 = "1flpjfgf7ahgaraab9d26c5imp03f6ljkl10jzdc6f0kf2529fg8";
+       version = "0.2.1.0";
+       sha256 = "1qfz1c4yzjshgvc64plahy3aar96yvcmn2m5giyp17nrfgq266qs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "stocks" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-conduit, semigroups
+     }:
+     mkDerivation {
+       pname = "stocks";
+       version = "0.1.0.0";
+       sha256 = "10ws7mg0236iqkjclajwph2lb5719adkay5imaxrsj13d10f8ssq";
+       libraryHaskellDepends = [
+         aeson base bytestring http-conduit semigroups
+       ];
+       homepage = "https://github.com/dabcoder/stocks#readme";
+       description = "Library for the IEX Trading API";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "stomp-conduit" = callPackage
     ({ mkDerivation, base, conduit, mime, mtl, resourcet, stomp-queue
      , stompl
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "streaming-bytestring_0_1_6" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, exceptions, mmorph, mtl
+     , resourcet, smallcheck, streaming, tasty, tasty-smallcheck
+     , transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "streaming-bytestring";
+       version = "0.1.6";
+       sha256 = "1lsklavhk6wcsgjr2rcwkkv827gnd9spv4zwz5i5zf3njvy27my1";
+       libraryHaskellDepends = [
+         base bytestring deepseq exceptions mmorph mtl resourcet streaming
+         transformers transformers-base
+       ];
+       testHaskellDepends = [
+         base bytestring smallcheck streaming tasty tasty-smallcheck
+         transformers
+       ];
+       homepage = "https://github.com/haskell-streaming/streaming-bytestring";
+       description = "effectful byte steams, or: bytestring io done right";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "streaming-cassava" = callPackage
     ({ mkDerivation, base, bytestring, cassava, hspec, mtl, QuickCheck
      , quickcheck-instances, streaming, streaming-bytestring, text
···
        pname = "swagger2";
        version = "2.2.1";
        sha256 = "11i0yg2g4bw8pjz9p0w7qz7hpriji9zkiz3y5gr26pwb3fzab5qz";
+       revision = "1";
+       editedCabalFile = "00snyp95rjh3h7yqfwg3x4y9gjhypm6zfv45i2sag4w5cydvkzb5";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson base base-compat bytestring containers generics-sop hashable
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "terminal-text" = callPackage
+    ({ mkDerivation, ansi-terminal, base, container, layered-state
+     , prologue, text
+     }:
+     mkDerivation {
+       pname = "terminal-text";
+       version = "1.1.1";
+       sha256 = "1jgdxqck3ck65mppi694w0f5x0547148y5agi100zggp8r3yxsy3";
+       libraryHaskellDepends = [
+         ansi-terminal base container layered-state prologue text
+       ];
+       homepage = "https://github.com/luna/terminal-text";
+       description = "Text data type for styled terminal output, including all standard ANSI effects (bold, italic, blinking) and ANSI / 256 / truecolor colors support for Unix and Windows (whenever possible)";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "termination-combinators" = callPackage
     ({ mkDerivation, base, containers, contravariant }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "text-format-heavy";
-       version = "0.1.5.0";
-       sha256 = "127h2pw3p9ixx34jiql9kgpjbjmkmwigm56iklaz6wxd69zr0sfx";
+       version = "0.1.5.1";
+       sha256 = "14hmzsxhbqr95r7sbpziv897akdw8p54fhwh56j0h9hqnpwxxwgd";
        libraryHaskellDepends = [
          base bytestring containers data-default parsec text time
        ];
···
      }:
      mkDerivation {
        pname = "text-regex-replace";
-       version = "0.1.1.1";
-       sha256 = "0n0jk3qdcdhy3b91x7xkyc87xk3405g49qrgcfzb3ksr9qyw89rg";
+       version = "0.1.1.2";
+       sha256 = "1v6gjimq4qzldpc3ihvf0mn24n3mfk4vs87b7xzgmzk63sbpijyk";
        libraryHaskellDepends = [ attoparsec base text text-icu ];
        testHaskellDepends = [
          base hspec QuickCheck smallcheck text text-icu
···
        pname = "text-show";
        version = "3.7.2";
        sha256 = "0gb7y83w81zvfi7szb62d17w0qi7ca7ybri81adqk141c3cxc83s";
-       revision = "1";
-       editedCabalFile = "1iaa9scqwys9da98ya62jz2lyqia79ys8zq4hhcgb3l45x0ngc27";
+       revision = "2";
+       editedCabalFile = "0fjysjlmvvzvndxsni2ja92kr1pyqgl4dyc5c7x2ffaf02g9h2d2";
        libraryHaskellDepends = [
          array base base-compat bifunctors bytestring bytestring-builder
          containers contravariant generic-deriving ghc-boot-th ghc-prim
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "text-show_3_7_3" = callPackage
+    ({ mkDerivation, array, base, base-compat-batteries, base-orphans
+     , bifunctors, bytestring, bytestring-builder, containers
+     , contravariant, criterion, deepseq, deriving-compat
+     , generic-deriving, ghc-boot-th, ghc-prim, hspec, hspec-discover
+     , integer-gmp, nats, QuickCheck, quickcheck-instances, semigroups
+     , tagged, template-haskell, text, th-abstraction, th-lift
+     , transformers, transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "text-show";
+       version = "3.7.3";
+       sha256 = "1d8wmdndl8qsz90fb67xxbrprlmmp47p4f3ik6psp5m6r0cdvpzg";
+       libraryHaskellDepends = [
+         array base base-compat-batteries bifunctors bytestring
+         bytestring-builder containers contravariant generic-deriving
+         ghc-boot-th ghc-prim integer-gmp nats semigroups tagged
+         template-haskell text th-abstraction th-lift transformers
+         transformers-compat void
+       ];
+       testHaskellDepends = [
+         array base base-compat-batteries base-orphans bifunctors bytestring
+         bytestring-builder containers contravariant deriving-compat
+         generic-deriving ghc-boot-th ghc-prim hspec integer-gmp nats
+         QuickCheck quickcheck-instances semigroups tagged template-haskell
+         text th-lift transformers transformers-compat void
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         array base base-compat-batteries bifunctors bytestring
+         bytestring-builder containers contravariant criterion deepseq
+         generic-deriving ghc-boot-th ghc-prim integer-gmp nats semigroups
+         tagged template-haskell text th-lift transformers
+         transformers-compat void
+       ];
+       homepage = "https://github.com/RyanGlScott/text-show";
+       description = "Efficient conversion of values into Text";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "text-show-instances" = callPackage
     ({ mkDerivation, base, base-compat, bifunctors, binary, bytestring
      , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
···
        homepage = "https://github.com/RyanGlScott/text-show-instances";
        description = "Additional instances for text-show";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "text-show-instances_3_6_4" = callPackage
+    ({ mkDerivation, base, base-compat-batteries, bifunctors, binary
+     , bytestring, containers, directory, generic-deriving, ghc-boot-th
+     , ghc-prim, haskeline, hoopl, hpc, hspec, hspec-discover
+     , old-locale, old-time, pretty, process, QuickCheck
+     , quickcheck-instances, random, semigroups, tagged
+     , template-haskell, terminfo, text, text-show, th-orphans, time
+     , transformers, transformers-compat, unix, unordered-containers
+     , vector, xhtml
+     }:
+     mkDerivation {
+       pname = "text-show-instances";
+       version = "3.6.4";
+       sha256 = "1a2aacy6l58b49868hhvqws4900rq9dpb8zwkb5cz45gsb7zpgjf";
+       libraryHaskellDepends = [
+         base base-compat-batteries bifunctors binary bytestring containers
+         directory ghc-boot-th haskeline hoopl hpc old-locale old-time
+         pretty process random semigroups tagged template-haskell terminfo
+         text text-show time transformers transformers-compat unix
+         unordered-containers vector xhtml
+       ];
+       testHaskellDepends = [
+         base base-compat-batteries bifunctors binary bytestring containers
+         directory generic-deriving ghc-boot-th ghc-prim haskeline hoopl hpc
+         hspec old-locale old-time pretty process QuickCheck
+         quickcheck-instances random semigroups tagged template-haskell
+         terminfo text text-show th-orphans time transformers
+         transformers-compat unix unordered-containers vector xhtml
+       ];
+       testToolDepends = [ hspec-discover ];
+       homepage = "https://github.com/RyanGlScott/text-show-instances";
+       description = "Additional instances for text-show";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "text-stream-decode" = callPackage
···
      }:
      mkDerivation {
        pname = "th-format";
-       version = "0.1.0.0";
-       sha256 = "0vyvw9m28xb2playrzc533173p26jnlr8w1sbjc9w81y17676z3x";
+       version = "0.1.1.0";
+       sha256 = "1axan3icxz9yxkra2kb9r66h9h51v4zbjncd1xsvgiplqmwf6fjl";
        libraryHaskellDepends = [
          base Earley haskell-src-meta template-haskell text
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "tibetan-utils_0_1_1_5" = callPackage
+    ({ mkDerivation, base, composition-prelude, either, hspec
+     , hspec-megaparsec, megaparsec, text, text-show
+     }:
+     mkDerivation {
+       pname = "tibetan-utils";
+       version = "0.1.1.5";
+       sha256 = "09bqix2a2js98rhp748qx2i0vnxya3c6zvpjizbbnf5fwpspy01q";
+       revision = "1";
+       editedCabalFile = "0wmfv4dxjhjwsnkc8n7jfhbkvc7zwgcmkj7pvabmhcjzn5ch0dck";
+       libraryHaskellDepends = [
+         base composition-prelude either megaparsec text text-show
+       ];
+       testHaskellDepends = [
+         base hspec hspec-megaparsec megaparsec text
+       ];
+       homepage = "https://github.com/vmchale/tibetan-utils#readme";
+       description = "Parse and display tibetan numerals";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tic-tac-toe" = callPackage
     ({ mkDerivation, base, glade, gtk, haskell98 }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "time-locale-compat_0_1_1_4" = callPackage
+    ({ mkDerivation, base, old-locale, time }:
+     mkDerivation {
+       pname = "time-locale-compat";
+       version = "0.1.1.4";
+       sha256 = "0qmyxf8nz0q6brvplc4s2wsb1bbpq7kb65b69m503g9bgranblgj";
+       libraryHaskellDepends = [ base old-locale time ];
+       homepage = "https://github.com/khibino/haskell-time-locale-compat";
+       description = "Compatibile module for time-format locale";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "time-locale-vietnamese" = callPackage
     ({ mkDerivation, base, time }:
      mkDerivation {
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "timemap_0_0_7" = callPackage
+    ({ mkDerivation, base, containers, criterion, focus, hashable
+     , list-t, QuickCheck, quickcheck-instances, stm, stm-containers
+     , tasty, tasty-quickcheck, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "timemap";
+       version = "0.0.7";
+       sha256 = "06rx5q1b0r4chiiy9wi9k0q9qc4yxjk794hcq8dr7gpixgcrjjrg";
+       libraryHaskellDepends = [
+         base containers focus hashable list-t stm stm-containers time
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         base containers focus hashable list-t QuickCheck
+         quickcheck-instances stm stm-containers tasty tasty-quickcheck time
+         unordered-containers
+       ];
+       benchmarkHaskellDepends = [
+         base containers criterion focus hashable list-t stm stm-containers
+         time unordered-containers
+       ];
+       homepage = "https://github.com/athanclark/timemap#readme";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "timeout" = callPackage
     ({ mkDerivation, base, exceptions, mtl, QuickCheck, tasty
      , tasty-quickcheck, time
···
      }:
      mkDerivation {
        pname = "tracetree";
-       version = "0.1.0.1";
-       sha256 = "05aigx15kyvy19gdzh9si2avl5a7g8c4yzrcp7sgy1d94dwypl0j";
-       revision = "1";
-       editedCabalFile = "0yppsjjvq2zpk9k3fpi7q9msww4biz6hn02waschca65s2gbc84y";
+       version = "0.1.0.2";
+       sha256 = "0ga78nkrfg2hlanqfd65il0yw596n7xy9jx76l7sffs438mx4wvr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "transformers-lift";
        version = "0.2.0.1";
        sha256 = "17g03r5hpnygx0c9ybr9za6208ay0cjvz47rkyplv1r9zcivzn0b";
+       revision = "1";
+       editedCabalFile = "1dy9vg0drkm9ria80hlfx6v72ji2fwmv3ik7lryv7i7hk0bdzk8l";
        libraryHaskellDepends = [
          base transformers writer-cps-transformers
        ];
···
     ({ mkDerivation, base, containers, stm }:
      mkDerivation {
        pname = "turn-loop";
-       version = "0.0.0";
-       sha256 = "08v4kswmj2phsm4mxgvifjgxky72xpml0kkabvgxn39i87p1y572";
+       version = "0.1.0";
+       sha256 = "180yplkjf0c4n17a5ad2pakjwnh7830rldzmaqjj7gwcl3pg0lc6";
        libraryHaskellDepends = [ base containers stm ];
        homepage = "https://github.com/jxv/turn-loop#readme";
        description = "Manage multiple turned-based sessions";
···
 
   "type-tree" = callPackage
     ({ mkDerivation, base, base-compat, Cabal, cabal-doctest
-     , containers, doctest, mtl, pretty, template-haskell
+     , containers, doctest, mtl, pretty, template-haskell, zenc
      }:
      mkDerivation {
        pname = "type-tree";
-       version = "0.1.0.1";
-       sha256 = "13jcaq977yk7vjqlq2rndhryvfy3cb56mlgyim1aza17ibf67jmp";
+       version = "0.2.0.1";
+       sha256 = "1gwa8dklc9hipgwcx068p4a49m9hgjh97qp5q3p5yai6jdg24j94";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
-         base base-compat Cabal containers mtl pretty template-haskell
+         base base-compat containers mtl pretty template-haskell zenc
        ];
        testHaskellDepends = [ base doctest ];
        homepage = "https://github.com/pikajude/type-tree";
···
      }) {};
 
   "typelevel" = callPackage
-    ({ mkDerivation, base, pretty, pretty-show }:
+    ({ mkDerivation, base, constraints, convert, exceptions, lens, mtl
+     , pretty, pretty-show, primitive, transformers
+     }:
      mkDerivation {
        pname = "typelevel";
-       version = "1.0.4";
-       sha256 = "1hhx8zgsxpd5y2lp72c7dpyp7p678fjp63cqd14wiy9cdqd17j0w";
-       libraryHaskellDepends = [ base pretty pretty-show ];
-       homepage = "https://github.com/wdanilo/typelevel";
+       version = "1.2.2";
+       sha256 = "0baigk89rd5cdy35v3abvdwh7g11fnz2rpnzfy4ahr0q1lj395f5";
+       libraryHaskellDepends = [
+         base constraints convert exceptions lens mtl pretty pretty-show
+         primitive transformers
+       ];
+       homepage = "https://github.com/luna/typelevel";
        description = "Useful type level operations (type families and related operators)";
        license = stdenv.lib.licenses.asl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "unicode-transforms_0_3_4" = callPackage
+    ({ mkDerivation, base, bitarray, bytestring, deepseq, filepath
+     , gauge, getopt-generics, optparse-applicative, path, path-io
+     , QuickCheck, split, text
+     }:
+     mkDerivation {
+       pname = "unicode-transforms";
+       version = "0.3.4";
+       sha256 = "0lh8bj6kxvpkmc14qa34vdrmcsis82mvnq6gs11ddqyjlz5sr7l2";
+       libraryHaskellDepends = [ base bitarray bytestring text ];
+       testHaskellDepends = [
+         base deepseq getopt-generics QuickCheck split text
+       ];
+       benchmarkHaskellDepends = [
+         base deepseq filepath gauge optparse-applicative path path-io text
+       ];
+       homepage = "http://github.com/harendra-kumar/unicode-transforms";
+       description = "Unicode normalization";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "unicoder" = callPackage
     ({ mkDerivation, attoparsec, base, data-default, directory
      , filepath, text, twitch
···
      }:
      mkDerivation {
        pname = "uniprot-kb";
-       version = "0.1.1.0";
-       sha256 = "1c1z7pp11mrg17c7sa1bdk1z7562jwp0wdx8kvyl5lb4z5nnb4fw";
+       version = "0.1.1.2";
+       sha256 = "15mlmappp5k8lamgmpkmyahi5vimxk3a1821c6cabs28r4d9rywy";
        libraryHaskellDepends = [ attoparsec base text ];
        testHaskellDepends = [
          attoparsec base hspec neat-interpolation QuickCheck text
···
        description = "Monad transformers that mirror worker-wrapper transformations";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "unpacked-containers" = callPackage
+    ({ mkDerivation, base, data-default-class, deepseq, ghc-prim }:
+     mkDerivation {
+       pname = "unpacked-containers";
+       version = "0";
+       sha256 = "17hm6r84kark7akn18lsvb0z6q5hcy4ap89nbkhxfhkchrqc6bfr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base data-default-class deepseq ghc-prim
+       ];
+       executableHaskellDepends = [ base ];
+       doHaddock = false;
+       homepage = "http://github.com/ekmett/unpacked-containers/";
+       description = "Unpacked containers via backpack";
+       license = stdenv.lib.licenses.bsd2;
      }) {};
 
   "unroll-ghc-plugin" = callPackage
···
        pname = "vec";
        version = "0.1";
        sha256 = "0m70ld5vy96vca4wdm45q1ixwznl3yfj8jzil2kjfkzzac5fym5y";
+       revision = "1";
+       editedCabalFile = "0ffzb4jps0grlpbq99vx30cp4g7mad87mwcng3s1w6xqa96xr6xh";
        libraryHaskellDepends = [
          adjunctions base base-compat deepseq distributive fin hashable lens
          semigroupoids
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "vector-text" = callPackage
+    ({ mkDerivation, base, binary, prologue, text, vector
+     , vector-binary-instances
+     }:
+     mkDerivation {
+       pname = "vector-text";
+       version = "1.1.1";
+       sha256 = "0hwis2xqj86j3smk9dnq9rpf8hraxzjczpajbkzma50g2kagj5r8";
+       libraryHaskellDepends = [
+         base binary prologue text vector vector-binary-instances
+       ];
+       homepage = "https://github.com/luna/vector-text";
+       description = "Text implementation based on unboxed char vector";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "vector-th-unbox" = callPackage
     ({ mkDerivation, base, data-default, template-haskell, vector }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "wai-middleware-static_0_8_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, cryptonite
+     , directory, expiring-cache-map, filepath, http-types, memory
+     , mime-types, mtl, old-locale, semigroups, text, time, wai
+     }:
+     mkDerivation {
+       pname = "wai-middleware-static";
+       version = "0.8.2";
+       sha256 = "1z5yapcf8j9w71f2na30snmalsajlyi8an2f9qrjdmajabyykr0b";
+       libraryHaskellDepends = [
+         base bytestring containers cryptonite directory expiring-cache-map
+         filepath http-types memory mime-types mtl old-locale semigroups
+         text time wai
+       ];
+       homepage = "https://github.com/scotty-web/wai-middleware-static";
+       description = "WAI middleware that serves requests to static files";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "wai-middleware-static-caching" = callPackage
     ({ mkDerivation, base, base16-bytestring, bytestring, containers
      , cryptohash, directory, expiring-cache-map, filepath, http-types
···
 
   "warped" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, conduit, http-types
-     , lifted-async, monad-control, preamble, shakers, uuid, wai
-     , wai-conduit, wai-cors, warp
+     , lifted-async, monad-control, preamble, uuid, wai, wai-conduit
+     , wai-cors, warp
      }:
      mkDerivation {
        pname = "warped";
-       version = "0.0.3";
-       sha256 = "11iw5shjclns2d8baj98scm4jc773fxyzbjwbvvs6scan9d31z7m";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.0.4";
+       sha256 = "0gvsqabl1kh0vkzqiijkndk77jdc6md2c2p1f8bilrliqq2p21gq";
        libraryHaskellDepends = [
          aeson base blaze-builder conduit http-types lifted-async
          monad-control preamble uuid wai wai-conduit wai-cors warp
        ];
-       executableHaskellDepends = [ base shakers ];
        homepage = "https://github.com/swift-nav/warped";
        description = "Warp and Wai Library";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "web-inv-route";
-       version = "0.1.1";
-       sha256 = "16iv72jyay844668rnzmk3w98ia5cdijg8hpzy7qdhc29n3p2kzf";
+       version = "0.1.2";
+       sha256 = "1qhs2gi1591bphdr1wxbn2za7kfskywndz4bcr741q825m2bakhd";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers happstack-server
          hashable http-types invertible network-uri snap-core text
          transformers unordered-containers wai
        ];
        testHaskellDepends = [ base bytestring HUnit network-uri text ];
-       description = "Composable, reversible, efficient web routing based on invertible invariants and bijections";
+       description = "Composable, reversible, efficient web routing using invertible invariants and bijections";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
   "wolf" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-swf, base, bytestring
      , conduit, directory, filepath, http-types, lifted-async
-     , lifted-base, optparse-generic, preamble, process, shakers, time
-     , uuid, yaml
+     , lifted-base, optparse-generic, preamble, process, time, uuid
+     , yaml
      }:
      mkDerivation {
        pname = "wolf";
-       version = "0.3.42";
-       sha256 = "078pzdwhdxgqd5lszwszzcwxla17a51ikcvvas6791lvwx1ddg0d";
+       version = "0.3.43";
+       sha256 = "1iy9qbpwnnzq8d7fvpl8iqn8bc3iz44rvxi4ijjj5xd4z1w6i5fv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          filepath http-types lifted-async lifted-base preamble process time
          uuid yaml
        ];
-       executableHaskellDepends = [ base optparse-generic shakers ];
+       executableHaskellDepends = [ base optparse-generic ];
        homepage = "https://github.com/swift-nav/wolf";
        description = "Amazon Simple Workflow Service Wrapper";
        license = stdenv.lib.licenses.mit;
···
 
   "xmobar" = callPackage
     ({ mkDerivation, alsa-core, alsa-mixer, base, bytestring
-     , containers, dbus, directory, filepath, hinotify, HTTP, iwlib
-     , libmpd, libXpm, libXrandr, libXrender, mtl, old-locale, parsec
-     , process, regex-compat, stm, time, timezone-olson, timezone-series
-     , transformers, unix, utf8-string, wirelesstools, X11, X11-xft
+     , containers, dbus, directory, filepath, hinotify, hspec, HTTP
+     , iwlib, libmpd, libXpm, libXrandr, libXrender, mtl, old-locale
+     , parsec, process, regex-compat, stm, time, timezone-olson
+     , timezone-series, transformers, unix, utf8-string, wirelesstools
+     , X11, X11-xft
      }:
      mkDerivation {
        pname = "xmobar";
-       version = "0.25";
-       sha256 = "0382r4vzqkz76jlp2069rdbwf4gh1a22r9w4rkphcn5qflw0dlb6";
+       version = "0.26";
+       sha256 = "19g40vqj3cs94i27f66194k7d5cazrv1lx54bz9kc0qy2npxjzgz";
        configureFlags = [ "-fall_extensions" ];
        isLibrary = false;
        isExecutable = true;
···
        ];
        executableSystemDepends = [
          libXpm libXrandr libXrender wirelesstools
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath hspec mtl old-locale
+         parsec process regex-compat stm time transformers unix X11
        ];
        homepage = "http://xmobar.org";
        description = "A Minimalistic Text Based Status Bar";
···
        pname = "yampa-canvas";
        version = "0.2.2";
        sha256 = "0g1yvb6snnsbvy2f74lrlqff5zgnvfh2f6r8xdwxi61dk71qsz0n";
-       revision = "3";
-       editedCabalFile = "1vh3v5hrd1y1m491g4h9p3c767h7kg3ffgi20vrafrg8i0r7hg3w";
+       revision = "4";
+       editedCabalFile = "1bqjfmssgg0jd6j5x727clk6wawbbh0hq8v0qpj4d5bfv4931pkb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base blank-canvas stm time Yampa ];

pkgs/development/libraries/Xaw3d/default.nix

···
 stdenv.mkDerivation {
   name = "Xaw3d-1.6.2";
   src = fetchurl {
-    urls = [ 
-      ftp://ftp.x.org/pub/xorg/individual/lib/libXaw3d-1.6.2.tar.bz2
-      ];
+    url = https://www.x.org/releases/individual/lib/libXaw3d-1.6.2.tar.bz2;
     sha256 = "0awplv1nf53ywv01yxphga3v6dcniwqnxgnb0cn4khb121l12kxp";
   };
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/libraries/accountsservice/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "accountsservice-${version}";
-  version = "0.6.45";
+  version = "0.6.46";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/accountsservice/accountsservice-${version}.tar.xz";
-    sha256 = "09pg25ir7kjigvp2cxd9fkfw8c8ql8vrswfvymg9zmbmma9w43zv";
+    sha256 = "09ddndbha2wh22a0k5150d2wy0v8k8zj3vmbdijyirqwhf5vjr8q";
   };
 
   nativeBuildInputs = [ pkgconfig makeWrapper ];

pkgs/development/libraries/dlib/default.nix

···
     homepage = http://www.dlib.net;
     license = licenses.boost;
     maintainers = with maintainers; [ christopherpoole ];
-    platforms = platforms.all;
+    platforms = platforms.linux;
   };
 }
 

pkgs/development/libraries/globalplatform/default.nix

···
     homepage = https://sourceforge.net/p/globalplatform/wiki/Home/;
     description = "Library for interacting with smart card devices";
     license = licenses.gpl3;
-    platforms = platforms.all;
+    platforms = platforms.linux;
   };
 }

pkgs/development/libraries/gstreamer/gstreamermm/default.nix

···
     description = "C++ interface for GStreamer";
     homepage = https://gstreamer.freedesktop.org/bindings/cplusplus.html;
     license = licenses.lgpl21Plus;
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     maintainers = with maintainers; [ romildo ];
   };
 

pkgs/development/libraries/herqq/default.nix

···
     sha256 = "1w674rbwbhpirq70gp9rk6p068j36rwn112fx3nz613wgw63x84m";
   };
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://herqq.org;
     description = "A software library for building UPnP devices and control points";
-    inherit (qt5.qtbase.meta) platforms;
+    platforms = platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/development/libraries/leveldb/default.nix

···
     make all leveldbutil libmemenv.a
   '';
 
-  installPhase = "
+  installPhase = (stdenv.lib.optionalString stdenv.isDarwin ''
+    for file in *.dylib*; do
+      install_name_tool -id $out/lib/$file $file
+    done
+  '') + # XXX consider removing above after transition to cmake in the next release
+  "
     mkdir -p $out/{bin,lib,include}
 
     cp -r include $out

pkgs/development/libraries/libesmtp/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "libESMTP-${version}";
+  version = "1.0.6";
+
+  src = fetchurl {
+    url = "http://brianstafford.info/libesmtp/libesmtp-1.0.6.tar.bz2";
+    sha256 = "02zbniyz7qys1jmx3ghx21kxmns1wc3hmv80gp7ag7yra9f1m9nh";
+  };
+
+  meta = with stdenv.lib; {
+    homepage = http://brianstafford.info/libesmtp/index.html;
+    description = "A Library for Posting Electronic Mail";
+    license = licenses.lgpl21;
+  };
+}
+

pkgs/development/libraries/libevent/default.nix

···
-{ stdenv, fetchurl, findutils
+{ stdenv, fetchurl, findutils, fixDarwinDylibNames
 , sslSupport? true, openssl
 }:
 
···
   buildInputs = []
     ++ stdenv.lib.optional sslSupport openssl
     ++ stdenv.lib.optional stdenv.isCygwin findutils
+    ++ stdenv.lib.optional stdenv.isDarwin fixDarwinDylibNames
     ;
 
   postInstall = stdenv.lib.optionalString sslSupport ''

pkgs/development/libraries/openvdb/default.nix

···
     LOG4CPLUS_LIB=
     BLOSC_INCLUDE_DIR=${c-blosc}/include/
     BLOSC_LIB_DIR=${c-blosc}/lib/
-    '';
+  '';
 
   installFlags = ''DESTDIR=$(out)'';
 
···
     description = "An open framework for voxel";
     homepage = "http://www.openvdb.org";
     maintainers = [ maintainers.guibou ];
-    platforms = platforms.all;
+    platforms = platforms.linux;
     license = licenses.mpl20;
   };
 }

pkgs/development/libraries/pugixml/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "pugixml-${version}";
-  version = "1.8.1";
+  version = "1.9";
 
   src = fetchurl {
     url = "https://github.com/zeux/pugixml/releases/download/v${version}/${name}.tar.gz";
-    sha256 = "0fcgggry5x5bn0zhb09ij9hb0p45nb0sv0d9fw3cm1cf62hp9n80";
+    sha256 = "19nv3zhik3djp4blc4vrjwrl8dfhzmal8b21sq7y907nhddx6mni";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/rdkafka/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "rdkafka-${version}";
-  version = "0.11.3";
+  version = "0.11.4";
 
   src = fetchFromGitHub {
     owner = "edenhill";
     repo = "librdkafka";
     rev = "v${version}";
-    sha256 = "17ghq0kzk2fdpxhr40xgg3s0p0n0gkvd0d85c6jsww3mj8v5xd14";
+    sha256 = "11ps8sy4v8yvj4sha7d1q3rmhfw7l1rd52rnl01xam9862yasahs";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/libraries/schroedinger/default.nix

···
     homepage = http://diracvideo.org/;
     maintainers = [ maintainers.spwhitt ];
     license = [ licenses.mpl11 licenses.lgpl2 licenses.mit ];
-    platforms = platforms.unix;
+    platforms = platforms.linux;
   };
 }

pkgs/development/libraries/science/math/caffe2/default.nix

···
       algorithms. You can bring your creations to scale using the power of GPUs in the
       cloud or to the masses on mobile with Caffe2's cross-platform libraries.
     '';
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    platforms = with stdenv.lib.platforms; linux;
     license = stdenv.lib.licenses.asl20;
     maintainers = with stdenv.lib.maintainers; [ yuriaisaka ];
   };

pkgs/development/libraries/science/networking/ns3/default.nix

···
+{ stdenv
+, fetchFromGitHub, fetchurl
+, python
+
+# for binding generation
+, castxml ? null
+
+# can take a long time, generates > 30000 images/graphs
+, enableDoxygen ? false
+
+# e.g. "optimized" or "debug". If not set, use default one
+, build_profile ? null
+
+# --enable-examples
+, withExamples ? false
+
+# very long
+, withManual ? false, doxygen ? null, graphviz ? null, imagemagick ? null
+# for manual, tetex is used to get the eps2pdf binary
+# texlive to get latexmk. building manual still fails though
+, dia, tetex ? null, ghostscript ? null, texlive ? null
+
+# generates python bindings
+, generateBindings ? false, ncurses ? null
+
+# All modules can be enabled by choosing 'all_modules'.
+# we include here the DCE mandatory ones
+, modules ? [ "core" "network" "internet" "point-to-point" "fd-net-device" "netanim"]
+, gcc6
+, lib
+}:
+
+let
+  pythonEnv = python.withPackages(ps:
+    stdenv.lib.optional withManual ps.sphinx
+    ++ stdenv.lib.optionals generateBindings (with ps;[ pybindgen pygccxml ])
+  );
+in
+stdenv.mkDerivation rec {
+
+  name = "ns-3.${version}";
+  version = "28";
+
+  # the all in one https://www.nsnam.org/release/ns-allinone-3.27.tar.bz2;
+  # fetches everything (netanim, etc), this package focuses on ns3-core
+  src = fetchFromGitHub {
+    owner  = "nsnam";
+    repo   = "ns-3-dev-git";
+    rev    = name;
+    sha256 = "17kzfjpgw2mvyx1c9bxccnvw67jpk09fxmcnlkqx9xisk10qnhng";
+  };
+
+  # ncurses is a hidden dependency of waf when checking python
+  buildInputs = lib.optionals generateBindings [ castxml ncurses ]
+    ++ stdenv.lib.optional enableDoxygen [ doxygen graphviz imagemagick ]
+    ++ stdenv.lib.optional withManual [ dia tetex ghostscript texlive.combined.scheme-medium ];
+
+  propagatedBuildInputs = [ gcc6 pythonEnv ];
+
+  postPatch = ''
+    patchShebangs ./waf
+    patchShebangs doc/ns3_html_theme/get_version.sh
+  '';
+
+  configureScript = "${python.interpreter} ./waf configure";
+
+  configureFlags = with stdenv.lib; [
+      "--enable-modules=${stdenv.lib.concatStringsSep "," modules}"
+      "--with-python=${pythonEnv.interpreter}"
+  ]
+  ++ optional (build_profile != null) "--build-profile=${build_profile}"
+  ++ optional generateBindings [  ]
+  ++ optional withExamples " --enable-examples "
+  ++ optional doCheck " --enable-tests "
+  ;
+
+  postBuild = with stdenv.lib; let flags = concatStringsSep ";" (
+      optional enableDoxygen "./waf doxygen"
+      ++ optional withManual "./waf sphinx"
+    );
+    in "${flags}"
+  ;
+
+  doCheck = true;
+
+  # we need to specify the proper interpreter else ns3 can check against a
+  # different version even though we
+  checkPhase =  ''
+    ${pythonEnv.interpreter} ./test.py
+  '';
+
+  meta = {
+    homepage = http://www.nsnam.org;
+    license = stdenv.lib.licenses.gpl3;
+    description = "A discrete time event network simulator";
+    platforms = with stdenv.lib.platforms; unix;
+  };
+}

pkgs/development/libraries/wlroots/default.nix

···
     license     = licenses.mit;
     platforms   = platforms.linux;
     maintainers = with maintainers; [ primeos ];
+    # Marked as broken until the first official/stable release (upstream
+    # request). See #38344 for the public discussion.
+    broken = true;
   };
 }

pkgs/development/libraries/zlog/default.nix

···
     homepage = http://hardysimpson.github.com/zlog;
     license = licenses.lgpl21;
     platforms = platforms.linux; # cannot test on something else
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
   };
 
 }

pkgs/development/misc/loc/default.nix

···
     homepage = https://github.com/cgag/loc;
     description = "Count lines of code quickly";
     license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = with stdenv.lib.platforms; linux;
   };
 }

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

···
+{ lib, buildPythonPackage, fetchPypi, xlib }:
+
+buildPythonPackage rec {
+  pname = "ewmh";
+  version = "0.1.6";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0g9l14my3v8zlgq1yd8wh5gpara0qcapsfmvg7lq2lapglzhjsy5";
+  };
+
+  propagatedBuildInputs = [ xlib ];
+
+  # No tests included
+  doCheck = false;
+
+  meta = {
+    homepage = https://github.com/parkouss/pyewmh;
+    description = "An implementation of EWMH (Extended Window Manager Hints), based on Xlib";
+    license = lib.licenses.lgpl3Plus;
+    maintainers = with lib.maintainers; [ bandresen ];
+  };
+}

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

···
     description = "Python interface to Graphviz graph drawing package";
     homepage = https://github.com/pygraphviz/pygraphviz;
     license = licenses.bsd3;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/development/python-modules/requests-toolbelt/default.nix

···
   meta = {
     description = "A toolbelt of useful classes and functions to be used with python-requests";
     homepage = http://toolbelt.rtfd.org;
-    maintainers = with lib.maintainers; [ matthiasbeyer jgeerds ];
+    maintainers = with lib.maintainers; [ jgeerds ];
   };
-}
+}

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

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "8.8";
+  version = "8.9";
   name = "checkstyle-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/checkstyle/${name}-bin.tar.gz";
-    sha256 = "0yawd6mbz6cqj0qlrh01vy33p30f4s3pfrvsxwg5l11p416zzrz4";
+    sha256 = "058lffmlzw7nqz5z89m2k640q7ffz6dz008bddvjsgpxbrdb89cd";
   };
 
   installPhase = ''

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

···
-{ stdenv, lib, requireFile, makeWrapper, yacc, gcc
+{ stdenv, lib, fetchurl, makeWrapper, yacc, gcc
 , withISpin ? true, tk, swarm, graphviz }:
 
 let
···
   version = "6.4.8";
   url-version = stdenv.lib.replaceChars ["."] [""] version;
 
-  src = requireFile {
-    name = "spin${url-version}.tar.gz";
-    sha256 = "1rpazi5fj772121cn7r85fxypmaiv0x6x2l82b5y1xqzyf0fi4ph";
-    message = ''
-      reCAPTCHA is preventing us to download the file for you.
-      Please download it at http://spinroot.com/spin/Src/index.html
-      and add it to the nix-store using nix-prefetch-url.
-    '';
+  src = fetchurl {
+    # The homepage is behind CloudFlare anti-DDoS protection, which blocks cURL.
+    # Dropbox mirror from developers:
+    # https://www.dropbox.com/sh/fgzipzp4wpo3qc1/AADZPqS4aoR-pjNF6OQXRLQHa
+    url = "https://www.dropbox.com/sh/fgzipzp4wpo3qc1/AADya1lOBJZDbgWGrUSq-dfHa/spin${url-version}.tar.gz?raw=1";
+    sha256 = "1rvamdsf0igzpndlr4ck7004jw9x1bg4xyf78zh5k9sp848vnd80";
   };
 
   nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ yacc ];
 
   sourceRoot = "Spin/Src${version}";
-
-  unpackPhase = ''
-    # The archive is compressed twice
-    gunzip -c $src > spin.tar.gz
-    tar -xzf spin.tar.gz
-  '';
 
   installPhase = ''
     install -Dm755 spin $out/bin/spin

pkgs/development/tools/database/sqlitebrowser/default.nix

···
     description = "DB Browser for SQLite";
     homepage = http://sqlitebrowser.org/;
     license = licenses.gpl3;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux; # can only test on linux
   };
 }

pkgs/development/tools/godot/default.nix

···
   installPhase = ''
     mkdir -p $out/bin
     cp bin/godot.x11.tools.* $out/bin/godot
+
+    mkdir -p "$out/share/applications"
+    cp misc/dist/linux/godot.desktop "$out/share/applications/"
+    substituteInPlace "$out/share/applications/godot.desktop" \
+                      --replace "Exec=godot" \
+                      "Exec=$out/bin/godot"
+
+    mkdir -p "$out/share/icons/hicolor/scalable/apps/"
+    cp icon.svg "$out/share/icons/hicolor/scalable/apps/godot.svg"
+    cp icon.png "$out/share/icons/godot.png"
+
+    mkdir -p "$out/share/man/man6"
+    cp misc/dist/linux/godot.6 "$out/share/man/man6/"
   '';
 
   meta = {

pkgs/development/tools/misc/pwndbg/default.nix

···
+{ stdenv, fetchFromGitHub, pythonPackages, makeWrapper, gdb }:
+
+stdenv.mkDerivation rec {
+  name = "pwndbg-2018-04-06";
+
+  src = fetchFromGitHub {
+    owner = "pwndbg";
+    repo = "pwndbg";
+    rev = "e225ba9f647ab8f7f4871075529c0ec239f43300";
+    sha256 = "1s6m93qi3baclgqqii4fnmzjmg0c6ipkscg7xiljaj5z4bs371j4";
+  };
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  propagatedBuildInputs = with pythonPackages; [
+    future
+    isort
+    psutil
+    pycparser
+    pyelftools
+    python-ptrace
+    ROPGadget
+    six
+    unicorn
+    pygments
+    enum34
+  ];
+
+  installPhase = ''
+    mkdir -p $out/share/pwndbg
+    cp -r *.py pwndbg $out/share/pwndbg
+    makeWrapper ${gdb}/bin/gdb $out/bin/pwndbg \
+      --add-flags "-q -x $out/share/pwndbg/gdbinit.py"
+  '';
+
+  preFixup = ''
+    sed -i "/import sys/a import sys; sys.path[0:0] = '$PYTHONPATH'.split(':')" \
+      $out/share/pwndbg/gdbinit.py
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Exploit Development and Reverse Engineering with GDB Made Easy";
+    homepage = http://pwndbg.com;
+    license = licenses.mit;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ mic92 ];
+  };
+}

pkgs/development/tools/misc/sysbench/default.nix

···
 , libaio }:
 
 stdenv.mkDerivation rec {
-  name = "sysbench-1.0.13";
+  name = "sysbench-1.0.14";
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
   buildInputs = [ vim mysql.connector-c libaio ];
···
   src = fetchFromGitHub {
     owner = "akopytov";
     repo = "sysbench";
-    rev = "1.0.13";
-    sha256 = "1inxyjpcyv2ag3k5riwlaq91362y16yks75vs2crmhjxlxdspy8c";
+    rev = "1.0.14";
+    sha256 = "0mp1wqdm87zqyn55z23qf1izqz7ijgcbsysdwqndd98w6m5d86rp";
   };
 
   meta = {

pkgs/development/tools/ocaml/js_of_ocaml/ppx_deriving_json.nix

···
+{ stdenv, ocaml, findlib, jbuilder, js_of_ocaml-compiler
+, js_of_ocaml, ppx_deriving
+}:
+
+stdenv.mkDerivation rec {
+	name = "js_of_ocaml-ppx_deriving_json-${version}";
+
+	inherit (js_of_ocaml-compiler) version src installPhase meta;
+
+	buildInputs = [ ocaml findlib jbuilder ];
+
+	propagatedBuildInputs = [ js_of_ocaml ppx_deriving ];
+
+	buildPhase = "jbuilder build -p js_of_ocaml-ppx_deriving_json";
+}

pkgs/misc/screensavers/pipes/default.nix

···
     homepage = https://github.com/pipeseroni/pipes.sh;
     description = "Animated pipes terminal screensaver";
     license = licenses.mit;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
     platforms = platforms.unix;
   };
 }

pkgs/misc/themes/adapta/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "adapta-gtk-theme-${version}";
-  version = "3.93.0.174";
+  version = "3.93.0.225";
 
   src = fetchFromGitHub {
     owner = "adapta-project";
     repo = "adapta-gtk-theme";
     rev = version;
-    sha256 = "0fkvcpx2vhyr3z74r5mcpjh293w3cfm07axj8dj84nl2hi6im8b6";
+    sha256 = "1mjdvfvx45pdypl34yghgi47bj86rwvryx9mwhwwb09psn9smp49";
   };
 
   preferLocalBuild = true;

pkgs/os-specific/linux/kernel/manual-config.nix

···
   extraMeta ? {},
   # Whether to utilize the controversial import-from-derivation feature to parse the config
   allowImportFromDerivation ? false,
+  # ignored
+  features ? null,
 
   hostPlatform
 }:

pkgs/os-specific/linux/zfs/default.nix

···
         versionAtLeast kernel.version incompatibleKernelVersion then
        throw ''
          Linux v${kernel.version} is not yet supported by zfsonlinux v${version}.
-         ${stdenv.lib.optional (!isUnstable) "Try zfsUnstable or set the NixOS option boot.zfs.enableUnstable."}
+         ${stdenv.lib.optionalString (!isUnstable) "Try zfsUnstable or set the NixOS option boot.zfs.enableUnstable."}
        ''
     else stdenv.mkDerivation rec {
       name = "zfs-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
···
 
   zfsUnstable = common rec {
     # comment/uncomment if breaking kernel versions are known
-    incompatibleKernelVersion = null;
+    incompatibleKernelVersion = "4.16";
 
     # this package should point to a version / git revision compatible with the latest kernel release
     version = "2018-04-04";

pkgs/servers/ftp/pure-ftpd/default.nix

···
     homepage = https://www.pureftpd.org;
     license = licenses.isc; # with some parts covered by BSD3(?)
     maintainers = [ maintainers.lethalman ];
-    platforms = platforms.unix;
+    platforms = platforms.linux;
   };
 }

pkgs/servers/mail/opensmtpd/extras.nix

···
     homepage = https://www.opensmtpd.org/;
     description = "Extra plugins for the OpenSMTPD mail server";
     license = licenses.isc;
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     maintainers = with maintainers; [ gebner ];
   };
 }

pkgs/servers/misc/taskserver/default.nix

···
     homepage = http://taskwarrior.org;
     license = stdenv.lib.licenses.mit;
     platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer makefu ];
+    maintainers = with stdenv.lib.maintainers; [ makefu ];
   };
 }

pkgs/servers/web-apps/klaus/default.nix

···
     description = "The first Git web viewer that Just Works";
     homepage    = https://github.com/jonashaag/klaus;
     license     = licenses.isc;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/tools/backup/mtx/default.nix

···
     homepage = https://sourceforge.net/projects/mtx/;
     license = stdenv.lib.licenses.gpl2;
     maintainers = [ stdenv.lib.maintainers.redvers ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/tools/filesystems/archivemount/default.nix

···
 { stdenv, fetchurl, pkgconfig, fuse, libarchive }:
 
 let
-  name = "archivemount-0.8.9";
+  name = "archivemount-0.8.12";
 in
 stdenv.mkDerivation {
   inherit name;
 
   src = fetchurl {
     url = "http://www.cybernoia.de/software/archivemount/${name}.tar.gz";
-    sha256 = "0v4si1ri6lhnq9q87gkx7fsh6lv6xz4bynknwndqncpvfp5cy1jg";
+    sha256 = "12fb8fcmd1zwvfgzx4pay47md5cr2kgxcgq82cm6skmq75alfzi4";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/tools/graphics/asymptote/default.nix

···
   s = # Generated upstream information
   rec {
     baseName="asymptote";
-    version="2.41";
+    version="2.42";
     name="${baseName}-${version}";
-    hash="1w7fbq6gy65g0mxg6wdxi7v178c5yxvh9yrnv3bzm4sjzf4pwvhx";
-    url="https://freefr.dl.sourceforge.net/project/asymptote/2.41/asymptote-2.41.src.tgz";
-    sha256="1w7fbq6gy65g0mxg6wdxi7v178c5yxvh9yrnv3bzm4sjzf4pwvhx";
+    hash="0dprc4shzdpvp87kc97ggh5ay2zmskjjaciay7mnblx63rhk1d95";
+    url="https://freefr.dl.sourceforge.net/project/asymptote/2.42/asymptote-2.42.src.tgz";
+    sha256="0dprc4shzdpvp87kc97ggh5ay2zmskjjaciay7mnblx63rhk1d95";
   };
   buildInputs = [
    ghostscriptX imagemagick fftw

pkgs/tools/graphics/pywal/default.nix

···
+{ lib, python3Packages, fetchFromGitHub, imagemagick, feh }:
+
+python3Packages.buildPythonApplication rec {
+  pname = "pywal";
+  version = "2.0.5";
+
+  src = python3Packages.fetchPypi {
+    inherit pname version;
+    sha256 = "117f61db013409ee2657aab9230cc5c2cb2b428c17f7fbcf664909122962165e";
+  };
+
+  # necessary for imagemagick to be found during tests
+  buildInputs = [ imagemagick ];
+
+  makeWrapperArgs = [ "--prefix PATH : ${lib.makeBinPath [ imagemagick feh ]}" ];
+
+  preCheck = ''
+    mkdir tmp
+    HOME=$PWD/tmp
+  '';
+
+  meta = with lib; {
+    description = "Generate and change colorschemes on the fly. A 'wal' rewrite in Python 3.";
+    homepage = https://github.com/dylanaraps/pywal;
+    license = licenses.mit;
+    maintainers = with maintainers; [ Fresheyeball ];
+  };
+}

pkgs/tools/misc/autorandr/default.nix

···
 
 let
   python = python3Packages.python;
-  version = "1.4";
+  version = "1.5";
 in
   stdenv.mkDerivation {
     name = "autorandr-${version}";
···
       owner = "phillipberndt";
       repo = "autorandr";
       rev = "${version}";
-      sha256 = "08i71r221ilc8k1c59w89g3iq5m7zwhnjjzapavhqxlr8y9dcpf5";
+      sha256 = "01pij2r73f190qk7q3cgf5cmk0w59g9l9v4vah5vf4ddn7nnk7yq";
     };
 
     meta = {

pkgs/tools/misc/lf/default.nix

···
 
 buildGoPackage rec {
   name = "lf-${version}";
-  version = "1";
+  version = "2";
 
   src = fetchFromGitHub {
     owner = "gokcehan";
     repo = "lf";
     rev = "r${version}";
-    sha256 = "0mq83m7mvavd0dzhk8g6ffldy57i22n0846yzqnlz733chiy3anz";
+    sha256 = "0g9fy6x3wc5hda886ci79wj7rnjwvaidbwhsrckqgiqymbzvrdb8";
   };
 
   goPackagePath = "github.com/gokcehan/lf";
···
     runHook preBuild
     runHook renameImports
     cd go/src/${goPackagePath}
-    go install -ldflags="-s -w -X main.gVersion=${version}"
+    go install -ldflags="-s -w -X main.gVersion=r${version}"
     runHook postBuild
   '';
 

pkgs/tools/misc/mpdscribble/default.nix

···
     description = "A Music Player Daemon (MPD) client which submits information about tracks beeing played to a scrobbler (e.g. last.fm)";
     homepage = http://mpd.wikia.com/wiki/Client:mpdscribble;
     license = licenses.gpl2;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
     platforms = platforms.linux;
   };
 }

pkgs/tools/misc/multitail/default.nix

···
   meta = {
     homepage = http://www.vanheusden.com/multitail/;
     description = "tail on Steroids";
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with stdenv.lib.maintainers; [ ];
     platforms = stdenv.lib.platforms.unix;
   };
 }

pkgs/tools/misc/neofetch/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "neofetch-${version}";
-  version = "3.3.0";
+  version = "3.4.0";
   src = fetchFromGitHub {
     owner = "dylanaraps";
     repo = "neofetch";
     rev = version;
-    sha256 = "1f1hvd635wv81qg802jdi0yggi4631w9nlznipaxkvk4y1zpdq5j";
+    sha256 = "10h4f7n6bllbq459nm9wppvk65n81zzv556njfqplzw3mpdrbiyx";
   };
 
   dontBuild = true;

pkgs/tools/misc/pspg/default.nix

···
+{ stdenv, fetchFromGitHub, gnugrep, ncurses, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "pspg-${version}";
+  version = "1.0.0";
+
+  src = fetchFromGitHub {
+    owner = "okbob";
+    repo = "pspg";
+    rev = "${version}";
+    sha256 = "1swrg4bg7i4xpdrsg8dsfldbxaffni04x8i1s0g6h691qcin675v";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ gnugrep ncurses ];
+
+  preBuild = ''
+    makeFlags="PREFIX=$out PKG_CONFIG=${pkgconfig}/bin/pkg-config"
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/okbob/pspg;
+    description = "Postgres Pager";
+    license = licenses.bsd2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.jlesquembre ];
+  };
+}

pkgs/tools/misc/smenu/default.nix

···
       your selection will be sent to standard output.
     '';
     license     = licenses.gpl2;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
     platforms   = platforms.linux;
   };
 }

pkgs/tools/misc/vdirsyncer/default.nix

···
   meta = with stdenv.lib; {
     homepage = https://github.com/pimutils/vdirsyncer;
     description = "Synchronize calendars and contacts";
-    maintainers = with maintainers; [ matthiasbeyer jgeerds ];
+    maintainers = with maintainers; [ jgeerds ];
     platforms = platforms.all;
     license = licenses.mit;
   };

pkgs/tools/misc/vimer/default.nix

···
       in an existing instance of GVim or MacVim.
     '';
     license = licenses.mit;
-    maintainers = [ maintainers.matthiasbeyer ];
+    maintainers = [ ];
     platforms = platforms.linux;
   };
 

pkgs/tools/misc/yad/default.nix

···
 , wrapGAppsHook }:
 
 stdenv.mkDerivation rec {
-  name = "yad-0.37.0";
+  name = "yad-0.40.0";
 
   src = fetchurl {
     url = "http://sourceforge.net/projects/yad-dialog/files/${name}.tar.xz";
-    sha256 = "0fhqsgml1axaa9avd0hbam5wm77c2c7q1bz4hs7fvyvdnljazvwi";
+    sha256 = "1x0fsv8nfkm8lchdawnf3zw79jaqbnvhv87sk5r8g86knv8vgl62";
   };
 
   configureFlags = [

pkgs/tools/networking/axel/default.nix

···
     description = "Console downloading program with some features for parallel connections for faster downloading";
     homepage = http://axel.alioth.debian.org/;
     maintainers = with maintainers; [ pSub ];
-    platforms = with platforms; linux ++ darwin;
+    platforms = with platforms; linux;
   };
 }

pkgs/tools/networking/ccnet/default.nix

···
 {stdenv, fetchurl, which, autoreconfHook, pkgconfig, vala, python, libsearpc, libzdb, libuuid, libevent, sqlite, openssl}:
 
 stdenv.mkDerivation rec {
-  version = "6.1.0";
-  seafileVersion = "6.1.0";
+  version = "6.1.7";
+  seafileVersion = "6.1.7";
   name = "ccnet-${version}";
 
   src = fetchurl {
     url = "https://github.com/haiwen/ccnet/archive/v${version}.tar.gz";
-    sha256 = "0q4a102xlcsxlr53h4jr4w8qzkbzvm2f3nk9fsha48h6l2hw34bb";
+    sha256 = "1kkzdxa9r7sw1niwniznfkvilgvb7q039wq07cfk73qs3231bj7r";
   };
 
   nativeBuildInputs = [ pkgconfig which autoreconfHook vala python ];

pkgs/tools/networking/getmail/default.nix

···
 { stdenv, fetchurl, python2Packages }:
 
 python2Packages.buildPythonApplication rec {
-  version = "5.5";
+  version = "5.6";
   name = "getmail-${version}";
   namePrefix = "";
 
   src = fetchurl {
     url = "http://pyropus.ca/software/getmail/old-versions/${name}.tar.gz";
-    sha256 = "0l43lbnrnyyrq8mlnw37saq6v0mh3nkirdq1dwnsrihykzjjwf70";
+    sha256 = "16nmvj80szr6yvcxxgmxn2lxqpjqqj4xg5a0b66zhvck6j42q3a6";
   };
 
   doCheck = false;

pkgs/tools/networking/htpdate/default.nix

···
   meta = with stdenv.lib; {
     description = "Utility to fetch time and set the system clock over HTTP";
     homepage = http://www.vervest.org/htp/;
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     license = licenses.gpl2Plus;
   };
 }

pkgs/tools/networking/http-prompt/default.nix

···
     description = "An interactive command-line HTTP client featuring autocomplete and syntax highlighting";
     homepage = https://github.com/eliangcs/http-prompt;
     license = licenses.mit;
-    maintainers = with maintainers; [ matthiasbeyer ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux; # can only test on linux
   };
 }

pkgs/tools/system/ipmitool/default.nix

···
     description = ''Command-line interface to IPMI-enabled devices'';
     license = licenses.bsd3;
     homepage = https://sourceforge.net/projects/ipmitool/;
-    platforms = platforms.unix;
+    platforms = platforms.linux;
     maintainers = with maintainers; [ fpletz ];
   };
 }

pkgs/tools/system/localtime/default.nix

···
-{ stdenv, go, systemd, polkit, fetchFromGitHub, m4 }:
+{ stdenv, go, systemd, polkit, fetchFromGitHub, m4, removeReferencesTo }:
 
 stdenv.mkDerivation {
   name = "localtime-2017-11-07";
···
     sha256 = "04fyna8p7q7skzx9fzmncd6gx7x5pwa9jh8a84hpljlvj0kldfs8";
   };
   
-  buildInputs = [ go systemd polkit m4 ];
+  buildInputs = [ go systemd polkit m4 removeReferencesTo ];
+  disallowedRequisites = [ go ];
 
   makeFlags = [ "PREFIX=$(out)" ];
+
+  preFixup = ''
+    find $out/bin -type f -exec remove-references-to -t ${go} '{}' +
+  '';
 
   meta = {
     description = "A daemon for keeping the system timezone up-to-date based on the current location";

pkgs/tools/system/s6-rc/default.nix

···
   meta = {
     homepage = http://skarnet.org/software/s6-rc/;
     description = "A service manager for s6-based systems";
-    platforms = stdenv.lib.platforms.all;
+    platforms = stdenv.lib.platforms.linux;
     license = stdenv.lib.licenses.isc;
     maintainers = with stdenv.lib.maintainers; [ pmahoney ];
   };

pkgs/tools/system/sg3_utils/default.nix

···
   meta = {
     homepage = http://sg.danny.cz/sg/;
     description = "Utilities that send SCSI commands to devices";
-    platforms = stdenv.lib.platforms.all;
+    platforms = stdenv.lib.platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/tools/system/syslog-ng/default.nix

···
 { stdenv, fetchurl, openssl, libcap, curl, which
 , eventlog, pkgconfig, glib, python, systemd, perl
 , riemann_c_client, protobufc, pcre, libnet
-, json_c, libuuid, libivykis, mongoc, rabbitmq-c }:
+, json_c, libuuid, libivykis, mongoc, rabbitmq-c
+, libesmtp
+}:
 
 let
   pname = "syslog-ng";
···
     libivykis
     mongoc
     rabbitmq-c
+    libesmtp
   ];
 
   configureFlags = [
     "--enable-manpages"
     "--enable-dynamic-linking"
     "--enable-systemd"
+    "--enable-smtp"
     "--with-ivykis=system"
     "--with-librabbitmq-client=system"
     "--with-mongoc=system"

pkgs/top-level/all-packages.nix

···
 
   pssh = callPackage ../tools/networking/pssh { };
 
+  pspg = callPackage ../tools/misc/pspg { };
+
   pstoedit = callPackage ../tools/graphics/pstoedit { };
 
   psutils = callPackage ../tools/typesetting/psutils { };
···
 
   pwnat = callPackage ../tools/networking/pwnat { };
 
+  pwndbg = callPackage ../development/tools/misc/pwndbg { };
+
   pycangjie = pythonPackages.pycangjie;
 
   pydb = callPackage ../development/tools/pydb { };
···
   pythonSexy = pythonPackages.libsexy;
 
   pytrainer = callPackage ../applications/misc/pytrainer { };
+
+  pywal = callPackage ../tools/graphics/pywal {};
 
   remarshal = callPackage ../development/tools/remarshal { };
 
···
   epoxy = callPackage ../development/libraries/epoxy {};
 
   esdl = callPackage ../development/libraries/esdl { };
+
+  libesmtp = callPackage ../development/libraries/libesmtp { };
 
   exiv2 = callPackage ../development/libraries/exiv2 { };
 
···
   # Intentionally lacks recurseIntoAttrs, as -rc kernels will quite likely break out-of-tree modules and cause failed Hydra builds.
   linuxPackages_testing = linuxPackagesFor pkgs.linux_testing;
 
-  linuxPackages_custom = { version, src, configfile }:
+  linuxPackages_custom = { version, src, configfile, allowImportFromDerivation ? true }:
     recurseIntoAttrs (linuxPackagesFor (pkgs.linuxManualConfig {
-      inherit version src configfile stdenv;
-      allowImportFromDerivation = true;
+      inherit version src configfile stdenv allowImportFromDerivation;
+      inherit (stdenv) hostPlatform;
     }));
+
+  # This serves as a test for linuxPackages_custom
+  linuxPackages_custom_tinyconfig_kernel = let
+    base = pkgs.linuxPackages.kernel;
+    tinyLinuxPackages = pkgs.linuxPackages_custom {
+      inherit (base) version src;
+      allowImportFromDerivation = false;
+      configfile = pkgs.linuxConfig {
+        makeTarget = "tinyconfig";
+        src = base.src;
+      };
+    };
+    in tinyLinuxPackages.kernel;
 
   # Build a kernel with bcachefs module
   linuxPackages_testing_bcachefs = recurseIntoAttrs (linuxPackagesFor pkgs.linux_testing_bcachefs);
···
 
   # A function to build a manually-configured kernel
   linuxManualConfig = makeOverridable (callPackage ../os-specific/linux/kernel/manual-config.nix {});
+
+  # Derive one of the default .config files
+  linuxConfig = { src, makeTarget ? "defconfig", name ? "kernel.config" }:
+    stdenv.mkDerivation {
+      inherit name src;
+      buildPhase = ''
+        set -x
+        make ${makeTarget}
+      '';
+      installPhase = ''
+        cp .config $out
+      '';
+    };
+
   buildLinux = attrs: callPackage ../os-specific/linux/kernel/generic.nix attrs;
 
   keyutils = callPackage ../os-specific/linux/keyutils { };
···
 
   nedit = callPackage ../applications/editors/nedit { };
 
+  nheko = callPackage ../applications/networking/instant-messengers/nheko { };
+
   nomacs = libsForQt5.callPackage ../applications/graphics/nomacs { };
 
   notepadqq = libsForQt5.callPackage ../applications/editors/notepadqq { };
···
     inherit sbcl lispPackages;
   };
 
-  sublime = callPackage ../applications/editors/sublime { };
+  sublime3Packages = recurseIntoAttrs (callPackage ../applications/editors/sublime/3/packages.nix { });
+
+  sublime3 = sublime3Packages.sublime3;
 
-  sublime3 = lowPrio (callPackage ../applications/editors/sublime3 { });
+  sublime3-dev = sublime3Packages.sublime3-dev;
 
   inherit (callPackages ../applications/version-management/subversion/default.nix {
       bdbSupport = true;
···
   terminator = callPackage ../applications/misc/terminator {
     vte = gnome2.vte.override { pythonSupport = true; };
   };
+
+  terminus = callPackage ../applications/misc/terminus { inherit (gnome2) GConf; };
 
   lxterminal = callPackage ../applications/misc/lxterminal {
     vte = gnome3.vte;
···
 
   aspino = callPackage ../applications/science/logic/aspino {};
 
+  beluga = callPackage ../applications/science/logic/beluga { };
+
   boogie = dotnetPackages.Boogie;
 
   inherit (callPackage ./coq-packages.nix {})
···
     gmp-static = gmp.override { withStatic = true; };
   };
 
-  z3_4_5_0 = callPackage ../applications/science/logic/z3/4.5.0.nix {};
   z3 = callPackage ../applications/science/logic/z3 { python = python2; };
 
   tlaplus = callPackage ../applications/science/logic/tlaplus {};
···
   golly-beta = callPackage ../applications/science/misc/golly/beta.nix { wxGTK = wxGTK30; };
 
   megam = callPackage ../applications/science/misc/megam { };
+
+  ns-3 = callPackage ../development/libraries/science/networking/ns3 { };
 
   root = callPackage ../applications/science/misc/root {
     inherit (darwin.apple_sdk.frameworks) Cocoa OpenGL;
···
   terraform-full = terraform_0_11-full;
 
   terraform-inventory = callPackage ../applications/networking/cluster/terraform-inventory {};
+
+  terraform-provider-nixos = callPackage ../applications/networking/cluster/terraform-provider-nixos {};
 
   terraform-landscape = callPackage ../applications/networking/cluster/terraform-landscape {};
 

pkgs/top-level/ocaml-packages.nix

···
 
     js_of_ocaml-ppx = callPackage ../development/tools/ocaml/js_of_ocaml/ppx.nix {};
 
+    js_of_ocaml-ppx_deriving_json = callPackage ../development/tools/ocaml/js_of_ocaml/ppx_deriving_json.nix {};
+
     jsonm = callPackage ../development/ocaml-modules/jsonm { };
 
     lablgl = callPackage ../development/ocaml-modules/lablgl { };

pkgs/top-level/perl-packages.nix

···
     };
   };
 
+  FilePid = buildPerlPackage rec {
+    name = "File-Pid-1.01";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/C/CW/CWEST/${name}.tar.gz";
+      sha256 = "bafeee8fdc96eb06306a0c58bbdb7209b6de45f850e75fdc6b16db576e05e422";
+    };
+    propagatedBuildInputs = [ ClassAccessor ];
+    meta = {
+      license = stdenv.lib.licenses.free; # Same as Perl
+      description = "Pid File Manipulation";
+      maintainers = [ maintainers.limeytexan ];
+    };
+  };
+
   Filepushd = buildPerlPackage {
     name = "File-pushd-1.014";
     src = fetchurl {
···
     buildInputs = [ TestSharedFork ];
   };
 
-  FileTemp = null;
-
-  FileType = buildPerlModule {
-    name = "File-Type-0.22";
-    src = fetchurl {
-      url = mirror://cpan/authors/id/P/PM/PMISON/File-Type-0.22.tar.gz;
-      sha256 = "0hfkaafp6wb0nw19x47wc6wc9mwlw8s2rxiii3ylvzapxxgxjp6k";
-    };
-    meta = {
-      description = "File::Type uses magic numbers (typically at the start of a file) to determine the MIME type of that file.";
-      license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
-      platforms = with stdenv.lib.platforms; linux ++ darwin;
-    };
-  };
-
   FileSlurp = buildPerlPackage {
     name = "File-Slurp-9999.19";
     # WARNING: check on next update if deprecation warning is gone
···
     };
   };
 
-  FileUtil = buildPerlModule rec {
+  FileTail = buildPerlPackage rec {
+    name = "File-Tail-1.3";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/M/MG/MGRABNAR/${name}.tar.gz";
+      sha256 = "1ixg6kn4h330xfw3xgvqcbzfc3v2wlzjim9803jflhvfhf0rzl16";
+    };
+    meta = {
+      description = "Perl extension for reading from continously updated files";
+      license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
+      maintainers = [ maintainers.limeytexan ];
+    };
+  };
+
+  FileTemp = null;
+
+  FileTouch = buildPerlPackage rec {
+    name = "File-Touch-0.11";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/N/NE/NEILB/${name}.tar.gz";
+      sha256 = "e379a5ff89420cf39906e5ceff309b8ce958f99f9c3e57ad52b5002a3982d93c";
+    };
+    meta = {
+      homepage = https://github.com/neilb/File-Touch;
+      description = "Update file access and modification times, optionally creating files if needed";
+      license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
+      maintainers = [ maintainers.limeytexan ];
+    };
+  };
+
+  FileType = buildPerlModule {
+    name = "File-Type-0.22";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PM/PMISON/File-Type-0.22.tar.gz;
+      sha256 = "0hfkaafp6wb0nw19x47wc6wc9mwlw8s2rxiii3ylvzapxxgxjp6k";
+    };
+    meta = {
+      description = "File::Type uses magic numbers (typically at the start of a file) to determine the MIME type of that file.";
+      license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
+      platforms = with stdenv.lib.platforms; linux ++ darwin;
+    };
+  };
+
+  FileUtil = buildPerlPackage rec {
     name = "File-Util-4.161950";
     src = fetchurl {
       url = "mirror://cpan/authors/id/T/TO/TOMMY/${name}.tar.gz";

pkgs/top-level/python-packages.nix

···
 
   email_validator = callPackage ../development/python-modules/email-validator { };
 
+  ewmh = callPackage ../development/python-modules/ewmh { };
+
   dbus-python = callPackage ../development/python-modules/dbus {
     dbus = pkgs.dbus;
   };
···
       description = "Python humanize utilities";
       homepage = https://github.com/jmoiron/humanize;
       license = licenses.mit;
-      maintainers = with maintainers; [ matthiasbeyer ];
+      maintainers = with maintainers; [ ];
       platforms = platforms.linux; # can only test on linux
     };
 
···
       description = "WSGI HTTP Digest Authentication middleware";
       homepage = https://github.com/jonashaag/httpauth;
       license = licenses.bsd2;
-      maintainers = with maintainers; [ matthiasbeyer ];
+      maintainers = with maintainers; [ ];
     };
   };
 
···
       homepage = https://github.com/uri-templates/uritemplate-py;
       description = "Python implementation of URI Template";
       license = licenses.asl20;
-      maintainers = with maintainers; [ matthiasbeyer ];
+      maintainers = with maintainers; [ ];
     };
   };