Merge remote-tracking branch 'upstream/master' into staging

nixos/modules/services/cluster/kubernetes/dashboard.nix

···
                 resources = {
                   limits = {
                     cpu = "100m";
-                    memory = "50Mi";
+                    memory = "250Mi";
                   };
                   requests = {
                     cpu = "100m";

nixos/modules/services/misc/home-assistant.nix

···
         you might need to specify it in <literal>extraPackages</literal>.
       '';
     };
+
+    openFirewall = mkOption {
+      default = false;
+      type = types.bool;
+      description = "Whether to open the firewall for the specified port.";
+    };
   };
 
   config = mkIf cfg.enable {
+    networking.firewall.allowedTCPPorts = mkIf cfg.openFirewall [ cfg.port ];
+
     systemd.services.home-assistant = {
       description = "Home Assistant";
       after = [ "network.target" ];

nixos/modules/services/misc/nix-daemon.nix

···
         default =
           [
             "$HOME/.nix-defexpr/channels"
-            "nixpkgs=/nix/var/nix/profiles/per-user/root/channels/nixos/nixpkgs"
+            "nixpkgs=/nix/var/nix/profiles/per-user/root/channels/nixos"
             "nixos-config=/etc/nixos/configuration.nix"
             "/nix/var/nix/profiles/per-user/root/channels"
           ];

nixos/modules/tasks/network-interfaces-scripted.nix

···
                   ''
                      echo "${cidr}" >> $state
                      echo -n "adding route ${cidr}... "
-                     if out=$(ip route add "${cidr}" ${options} ${via} dev "${i.name}" 2>&1); then
+                     if out=$(ip route add "${cidr}" ${options} ${via} dev "${i.name}" proto static 2>&1); then
                        echo "done"
                      elif ! echo "$out" | grep "File exists" >/dev/null 2>&1; then
                        echo "'ip route add "${cidr}" ${options} ${via} dev "${i.name}"' failed: $out"

pkgs/applications/altcoins/parity-ui/default.nix

···
 
 in stdenv.mkDerivation rec {
   name = "parity-ui-${version}";
-  version = "0.1.1";
+  version = "0.2.1";
 
   src = fetchurl {
     url = "https://github.com/parity-js/shell/releases/download/v${version}/parity-ui_${version}_amd64.deb";
-    sha256 = "1jym6q63m5f4xm06dxiiabhbqnr0hysf2d3swysncs5hg6w00lh3";
+    sha256 = "08gh438mqxj2h8i9hv826bx040wmkmdgsda5grj0k81459vds31l";
     name = "${name}.deb";
   };
 

pkgs/applications/editors/atom/beta.nix

···
-{ stdenv, pkgs, fetchurl, lib, makeWrapper, gvfs, atomEnv}:
-
-stdenv.mkDerivation rec {
-  name = "atom-beta-${version}";
-  version = "1.24.0-beta3";
-
-  src = fetchurl {
-    url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "02nnjjwlkxafi2fbi4gz276nqkmi92kf3q414vw1k3kc8q5zvxrs";
-    name = "${name}.deb";
-  };
-
-  nativeBuildInputs = [ makeWrapper ];
-
-  buildCommand = ''
-    mkdir -p $out/usr/
-    ar p $src data.tar.xz | tar -C $out -xJ ./usr
-    substituteInPlace $out/usr/share/applications/atom-beta.desktop \
-      --replace /usr/share/atom-beta $out/bin
-    mv $out/usr/* $out/
-    rm -r $out/share/lintian
-    rm -r $out/usr/
-    sed -i "s/'atom-beta'/'.atom-beta-wrapped'/" $out/bin/atom-beta
-    wrapProgram $out/bin/atom-beta \
-      --prefix "PATH" : "${gvfs}/bin"
-
-    fixupPhase
-
-    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-      --set-rpath "${atomEnv.libPath}:$out/share/atom-beta" \
-      $out/share/atom-beta/atom
-    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-      --set-rpath "${atomEnv.libPath}" \
-      $out/share/atom-beta/resources/app/apm/bin/node
-
-    #rm -f $out/share/atom-beta/resources/app/node_modules/dugite/git/bin/git
-    #ln -s ${pkgs.git}/bin/git $out/share/atom-beta/resources/app/node_modules/dugite/git/bin/git
-
-    find $out/share/atom-beta -name "*.node" -exec patchelf --set-rpath "${atomEnv.libPath}:$out/share/atom-beta" {} \;
-
-    paxmark m $out/share/atom-beta/atom
-    paxmark m $out/share/atom-beta/resources/app/apm/bin/node
-  '';
-
-  meta = with stdenv.lib; {
-    description = "A hackable text editor for the 21st Century";
-    homepage = https://atom.io/;
-    license = licenses.mit;
-    maintainers = [ maintainers.offline maintainers.nequissimus ];
-    platforms = [ "x86_64-linux" ];
-  };
-}

pkgs/applications/editors/atom/default.nix

···
 { stdenv, pkgs, fetchurl, lib, makeWrapper, gvfs, atomEnv}:
 
-stdenv.mkDerivation rec {
-  name = "atom-${version}";
-  version = "1.27.0";
+let
+  common = pname: {version, sha256}: stdenv.mkDerivation rec {
+    name = "${pname}-${version}";
+    inherit version;
 
-  src = fetchurl {
-    url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "1r37s6ndxyib644v7nlgha1pkcnz7kxpmlkhh41l5jp4dpc6iik6";
-    name = "${name}.deb";
-  };
+    src = fetchurl {
+      url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
+      name = "${name}.deb";
+      inherit sha256;
+    };
 
-  nativeBuildInputs = [ makeWrapper ];
+    nativeBuildInputs = [ makeWrapper ];
 
-  buildCommand = ''
-    mkdir -p $out/usr/
-    ar p $src data.tar.xz | tar -C $out -xJ ./usr
-    substituteInPlace $out/usr/share/applications/atom.desktop \
-      --replace /usr/share/atom $out/bin
-    mv $out/usr/* $out/
-    rm -r $out/share/lintian
-    rm -r $out/usr/
-    wrapProgram $out/bin/atom \
-      --prefix "PATH" : "${gvfs}/bin"
+    buildCommand = ''
+      mkdir -p $out/usr/
+      ar p $src data.tar.xz | tar -C $out -xJ ./usr
+      substituteInPlace $out/usr/share/applications/${pname}.desktop \
+        --replace /usr/share/${pname} $out/bin
+      mv $out/usr/* $out/
+      rm -r $out/share/lintian
+      rm -r $out/usr/
+      # sed -i "s/'${pname}'/'.${pname}-wrapped'/" $out/bin/${pname}
+      wrapProgram $out/bin/${pname} \
+        --prefix "PATH" : "${gvfs}/bin"
 
-    fixupPhase
+      fixupPhase
 
-    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-      --set-rpath "${atomEnv.libPath}:$out/share/atom" \
-      $out/share/atom/atom
-    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-      --set-rpath "${atomEnv.libPath}" \
-      $out/share/atom/resources/app/apm/bin/node
+      share=$out/share/${pname}
 
-    rm -f $out/share/atom/resources/app.asar.unpacked/node_modules/dugite/git/bin/git
-    ln -s ${pkgs.git}/bin/git $out/share/atom/resources/app.asar.unpacked/node_modules/dugite/git/bin/git
-    rm -f $out/share/atom/resources/app.asar.unpacked/node_modules/dugite/git/libexec/git-core/git
-    ln -s ${pkgs.git}/bin/git $out/share/atom/resources/app.asar.unpacked/node_modules/dugite/git/libexec/git-core/git
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
+        --set-rpath "${atomEnv.libPath}:$share" \
+        $share/atom
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
+        --set-rpath "${atomEnv.libPath}" \
+        $share/resources/app/apm/bin/node
 
-    find $out/share/atom -name "*.node" -exec patchelf --set-rpath "${atomEnv.libPath}:$out/share/atom" {} \;
+      dugite=$share/resources/app.asar.unpacked/node_modules/dugite
+      rm -f $dugite/git/bin/git
+      ln -s ${pkgs.git}/bin/git $dugite/git/bin/git
+      rm -f $dugite/git/libexec/git-core/git
+      ln -s ${pkgs.git}/bin/git $dugite/git/libexec/git-core/git
 
-    paxmark m $out/share/atom/atom
-    paxmark m $out/share/atom/resources/app/apm/bin/node
-  '';
+      find $share -name "*.node" -exec patchelf --set-rpath "${atomEnv.libPath}:$share" {} \;
 
-  meta = with stdenv.lib; {
-    description = "A hackable text editor for the 21st Century";
-    homepage = https://atom.io/;
-    license = licenses.mit;
-    maintainers = with maintainers; [ offline nequissimus synthetica ysndr ];
-    platforms = [ "x86_64-linux" ];
+      paxmark m $share/atom
+      paxmark m $share/resources/app/apm/bin/node
+    '';
+
+    meta = with stdenv.lib; {
+      description = "A hackable text editor for the 21st Century";
+      homepage = https://atom.io/;
+      license = licenses.mit;
+      maintainers = with maintainers; [ offline nequissimus synthetica ysndr ];
+      platforms = [ "x86_64-linux" ];
+    };
+  };
+in stdenv.lib.mapAttrs common {
+  atom = {
+    version = "1.27.1";
+    sha256 = "08slv8s90wz2jcdrcqh2d815wfbrkwcdx9c3qbx8cml04hz8p2gx";
+  };
+
+  atom-beta = {
+    version = "1.28.0-beta1";
+    sha256 = "1mkxq2a7sylj9jx1bs2v1pmgrwc10cgh810qic1lncq9jzpaik0n";
   };
 }

pkgs/applications/editors/kakoune/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "kakoune-unstable-${version}";
-  version = "2018-03-22";
+  version = "2018-05-21";
   src = fetchFromGitHub {
     repo = "kakoune";
     owner = "mawww";
-    rev = "f8e297acef1be0657b779fea5256f606a6c6a3a3";
-    sha256 = "14xmw3lkwzppm9bns55nmyb1lfihzhdyisf6xjqlszdj4mcf94jl";
+    rev = "878d2a4bdb674a5e7703a66e530520f48efba641";
+    sha256 = "0pwy6ilsb62s1792gjyvhvq8shj60l8lx26b58zvpfb54an4s6rk";
   };
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ ncurses asciidoc docbook_xsl libxslt ];
+  makeFlags = [ "debug=no" ];
 
   postPatch = ''
     export PREFIX=$out

pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-xmpp-http-upload/default.nix

···
+{ stdenv, fetchgit, pidgin, glib, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "purple-xmpp-upload-2017-12-31";
+
+  src = fetchgit {
+    url = "https://github.com/Junker/purple-xmpp-http-upload";
+    rev = "178096cbfc9df165c2dc1677666439969d212b37";
+    sha256 = "12l9rqlgb4i50xxrfnvwz9sqfk0d3c0m6l09mnvfixqi8illyvlp";
+  };
+
+  buildInputs = [ pidgin glib libxml2 ];
+
+  installPhase = ''
+    install -Dm644 -t $out/lib/purple-2 jabber_http_file_upload.so
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/Junker/purple-xmpp-http-upload;
+    description = "HTTP File Upload plugin for libpurple (XMPP Protocol XEP-0363)";
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ emmanuelrosa ];
+  };
+}

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

···
-{ stdenv, fetchurl, ocaml }:
+{ stdenv, fetchurl, ocamlPackages }:
 
 stdenv.mkDerivation rec {
   name = "proverif-${version}";
-  version = "1.97pl1";
+  version = "2.00";
 
   src = fetchurl {
     url    = "http://prosecco.gforge.inria.fr/personal/bblanche/proverif/proverif${version}.tar.gz";
-    sha256 = "1b0ji68crdli40a4z62gdq6fnygj3z2j63iaq4jki7wfc3nn3vgq";
+    sha256 = "0vjphj85ch9q39vc7sd6n4vxy5bplp017vlshk989yhfwb00r37y";
   };
 
-  buildInputs = [ ocaml ];
+  buildInputs = with ocamlPackages; [ ocaml findlib lablgtk ];
 
   buildPhase = "./build";
   installPhase = ''

pkgs/data/misc/hackage/default.nix

···
 { fetchurl }:
 
 fetchurl {
-  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/7988bc2977184737900cc54b2dda27af6921f5ee.tar.gz";
-  sha256 = "1zagnnab5z3zymniw5rrdahlxrfpnyf30iysa1lylgwlscnzfv0l";
+  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/810aa8e3848857c1158ded74a52159220119d188.tar.gz";
+  sha256 = "1s4x3ipn2san4rvfagmczdn70rhygpwwdmz0pqvy7q4rmgxy9x1i";
 }

pkgs/development/compilers/ghc/8.0.2.nix

···
       extraPrefix = "libraries/Cabal/";
     })
   ] ++ stdenv.lib.optional stdenv.isLinux ./ghc-no-madv-free.patch
-    ++ stdenv.lib.optional stdenv.isDarwin ./ghc-8.0.2-no-cpp-warnings.patch;
+    ++ stdenv.lib.optional stdenv.isDarwin ./ghc-8.0.2-no-cpp-warnings.patch
+    ++ stdenv.lib.optional stdenv.isDarwin ./backport-dylib-command-size-limit.patch;
 
   postPatch = "patchShebangs .";
 

pkgs/development/compilers/ghc/8.2.2.nix

···
     (fetchpatch { # Backport of https://phabricator.haskell.org/D4388 for more determinism
       url = "https://github.com/shlevy/ghc/commit/fec1b8d3555c447c0d8da0e96b659be67c8bb4bc.patch";
       sha256 = "1lyysz6hfd1njcigpm8xppbnkadqfs0kvrp7s8vqgb38pjswj5hg";
-    });
+    })
+    ++ stdenv.lib.optional stdenv.isDarwin ./backport-dylib-command-size-limit.patch;
 
   postPatch = "patchShebangs .";
 

pkgs/development/compilers/ghc/8.4.2.nix

···
     sha256 = "0plzsbfaq6vb1023lsarrjglwgr9chld4q3m99rcfzx0yx5mibp3";
     extraPrefix = "utils/hsc2hs/";
     stripLen = 1;
-  })];
+  })]
+    ++ stdenv.lib.optional stdenv.isDarwin ./backport-dylib-command-size-limit.patch;
 
   postPatch = "patchShebangs .";
 

pkgs/development/compilers/ghc/backport-dylib-command-size-limit.patch

···
+diff --git a/compiler/main/DriverPipeline.hs b/compiler/main/DriverPipeline.hs
+index acd0d61..3e83c15 100644
+--- a/compiler/main/DriverPipeline.hs
++++ b/compiler/main/DriverPipeline.hs
+@@ -1916,6 +1916,7 @@ linkBinary' staticLink dflags o_files dep_packages = do
+                       ++ pkg_framework_opts
+                       ++ debug_opts
+                       ++ thread_opts
++                      ++ (if (platformOS platform `elem` [OSDarwin]) then [ "-Wl,-dead_strip_dylibs" ] else [])
+                     ))
+ 
+ exeFileName :: Bool -> DynFlags -> FilePath
+diff --git a/compiler/main/SysTools.hs b/compiler/main/SysTools.hs
+index 1ab5b13..2ebbf51 100644
+--- a/compiler/main/SysTools.hs
++++ b/compiler/main/SysTools.hs
+@@ -1737,6 +1737,7 @@ linkDynLib dflags0 o_files dep_packages
+                  ++ map Option pkg_lib_path_opts
+                  ++ map Option pkg_link_opts
+                  ++ map Option pkg_framework_opts
++                 ++ [ Option "-Wl,-dead_strip_dylibs" ]
+               )
+         OSiOS -> throwGhcExceptionIO (ProgramError "dynamic libraries are not supported on iOS target")
+         _ -> do

pkgs/development/compilers/vala/default.nix

···
-{ stdenv, fetchurl, pkgconfig, flex, bison, libxslt, autoconf, graphviz
+{ stdenv, lib, fetchurl, pkgconfig, flex, bison, libxslt, autoconf, graphviz
 , glib, libiconv, libintl, libtool, expat
 }:
 
 let
   generic = { major, minor, sha256, extraNativeBuildInputs ? [], extraBuildInputs ? [] }:
-  stdenv.mkDerivation rec {
+  let
+    atLeast = lib.versionAtLeast "${major}.${minor}";
+  in stdenv.mkDerivation rec {
     name = "vala-${major}.${minor}";
 
     src = fetchurl {
···
 
     outputs = [ "out" "devdoc" ];
 
-    nativeBuildInputs = [ pkgconfig flex bison libxslt ] ++ extraNativeBuildInputs;
+    nativeBuildInputs = [
+      pkgconfig flex bison libxslt
+    ] ++ lib.optional (stdenv.isDarwin && (atLeast "0.38")) expat
+      ++ extraNativeBuildInputs;
 
-    buildInputs = [ glib libiconv libintl ] ++ extraBuildInputs;
+    buildInputs = [
+      glib libiconv libintl
+    ] ++ lib.optional (atLeast "0.38") graphviz
+      ++ extraBuildInputs;
 
     meta = with stdenv.lib; {
       description = "Compiler for GObject type system";
···
 
 in rec {
 
-  vala_0_23 = generic {
-    major   = "0.23";
-    minor   = "3";
-    sha256  = "101xjbc818g4849n9a80c2aai13zakj7mpnd7470xnkvz5jwqq96";
-  };
-
   vala_0_26 = generic {
     major   = "0.26";
     minor   = "2";
···
 
   vala_0_36 = generic {
     major   = "0.36";
-    minor   = "12";
-    sha256  = "1nvw721piwdh15bipg0sdll9kvgpz0y9i5fpszlc7y9w64yis25l";
+    minor   = "13";
+    sha256  = "0gxz7yisd9vh5d2889p60knaifz5zndgj98zkdfkkaykdfdq4m9k";
   };
 
   vala_0_38 = generic {
     major   = "0.38";
-    minor   = "4";
-    sha256  = "1sg5gaq3jhgr9vzh2ypiw475167k150wmyglymr7wwqppmikmcrc";
-    extraNativeBuildInputs = [ autoconf ] ++ stdenv.lib.optionals stdenv.isDarwin [ libtool expat ];
-    extraBuildInputs = [ graphviz ];
+    minor   = "9";
+    sha256  = "1dh1qacfsc1nr6hxwhn9lqmhnq39rv8gxbapdmj1v65zs96j3fn3";
+    extraNativeBuildInputs = [ autoconf ] ++ lib.optional stdenv.isDarwin libtool;
   };
 
   vala_0_40 = generic {
     major   = "0.40";
-    minor   = "0";
-    sha256  = "0wcfljl55a9qvslfcc4sf76wdpwgn83n96b7fgb7r49ib35qz20m";
-    extraNativeBuildInputs = stdenv.lib.optionals stdenv.isDarwin [ expat ];
-    extraBuildInputs = [ graphviz ];
+    minor   = "6";
+    sha256  = "1qjbwhifwwqbdg5zilvnwm4n76g8p7jwqs3fa0biw3rylzqm193d";
   };
 
   vala = vala_0_38;

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

···
   - haddock-library == 1.2.*            # required for haddock-api-2.16.x
   - haddock-library == 1.4.3            # required for haddock-api-2.17.x
   - haddock-library == 1.4.4            # required for haddock-api-2.18.x
+  - haddock-library == 1.5.*            # required for stylish-cabal-0.4.0.1
   - happy <1.19.6                       # newer versions break Agda
   - haskell-gi-overloading == 0.0       # gi-* packages use this dependency to disable overloading support
   - haskell-src-exts == 1.19.*          # required by hindent and structured-haskell-mode

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

···
        license = stdenv.lib.licenses.lgpl3;
      }) {};
 
+  "HasBigDecimal" = callPackage
+    ({ mkDerivation, base, hspec, QuickCheck }:
+     mkDerivation {
+       pname = "HasBigDecimal";
+       version = "0.1.1";
+       sha256 = "0ddyngd1mrx9s11nm7sh0nh76zi1zi7yjzmqk7xbpv6ijqka050a";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       homepage = "https://github.com/thma/HasBigDecimal#readme";
+       description = "A library for arbitrary precision decimal numbers";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "HasCacBDD" = callPackage
     ({ mkDerivation, base, Cabal, CacBDD, directory, process
      , QuickCheck
···
        homepage = "https://github.com/phadej/JuicyPixels-scale-dct#readme";
        description = "Scale JuicyPixels images with DCT";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "JuicyPixels-scale-dct_0_1_2" = callPackage
+    ({ mkDerivation, base, base-compat, carray, fft, JuicyPixels, time
+     }:
+     mkDerivation {
+       pname = "JuicyPixels-scale-dct";
+       version = "0.1.2";
+       sha256 = "04rhrmjnh12hh2nz04k245avgdcwqfyjnsbpcrz8j9328j41nf7p";
+       libraryHaskellDepends = [
+         base base-compat carray fft JuicyPixels
+       ];
+       testHaskellDepends = [
+         base base-compat carray fft JuicyPixels time
+       ];
+       homepage = "https://github.com/phadej/JuicyPixels-scale-dct#readme";
+       description = "Scale JuicyPixels images with DCT";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "JuicyPixels-stbir" = callPackage
···
      }:
      mkDerivation {
        pname = "animate";
-       version = "0.6.1";
-       sha256 = "1mjjng8mr8r6gly822nah3ps4phgydfnyggyz43n5bhdr17f37f9";
+       version = "0.7.0";
+       sha256 = "1xkp7zpbls02didfks9980989riixpklm31m7by3gsxq7mmyd6gn";
        libraryHaskellDepends = [
          aeson base bytestring containers text vector yaml
        ];
···
     ({ mkDerivation, aeson, animate, base, sdl2, sdl2-image }:
      mkDerivation {
        pname = "animate-sdl2";
-       version = "0.1.0";
-       sha256 = "1wzwhhv6x098y3pkpssxx7y1cb69z1bb2gsa2r8prg729y664648";
+       version = "0.1.1";
+       sha256 = "0wpx0jv2zyphhxi84bw4h1bw6apbazcadfxzzj90ddc3cb5lhv9n";
        libraryHaskellDepends = [ aeson animate base sdl2 sdl2-image ];
        homepage = "https://github.com/jxv/animate-sdl2#readme";
        description = "sdl2 + animate auxiliary library";
···
      }:
      mkDerivation {
        pname = "ats-format";
-       version = "0.2.0.26";
-       sha256 = "14s8bic1kvsigmi5nmjdca6pkh223axygr74nmygjbvwmryfxcxn";
+       version = "0.2.0.27";
+       sha256 = "11ln9nkdn5f8fklpddhypf02nkp8ya47kpfg4dbw86wk3h37862z";
        isLibrary = false;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cli-setup ];
···
 
   "ats-pkg" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, binary, bytestring, bzlib
-     , Cabal, cli-setup, composition-prelude, containers, dependency
-     , dhall, directory, file-embed, filemanip, hashable, http-client
-     , http-client-tls, lens, lzma, mtl, optparse-applicative
-     , parallel-io, process, shake, shake-ats, shake-ext, tar, temporary
-     , text, unix, zip-archive, zlib
+     , Cabal, cli-setup, composition-prelude, containers, cpphs
+     , dependency, dhall, directory, file-embed, filemanip, hashable
+     , http-client, http-client-tls, lzma, microlens, microlens-th, mtl
+     , optparse-applicative, parallel-io, process, shake, shake-ats
+     , shake-ext, tar, temporary, text, unix, zip-archive, zlib
      }:
      mkDerivation {
        pname = "ats-pkg";
-       version = "2.10.1.5";
-       sha256 = "14y4mpk6hkqvw8jh49idj9gx2wxcy2ppz00abny6fsbw6iff4xrs";
+       version = "2.10.1.8";
+       sha256 = "1i6dm3w5qw5xbhlzlazbp6klr31j4qajyqdwdq5r38scascdhjbq";
        revision = "1";
-       editedCabalFile = "0ff0nslsi5b4g8gp63x6js3c026ajgfamd8pg2k1aygwx8x3zqk9";
+       editedCabalFile = "1j2dyw224gspfi7s1c316ip196c8kxx1vzpxxkkbx18bw9s72fa6";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cli-setup ];
        libraryHaskellDepends = [
          ansi-wl-pprint base binary bytestring bzlib Cabal
          composition-prelude containers dependency dhall directory
-         file-embed filemanip hashable http-client http-client-tls lens lzma
-         mtl parallel-io process shake shake-ats shake-ext tar text unix
-         zip-archive zlib
+         file-embed filemanip hashable http-client http-client-tls lzma
+         microlens microlens-th mtl parallel-io process shake shake-ats
+         shake-ext tar text unix zip-archive zlib
        ];
+       libraryToolDepends = [ cpphs ];
        executableHaskellDepends = [
-         base composition-prelude directory lens optparse-applicative
+         base composition-prelude directory microlens optparse-applicative
          parallel-io shake shake-ats temporary text
        ];
        homepage = "https://github.com/vmchale/atspkg#readme";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "binary-tagged_0_1_5" = callPackage
+    ({ mkDerivation, aeson, array, base, base16-bytestring, bifunctors
+     , binary, binary-orphans, bytestring, containers, criterion
+     , deepseq, generics-sop, hashable, nats, quickcheck-instances
+     , scientific, semigroups, SHA, tagged, tasty, tasty-quickcheck
+     , text, time, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "binary-tagged";
+       version = "0.1.5";
+       sha256 = "1s05hrak9mg8klid5jsdqh1i7d1zyzkpdbdc969g2s9h06lk7dyl";
+       libraryHaskellDepends = [
+         aeson array base base16-bytestring binary bytestring containers
+         generics-sop hashable scientific SHA tagged text time
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson array base base16-bytestring bifunctors binary binary-orphans
+         bytestring containers generics-sop hashable quickcheck-instances
+         scientific SHA tagged tasty tasty-quickcheck text time
+         unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [
+         aeson array base base16-bytestring binary binary-orphans bytestring
+         containers criterion deepseq generics-sop hashable nats scientific
+         semigroups SHA tagged text time unordered-containers vector
+       ];
+       homepage = "https://github.com/phadej/binary-tagged#readme";
+       description = "Tagged binary serialisation";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "binary-tree" = callPackage
     ({ mkDerivation, base, ChasingBottoms, checkers, criterion, deepseq
      , doctest, ghc-prim, HUnit, QuickCheck, random, test-framework
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "bindings-DSL_1_0_25" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "bindings-DSL";
+       version = "1.0.25";
+       sha256 = "0kqrd78nspl3lk4a0fqn47d8dirjg3b24dkvkigcrlb81hw35pk3";
+       libraryHaskellDepends = [ base ];
+       homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
+       description = "FFI domain specific language, on top of hsc2hs";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "bindings-EsounD" = callPackage
     ({ mkDerivation, base, bindings-audiofile, bindings-DSL, esound }:
      mkDerivation {
···
     ({ mkDerivation, base, bindings-DSL }:
      mkDerivation {
        pname = "bindings-posix";
-       version = "1.2.6";
-       sha256 = "1yza3qbf0f5gfpg79pb6xfpw37zg191nmxa4r6h9x4xb5na0rzff";
+       version = "1.2.7";
+       sha256 = "02bcb40jpwylcl48g48r2yd3j7pmij94975r3dcnmyk76kyp3fc3";
        libraryHaskellDepends = [ base bindings-DSL ];
-       description = "Low level bindings to posix";
+       description = "Project bindings-* raw interface to Posix";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "bits-extra";
-       version = "0.0.1.0";
-       sha256 = "0slxzlc81nbzzd7513i9crwqlpxxvpfz9haq5hr9qp533pr4cyz4";
+       version = "0.0.1.1";
+       sha256 = "0fsih4vrlq9l7851341n5qj1bp014f8rn7fhqf28803l6m3nrn1l";
        libraryHaskellDepends = [ base ghc-prim vector ];
        testHaskellDepends = [
          base ghc-prim hedgehog hspec hw-hedgehog hw-hspec-hedgehog
···
      }:
      mkDerivation {
        pname = "bytestring-encodings";
-       version = "0.1.0.1";
-       sha256 = "09lx8d92dhd4gicz8pbpj19k2iaig1yl4lksqpxiqgxzybwqn0rc";
+       version = "0.2.0.1";
+       sha256 = "0qjqbffp4fa7a95mfsgzhibqblxrxl4qa8kb0yhyb8c1r47r5nn7";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        testHaskellDepends = [ base bytestring hedgehog ];
        benchmarkHaskellDepends = [ base bytestring gauge text ];
···
      }) {};
 
   "cautious-file" = callPackage
-    ({ mkDerivation, base, bytestring, directory, filepath, unix }:
+    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
+     , process, unix
+     }:
      mkDerivation {
        pname = "cautious-file";
        version = "1.0.2";
        sha256 = "1sw5ngwrarq1lsd4c6v2wdmgbhkkq6kpybb62r8ccm11ddgn3yiq";
-       revision = "1";
-       editedCabalFile = "14yqf1wljrham5k4i4189h2pdlwgj3v59ff4p346fivdzh234666";
+       revision = "2";
+       editedCabalFile = "02ysmm577c4z0s3mqrpdpmzvs18y834ic90iwi5czcnj02zvg22s";
+       setupHaskellDepends = [ base Cabal process ];
        libraryHaskellDepends = [
          base bytestring directory filepath unix
        ];
···
        pname = "codeworld-api";
        version = "0.2.2.1";
        sha256 = "0vb3v8d4jdzk14zs1jv4m5f2wa32bpxsfa0zr4f3w6z77as136sx";
+       revision = "2";
+       editedCabalFile = "0glp45kr9v8c9pxbaaq6cwm6i5rhglw2npk16kab80dgsfdb1pj9";
        libraryHaskellDepends = [
          base blank-canvas cereal cereal-text containers hashable mtl random
          random-shuffle text time
···
      }) {};
 
   "componentm" = callPackage
-    ({ mkDerivation, base, containers, deepseq, exceptions
+    ({ mkDerivation, base, containers, deepseq, exceptions, pretty-show
      , prettyprinter, rio, tasty, tasty-hunit, teardown
      }:
      mkDerivation {
        pname = "componentm";
-       version = "0.0.0.1";
-       sha256 = "1r2z9jbb0ka2i0lxbrb30p1x0zbwdcxid5k53mkzg82d5v2f08k9";
+       version = "0.0.0.2";
+       sha256 = "19xnav3xiw5v8sdmw6a90wdhxxkjlkvpkwrf0pjsxlisgn93vqpg";
        libraryHaskellDepends = [
-         base containers deepseq exceptions prettyprinter rio teardown
+         base containers deepseq exceptions pretty-show prettyprinter rio
+         teardown
        ];
        testHaskellDepends = [
-         base containers prettyprinter rio tasty tasty-hunit teardown
+         base containers pretty-show prettyprinter rio tasty tasty-hunit
+         teardown
        ];
        homepage = "https://github.com/roman/Haskell-componentm#readme";
        description = "Monad for allocation and cleanup of application resources";
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "componentm-devel" = callPackage
+    ({ mkDerivation, base, componentm, foreign-store, rio, teardown }:
+     mkDerivation {
+       pname = "componentm-devel";
+       version = "0.0.0.2";
+       sha256 = "02jvv2f5akl47jg66xwcgj0s5wif0wckp2d0y6x4imr6kcy31mrd";
+       libraryHaskellDepends = [
+         base componentm foreign-store rio teardown
+       ];
+       homepage = "https://github.com/roman/Haskell-componentm#readme";
+       description = "Easy REPL driven development using ComponentM";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "composable-associations" = callPackage
     ({ mkDerivation, base, lens, tasty, tasty-hunit }:
      mkDerivation {
···
        pname = "cryptonite-conduit";
        version = "0.2.2";
        sha256 = "1bldcmda4xh52mw1wfrjljv8crhw3al7v7kv1j0vidvr7ymnjpbh";
+       revision = "1";
+       editedCabalFile = "1hh2nzfz4qpxgivfilgk4ll416lph8b2fdkzpzrmqfjglivydfmz";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra cryptonite exceptions memory
          resourcet transformers
···
 
   "dependency" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, binary, containers, cpphs
-     , criterion, deepseq, hspec, lens, recursion-schemes, transformers
+     , criterion, deepseq, hspec, micro-recursion-schemes, microlens
      }:
      mkDerivation {
        pname = "dependency";
-       version = "1.0.0.0";
-       sha256 = "08n38sqcnljja235cv4xlvfmir7cbcmb53rayc81nl3km292hr8i";
+       version = "1.1.0.0";
+       sha256 = "1874zvkv5vkx9s6864kmpihq7514hywzb2a1zhqn3f6qf27bnj9c";
        libraryHaskellDepends = [
-         ansi-wl-pprint base binary containers deepseq lens
-         recursion-schemes transformers
+         ansi-wl-pprint base binary containers deepseq
+         micro-recursion-schemes microlens
        ];
        libraryToolDepends = [ cpphs ];
        testHaskellDepends = [ base containers hspec ];
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "descript-lang" = callPackage
+    ({ mkDerivation, aeson, array, autoexporter, base, bifunctors
+     , bytestring, containers, data-default, directory, exceptions
+     , filepath, fsnotify, hashtables, haskell-lsp, hslogger, hspec
+     , HUnit, lens, megaparsec, mtl, network-uri, optparse-applicative
+     , QuickCheck, rainbow, stm, text, transformers
+     , unordered-containers, vector, yaml, yi-rope
+     }:
+     mkDerivation {
+       pname = "descript-lang";
+       version = "0.2.0.0";
+       sha256 = "0gar05gz7xvz74c9573h6zgv8rflwclzr3aw21cnyy1wpkqlbsnl";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array autoexporter base bifunctors bytestring containers filepath
+         hashtables megaparsec stm text transformers
+       ];
+       executableHaskellDepends = [
+         aeson array autoexporter base bifunctors bytestring containers
+         data-default exceptions filepath fsnotify hashtables haskell-lsp
+         hslogger lens megaparsec mtl network-uri optparse-applicative
+         rainbow stm text transformers unordered-containers vector yi-rope
+       ];
+       testHaskellDepends = [
+         array autoexporter base bifunctors bytestring containers directory
+         filepath hashtables hspec HUnit megaparsec QuickCheck stm text
+         transformers yaml
+       ];
+       homepage = "https://bitbucket.org/jakobeha/descript-lang/src/master/README.md";
+       description = "Library, interpreter, and CLI for Descript programming language";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "descriptive" = callPackage
     ({ mkDerivation, aeson, base, bifunctors, containers, hspec, HUnit
      , mtl, scientific, text, transformers, vector
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall_1_13_1" = callPackage
+  "dhall_1_14_0" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, case-insensitive
      , containers, contravariant, cryptonite, deepseq, directory
-     , exceptions, filepath, formatting, haskeline, http-client
+     , doctest, exceptions, filepath, formatting, haskeline, http-client
      , http-client-tls, insert-ordered-containers, lens-family-core
      , megaparsec, memory, mtl, optparse-applicative, parsers
      , prettyprinter, prettyprinter-ansi-terminal, repline, scientific
···
      }:
      mkDerivation {
        pname = "dhall";
-       version = "1.13.1";
-       sha256 = "1mjhxkdpw7blcdci6cmm3x2c9ascp7djc8c77dblfpzyqa3sqxf0";
+       version = "1.14.0";
+       sha256 = "0dm823rr4gkx1m7f0v9wvqlkhn1mmmml854p4zsi2j6ai4l885gl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          prettyprinter prettyprinter-ansi-terminal repline text
        ];
        testHaskellDepends = [
-         base deepseq insert-ordered-containers prettyprinter tasty
+         base deepseq doctest insert-ordered-containers prettyprinter tasty
          tasty-hunit text vector
        ];
        description = "A configuration language guaranteed to terminate";
···
      }:
      mkDerivation {
        pname = "dhall-bash";
-       version = "1.0.12";
-       sha256 = "1q9bwcdxyn2f7zp6r67k3kxqydj54shf0v0liyps7g7c9fixzrij";
-       revision = "1";
-       editedCabalFile = "12qklhw4jk2i1qiq9wyv23d6bl3yyqyjwf8dda649clby2my0hrc";
+       version = "1.0.13";
+       sha256 = "04f9ksw36kqb1g41211hcfcgg21pxkdszsznpa1vh09dcmlv6i7i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dhall-json_1_1_0" = callPackage
+  "dhall-json_1_2_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, dhall
-     , optparse-generic, text, unordered-containers, yaml
+     , insert-ordered-containers, optparse-applicative, text
+     , unordered-containers, yaml
      }:
      mkDerivation {
        pname = "dhall-json";
-       version = "1.1.0";
-       sha256 = "13fan1zdgj8zdv1br5vj57iqbfb5grllk8a2xkz6yyfk8kylmrc7";
-       revision = "1";
-       editedCabalFile = "0k8q44hfhd95k7i92g1zvsw9ys1ak6vl663r2v7pf6k1zl70cyhs";
+       version = "1.2.0";
+       sha256 = "0ks8ycgysimj1jqabzdrrsdcqkp3bi5f0zhwgmilsprx88dxrddz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base dhall text unordered-containers
+         aeson base dhall insert-ordered-containers optparse-applicative
+         text unordered-containers
        ];
        executableHaskellDepends = [
-         aeson aeson-pretty base bytestring dhall optparse-generic text yaml
+         aeson aeson-pretty base bytestring dhall optparse-applicative text
+         yaml
        ];
        description = "Compile Dhall to JSON or YAML";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "dhall-nix";
-       version = "1.1.3";
-       sha256 = "0dpkg84qzviasadgif30ivbg6k7azqq9ki8grd3g93zbrdxgv4fj";
+       version = "1.1.4";
+       sha256 = "1yhnpmvisizl5vm37sns8sn0ff496aqr2i76v3c2034cjd9v0mdb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, dhall, optparse-generic, text }:
      mkDerivation {
        pname = "dhall-text";
-       version = "1.0.9";
-       sha256 = "0jh2nm26i5gdicsxzvx54rmx7x1g5mpjiwd7c5wfj6pmrpcp606r";
+       version = "1.0.10";
+       sha256 = "07cxc3m2pqg5lk0d03i20ch6bsq779sg3ci4yy1fkai8vs513yjq";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base dhall optparse-generic text ];
···
        pname = "diagrams-gtk";
        version = "1.4";
        sha256 = "1sga2wwkircjgryd4pn9i0wvvcnh3qnhpxas32crpdq939idwsxn";
-       revision = "1";
-       editedCabalFile = "0afpcbgkc897gp0hpqi5frwbzln1qapf36p93v9zxl05my6nj04i";
+       revision = "2";
+       editedCabalFile = "0hblrqvwk1pbssaci97v36r71kpm7kkcghh5ijmq52lmjfq72jqm";
        libraryHaskellDepends = [
          base cairo diagrams-cairo diagrams-lib gtk
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "difference-monoid" = callPackage
+    ({ mkDerivation, adjunctions, base, comonad, containers, deepseq
+     , distributive, doctest, groups, hedgehog, hedgehog-checkers
+     , QuickCheck, semigroupoids
+     }:
+     mkDerivation {
+       pname = "difference-monoid";
+       version = "0.1.0.0";
+       sha256 = "1i99hcxb07142227x4f0p2giayvzpr49ynx6apys178bgi99ih3k";
+       libraryHaskellDepends = [
+         adjunctions base comonad deepseq distributive groups semigroupoids
+       ];
+       testHaskellDepends = [
+         adjunctions base comonad containers deepseq distributive doctest
+         groups hedgehog hedgehog-checkers QuickCheck semigroupoids
+       ];
+       homepage = "https://github.com/oisdk/difference-monoid#readme";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "difftodo" = callPackage
     ({ mkDerivation, base, bytestring, diff-parse, highlighter2
      , optparse-applicative, pretty-show, process, protolude, tasty
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "dns_3_0_3" = callPackage
+  "dns_3_0_4" = callPackage
     ({ mkDerivation, async, attoparsec, auto-update, base
      , base64-bytestring, binary, bytestring, containers, cryptonite
      , doctest, hspec, iproute, mtl, network, psqueues, QuickCheck, safe
···
      }:
      mkDerivation {
        pname = "dns";
-       version = "3.0.3";
-       sha256 = "0m7xgf5vgh3xj5yrv8hyvhx3lligx1xrnq22a9b6s2prbywyllfv";
+       version = "3.0.4";
+       sha256 = "1aa4zb9zkk244rndimrq8maxj9qrmz3rb13v9n8jblmp6ssk6d3v";
        libraryHaskellDepends = [
          async attoparsec auto-update base base64-bytestring binary
          bytestring containers cryptonite iproute mtl network psqueues safe
···
        pname = "dual-tree";
        version = "0.2.2";
        sha256 = "1sx9p9yr06z7bi7pshjpswizs6bkmfzcpw8xlasriniry86df4kl";
+       revision = "1";
+       editedCabalFile = "1hkjhij3s2a82b0sd898511lr6iphk3myk1l0hpl42ai32sf606q";
        libraryHaskellDepends = [
          base monoid-extras newtype-generics semigroups
        ];
···
      }:
      mkDerivation {
        pname = "etc";
-       version = "0.4.0.0";
-       sha256 = "0zyyayk9b6jzksxd14k08594ms5szgcpa63nlw3vnni1q1c2x1v4";
+       version = "0.4.0.1";
+       sha256 = "0vpc3816vsxs985h076wxyr3z9q759399xapnhiv1m428sksw6zs";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base hashable rio text typed-process unliftio
···
      }:
      mkDerivation {
        pname = "fast-arithmetic";
-       version = "0.6.0.5";
-       sha256 = "138qdgwqc3qnafi0kf5nkva3nvcfn71b1ch2xrwgxkna5kniqjrh";
+       version = "0.6.0.6";
+       sha256 = "1vw652sps7dx11anqrrjw2fz039m7bkcfmk61px9g3yn0wvjlm02";
        libraryHaskellDepends = [ base composition-prelude gmpint ];
        testHaskellDepends = [ arithmoi base combinat hspec QuickCheck ];
        benchmarkHaskellDepends = [ arithmoi base combinat criterion ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "forma_1_0_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, hspec, mtl, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "forma";
+       version = "1.0.0";
+       sha256 = "11rqwlqsjw5r674zqv9lmafqhlb339afifa2376a6cgbxm7j2msd";
+       libraryHaskellDepends = [
+         aeson base containers mtl text unordered-containers
+       ];
+       testHaskellDepends = [ aeson base containers hspec mtl text ];
+       homepage = "https://github.com/mrkkrp/forma";
+       description = "Parse and validate forms in JSON format";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "formal" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, containers
      , directory, file-embed, HTTP, indents, interpolatedstring-perl6
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ghc-trace-events" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, text }:
+     mkDerivation {
+       pname = "ghc-trace-events";
+       version = "0.0.0";
+       sha256 = "00lq6bcl78drqlzj39avf9k2x2q4d2fdac3rrxrxicsdwry6brkk";
+       libraryHaskellDepends = [ base bytestring text ];
+       benchmarkHaskellDepends = [ base bytestring criterion ];
+       homepage = "https://github.com/maoe/ghc-trace-events";
+       description = "Faster replacements for traceEvent and traceEventMarker";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "ghc-typelits-extra" = callPackage
     ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
      , ghc-typelits-knownnat, ghc-typelits-natnormalise, integer-gmp
···
      }:
      mkDerivation {
        pname = "grammatical-parsers";
-       version = "0.3";
-       sha256 = "1dqmjg40h4gm6921yq84sx8x5sdbzhnv8xl7m2ylb872ddbzfwg3";
+       version = "0.3.1";
+       sha256 = "12lrzzpv48j34y6lwyiq7hg3mahynwj934rsfjmyamy5m5ya0170";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          text
        ];
        homepage = "https://github.com/blamario/grampa/tree/master/grammatical-parsers";
-       description = "parsers that can combine into grammars";
+       description = "parsers that combine into grammars";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "gtk-sni-tray";
-       version = "0.1.3.0";
-       sha256 = "197a0wfbg6xzyka2ydbmbs6g6mghlp1ncchbmrb6gzn3b85iggq6";
+       version = "0.1.3.1";
+       sha256 = "1wsq7d47px11c64k38nqxms408yd4il35ai8r53p76qnd04s8saw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, gi-gdk, gi-gtk, text, transformers }:
      mkDerivation {
        pname = "gtk-strut";
-       version = "0.1.2.0";
-       sha256 = "1v73qca2qdkpvfal2ndmwrxyj1qwgxgmammkbf88azs7wcxcf7y6";
+       version = "0.1.2.1";
+       sha256 = "1m5vvyiyn4v6a8jhizcm8dyi20q2nag9ycm0c2hdxfhsl7fxbx31";
        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";
···
      }:
      mkDerivation {
        pname = "gtkglext";
-       version = "0.13.1.1";
-       sha256 = "15v40f21xlg5r2zidh77cfiq6ink1dxljbl59mf5sqyq5pjbdw3h";
+       version = "0.13.2.0";
+       sha256 = "14rid23m5qa5g0fkc07cac5j8arkbz3cc23wkva7b46xnyfs10ra";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
        libraryHaskellDepends = [ base glib gtk pango ];
···
     ({ mkDerivation, base, filepath, haddock-api, hspec }:
      mkDerivation {
        pname = "haddock";
-       version = "2.19.0.1";
-       sha256 = "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7";
+       version = "2.20.0";
+       sha256 = "0jfgd9n0gcbg9i2ifra5cnj0xh2nc5j65ns3b280482r65vnph9w";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haddock-api ];
···
      }:
      mkDerivation {
        pname = "haddock-api";
-       version = "2.19.0.1";
-       sha256 = "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3";
-       revision = "1";
-       editedCabalFile = "0lfvhpiy8zr117wn9s9nc5va83rb0jz1h14ggm88565xr6qbwmjx";
+       version = "2.20.0";
+       sha256 = "02f6038djjbx2vshd5digk4rm16fl33m080s7v01nn5bzfak9g7j";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base bytestring Cabal containers deepseq directory filepath
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "haddock-library_1_6_0" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, containers, deepseq
+     , directory, filepath, hspec, hspec-discover, optparse-applicative
+     , QuickCheck, transformers, tree-diff
+     }:
+     mkDerivation {
+       pname = "haddock-library";
+       version = "1.6.0";
+       sha256 = "0h7721zw6kbm1vcr0kp69avfy3qfd9zsgmh24gy909kxgdp0k7v0";
+       libraryHaskellDepends = [
+         base bytestring containers deepseq transformers
+       ];
+       testHaskellDepends = [
+         base base-compat bytestring containers deepseq directory filepath
+         hspec optparse-applicative QuickCheck transformers tree-diff
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       homepage = "http://www.haskell.org/haddock/";
+       description = "Library exposing some functionality of Haddock";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "haddock-test" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, directory, filepath
      , process, syb, xhtml, xml
···
        pname = "hashable-time";
        version = "0.2.0.1";
        sha256 = "0k932nyd08l3xxbh2g3n76py2f4kd9yw4s5a065vjz0xp6wjnxdm";
+       revision = "1";
+       editedCabalFile = "0rv40xkg3gj8jnqsry1gq3f5s5la6d5arg8fzkirnwdpcgha1as6";
        libraryHaskellDepends = [ base hashable time ];
        description = "Hashable instances for Data.Time";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "hdocs";
-       version = "0.5.2.1";
-       sha256 = "1b8qrkfryyj8fg07vzl4cq4rwsbhlaqm5l477ld4mmgcgk4infi8";
+       version = "0.5.3.0";
+       sha256 = "0gkv4xy7jr2ic22gn5fpj3vd6avgd1xqblv96gg1m0fhfsj92y5h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hedis_0_10_2" = callPackage
+    ({ mkDerivation, async, base, bytestring, bytestring-lexing
+     , deepseq, doctest, errors, HTTP, HUnit, mtl, network, network-uri
+     , resource-pool, scanner, slave-thread, stm, test-framework
+     , test-framework-hunit, text, time, tls, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "hedis";
+       version = "0.10.2";
+       sha256 = "05bnma4ssdg4zx39xrwx14xys47zdxxkk9iyi8d29p1vb90vv68w";
+       libraryHaskellDepends = [
+         async base bytestring bytestring-lexing deepseq errors HTTP mtl
+         network network-uri resource-pool scanner stm text time tls
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         async base bytestring doctest HUnit mtl slave-thread stm
+         test-framework test-framework-hunit text time
+       ];
+       benchmarkHaskellDepends = [ base mtl time ];
+       homepage = "https://github.com/informatikr/hedis";
+       description = "Client library for the Redis datastore: supports full command set, pipelining";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hedis-config" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hedis, scientific, text
      , time
···
      }:
      mkDerivation {
        pname = "hprotoc";
-       version = "2.4.9";
-       sha256 = "1bfar7biksa9ha6vzrh4z2lz048mf1zz261ih6mbl9q6kvyr27w4";
+       version = "2.4.10";
+       sha256 = "14zihg4gb42kr68y73mzb7a9ryc2yi4h50n3a4v8idw17f3fdhlz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hspec-golden-aeson_0_6_0_0" = callPackage
+  "hspec-golden-aeson_0_7_0_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
      , filepath, hspec, hspec-core, QuickCheck, quickcheck-arbitrary-adt
      , random, silently, transformers
      }:
      mkDerivation {
        pname = "hspec-golden-aeson";
-       version = "0.6.0.0";
-       sha256 = "0918b4y0lkz66hyhydqkd0yxna37vqqqc0pgjg4vn1h860xj0rv0";
+       version = "0.7.0.0";
+       sha256 = "18jc992dhln1v5sfg8yjfsm2i5c7c38ph3bxrjxgc9bl7fzcsk0i";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring directory filepath hspec
          QuickCheck quickcheck-arbitrary-adt random transformers
···
      }:
      mkDerivation {
        pname = "iCalendar";
-       version = "0.4.0.3";
-       sha256 = "0dbs9s68fpx67ngjnd1p8c9n421bzn6a034dr6i3bhg2cn0s01mw";
+       version = "0.4.0.4";
+       sha256 = "1hgji4riaqjpsqi2c7i1md9p8ig4sfigmldllnpkwbbhwhzmnsq5";
        libraryHaskellDepends = [
          base base64-bytestring bytestring case-insensitive containers
          data-default mime mtl network network-uri old-locale parsec text
···
 
   "implicit" = callPackage
     ({ mkDerivation, base, blaze-builder, blaze-markup, blaze-svg
-     , bytestring, containers, criterion, deepseq, directory, download
-     , filepath, hspec, JuicyPixels, monads-tf, mtl, NumInstances
-     , optparse-applicative, parallel, parsec, random, silently
-     , snap-core, snap-server, storable-endian, text, transformers
-     , unordered-containers, vector-space
+     , bytestring, bytestring-builder, containers, criterion, deepseq
+     , directory, filepath, hspec, JuicyPixels, monads-tf, mtl
+     , NumInstances, optparse-applicative, parallel, parsec, random
+     , silently, snap-core, snap-server, storable-endian, text
+     , transformers, unordered-containers, vector-space
      }:
      mkDerivation {
        pname = "implicit";
-       version = "0.1.0";
-       sha256 = "16yhclgph95a698qbs6l9c16k950bh1zzy8spwgfjh7ilpn0s4pk";
+       version = "0.2.0";
+       sha256 = "1lj206x2s7sdjg6yllhp809d7k84xa6ky70859jyw4m6bry4xyaw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base blaze-builder blaze-markup blaze-svg bytestring containers
-         criterion deepseq directory download filepath JuicyPixels monads-tf
-         NumInstances parallel parsec silently snap-core snap-server
-         storable-endian text transformers unordered-containers vector-space
+         base blaze-builder blaze-markup blaze-svg bytestring
+         bytestring-builder containers criterion deepseq directory filepath
+         hspec JuicyPixels monads-tf NumInstances parallel parsec silently
+         snap-core snap-server storable-endian text transformers
+         unordered-containers vector-space
        ];
        executableHaskellDepends = [
          base blaze-builder blaze-markup blaze-svg bytestring containers
···
      }:
      mkDerivation {
        pname = "int-multimap";
-       version = "0.3";
-       sha256 = "1hsd55hg52mb6vimk5813l0s72spvy9njrhzz6dc6jddh65v58lv";
+       version = "0.3.1";
+       sha256 = "0sl3xzlw0mzyq1h28mqklm41q9pknsf1qmd74a5syn24m01dknnv";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "kleene" = callPackage
+    ({ mkDerivation, base, base-compat-batteries, containers, lattices
+     , MemoTrie, QuickCheck, range-set-list, regex-applicative
+     , step-function, text, transformers
+     }:
+     mkDerivation {
+       pname = "kleene";
+       version = "0";
+       sha256 = "00hbrmsm19azxxql14y6k7h7z8k4azlmy4y0gimyqbx4nb7swln6";
+       libraryHaskellDepends = [
+         base base-compat-batteries containers lattices MemoTrie QuickCheck
+         range-set-list regex-applicative step-function text transformers
+       ];
+       homepage = "https://github.com/phadej/kleene";
+       description = "Kleene algebra";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "kmeans" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }) {};
 
   "lucid-extras" = callPackage
-    ({ mkDerivation, base, blaze-builder, bytestring, directory, lucid
-     , text
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring, directory
+     , lucid, text
      }:
      mkDerivation {
        pname = "lucid-extras";
-       version = "0.1.0.0";
-       sha256 = "0akpsh79lpdx7in1ffzz2l36i4gnvfn290cjz0pdr0y8bs0bv9dr";
+       version = "0.1.0.1";
+       sha256 = "0wyb5pqhphfckmzpnl0xp6fy8fmnwqjqim3h3f3sdjqkqdly5iaw";
        libraryHaskellDepends = [
-         base blaze-builder bytestring lucid text
+         aeson base blaze-builder bytestring lucid text
        ];
        testHaskellDepends = [ base directory lucid ];
        homepage = "https://github.com/diffusionkinetics/open/lucid-extras";
···
        pname = "meldable-heap";
        version = "2.0.3";
        sha256 = "1p75zjlls38sd1lma7w95mpmb9kdff19s2as6pz1ki1g20nnxdk3";
+       revision = "1";
+       editedCabalFile = "1igir17mnzrmvbcp5n93x1zqjbc44dv0gl4z7szvi7nqh47h72k7";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base ];
-       homepage = "http://code.google.com/p/priority-queues/";
+       homepage = "https://github.com/jbapple/priority-queues";
        description = "Asymptotically optimal, Coq-verified meldable heaps, AKA priority queues";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, mtl, stm }:
      mkDerivation {
        pname = "monadIO";
-       version = "0.10.1.4";
-       sha256 = "08158j978h69knbnzxkzv856sjhhw24h5lh7d8hx2lyhzbpnfarl";
+       version = "0.11.0.0";
+       sha256 = "11pbg83fw5vdlny5w9afmzdhn3ryg1av429gbsk8w6wl8zqhd4n9";
        libraryHaskellDepends = [ base mtl stm ];
        description = "Overloading of concurrency variables";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "motor" = callPackage
-    ({ mkDerivation, base, CTRex, indexed, indexed-extras, reflection
-     , template-haskell
+    ({ mkDerivation, base, indexed, indexed-extras, reflection
+     , row-types, template-haskell
      }:
      mkDerivation {
        pname = "motor";
-       version = "0.2.0.0";
-       sha256 = "0py79plg65d1h49zm8jz6hbzg57lq0psv8k5m5w23dwrgn9jr4x1";
+       version = "0.3.0";
+       sha256 = "0yx0gwdqny8p5nggigk5w57cyf2qjdjb5ypppwd84qjm663na9bh";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-         base CTRex indexed indexed-extras reflection template-haskell
+         base indexed indexed-extras reflection row-types template-haskell
        ];
-       testHaskellDepends = [ base CTRex indexed indexed-extras ];
+       executableHaskellDepends = [
+         base indexed indexed-extras row-types
+       ];
+       testHaskellDepends = [ base indexed indexed-extras row-types ];
        description = "Type-safe effectful state machines in Haskell";
        license = stdenv.lib.licenses.mpl20;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "motor-diagrams";
-       version = "0.2.0.0";
-       sha256 = "094in9l2sngxg4p2ijfi97dqs6v7rk1a4h7fcbi269qmh9sfck43";
+       version = "0.3.0";
+       sha256 = "1rvlb3gvnzdqzwrg3nm21vw6j33c4aqp6npsz8cdbh24ijc46jbr";
        libraryHaskellDepends = [
          base motor motor-reflection template-haskell text
        ];
···
      }) {};
 
   "motor-reflection" = callPackage
-    ({ mkDerivation, base, CTRex, hspec, hspec-discover, indexed, motor
-     , template-haskell, text
+    ({ mkDerivation, base, hspec, hspec-discover, indexed, motor
+     , row-types, template-haskell, text
      }:
      mkDerivation {
        pname = "motor-reflection";
-       version = "0.2.0.0";
-       sha256 = "0qycmskhvh3n3pa4xib72irzka8hn93bqv4ayrykhnp4k0fbbndd";
+       version = "0.3.0";
+       sha256 = "1mac2ywknribmzs79dpjigk45nzrwsx7as0zi1zaqrq2vy45xl8y";
        libraryHaskellDepends = [ base motor template-haskell text ];
        testHaskellDepends = [
-         base CTRex hspec hspec-discover indexed motor
+         base hspec hspec-discover indexed motor row-types
        ];
        description = "Reflect on Motor FSM typeclasses to obtain runtime representations";
        license = stdenv.lib.licenses.mpl20;
···
      }) {};
 
   "nanovg" = callPackage
-    ({ mkDerivation, base, bytestring, c2hs, containers, GLEW, hspec
-     , inline-c, libGL, libGLU, QuickCheck, text, vector
+    ({ mkDerivation, base, bytestring, c2hs, containers, GLEW, glew
+     , hspec, inline-c, libGL, libGLU, QuickCheck, text, vector
      }:
      mkDerivation {
        pname = "nanovg";
-       version = "0.5.2.0";
-       sha256 = "0p8g3235srd23vpy2yvw68sxdx4mb31m09yvm8im3rbhfwi1vqr2";
-       revision = "1";
-       editedCabalFile = "0ls8wyr1gk1qcd3vzyi0a1i8jxy9b6x3973fy0h1icda7f62r0mb";
+       version = "0.6.0.0";
+       sha256 = "15nljmlcgj1pw9ydy3a9nmk6zpgfp3p71arw04b1krx2y9r2fnp3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers text vector ];
        librarySystemDepends = [ GLEW libGL libGLU ];
+       libraryPkgconfigDepends = [ glew ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ base containers hspec inline-c QuickCheck ];
        homepage = "https://github.com/cocreature/nanovg-hs";
        description = "Haskell bindings for nanovg";
        license = stdenv.lib.licenses.isc;
        hydraPlatforms = stdenv.lib.platforms.none;
-     }) {GLEW = null; inherit (pkgs) libGL; inherit (pkgs) libGLU;};
+     }) {GLEW = null; inherit (pkgs) glew; inherit (pkgs) libGL; 
+         inherit (pkgs) libGLU;};
 
   "nanq" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
···
      }:
      mkDerivation {
        pname = "numhask-prelude";
-       version = "0.0.4.0";
-       sha256 = "11kwszs98c00bcjr318rm7yfc0h304s6vnrmh97mp4xp4bk7fqq1";
+       version = "0.0.4.1";
+       sha256 = "1sj7l62cgk68b1d2lfxd944yxw43l6a3qr335x21jjhgdaffwg3x";
        libraryHaskellDepends = [
          base numhask protolude QuickCheck tasty tasty-quickcheck
        ];
···
      }:
      mkDerivation {
        pname = "obdd";
-       version = "0.8.1";
-       sha256 = "04cfbqsy65kvs9iyx8crpz54l0jmndvz2smn83k0ybpj3ahs4kj2";
+       version = "0.8.2";
+       sha256 = "17cs06cxxmjknb1mc691n5k70yqplasqc97dpr6vx71aj1wzwzhw";
        libraryHaskellDepends = [
          array base containers ersatz mtl process-extras random text
        ];
···
      }:
      mkDerivation {
        pname = "openpgp-Crypto";
-       version = "0.5";
-       sha256 = "0gsdzfg378j7s2kpryg43ajxcdk8s5szk0yq48qfvnlsbgrxz07r";
+       version = "0.6";
+       sha256 = "0143ln5pr3d0kg28838ipir3j6x6r6j9rc4f5dmvsb2ffl464zxm";
        libraryHaskellDepends = [
          base binary bytestring Crypto openpgp utf8-string
        ];
···
      }:
      mkDerivation {
        pname = "potoki-hasql";
-       version = "1.3";
-       sha256 = "0n8ysdcg8p40idbbnyrmhjyh1hxhg7nrv5yf03fb0cvx5mwdgh11";
+       version = "1.4";
+       sha256 = "1ahdmc98pkfvbj8z1ds6xfzrj77wqbagfkn9jfzsz14z2m2rw8b2";
        libraryHaskellDepends = [
          base bytestring hasql potoki potoki-core profunctors text vector
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "protocol-buffers_2_4_10" = callPackage
+    ({ mkDerivation, array, base, binary, bytestring, containers
+     , directory, filepath, mtl, parsec, syb, utf8-string
+     }:
+     mkDerivation {
+       pname = "protocol-buffers";
+       version = "2.4.10";
+       sha256 = "0rr7yla1gl199hk2zn7jr1p0nq166mi4dm43ild27y6bvrdc2kvk";
+       libraryHaskellDepends = [
+         array base binary bytestring containers directory filepath mtl
+         parsec syb utf8-string
+       ];
+       homepage = "https://github.com/k-bx/protocol-buffers";
+       description = "Parse Google Protocol Buffer specifications";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "protocol-buffers-descriptor" = callPackage
     ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
      mkDerivation {
···
        homepage = "https://github.com/k-bx/protocol-buffers";
        description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "protocol-buffers-descriptor_2_4_10" = callPackage
+    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
+     mkDerivation {
+       pname = "protocol-buffers-descriptor";
+       version = "2.4.10";
+       sha256 = "1w4n0yqf5xhbs5yi0xj8ak268chngklc7sif2s3bjr0dwk7fi5d0";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring containers protocol-buffers
+       ];
+       homepage = "https://github.com/k-bx/protocol-buffers";
+       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "protocol-buffers-descriptor-fork" = callPackage
···
      , ansi-wl-pprint, base, base-compat, blaze-html, bower-json, boxes
      , bytestring, cheapskate, clock, containers, data-ordlist, deepseq
      , directory, dlist, edit-distance, file-embed, filepath, fsnotify
-     , gitrev, Glob, haskeline, hspec, hspec-discover, http-client
-     , http-types, HUnit, language-javascript, lens, lifted-base
-     , monad-control, monad-logger, mtl, network, optparse-applicative
-     , parallel, parsec, pattern-arrows, pipes, pipes-http, process
-     , protolude, regex-tdfa, safe, scientific, semigroups, silently
-     , sourcemap, spdx, split, stm, stringsearch, syb, text, time
-     , transformers, transformers-base, transformers-compat
-     , unordered-containers, utf8-string, vector, wai, wai-websockets
-     , warp, websockets
+     , gitrev, Glob, haskeline, hspec, hspec-discover, http-types, HUnit
+     , language-javascript, lens, lifted-base, monad-control
+     , monad-logger, mtl, network, optparse-applicative, parallel
+     , parsec, pattern-arrows, process, protolude, regex-tdfa, safe
+     , scientific, semigroups, sourcemap, spdx, split, stm, stringsearch
+     , syb, tasty, tasty-hspec, text, time, transformers
+     , transformers-base, transformers-compat, unordered-containers
+     , utf8-string, vector, wai, wai-websockets, warp, websockets
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.11.7";
-       sha256 = "1q6nzxchmwdqrx3bxx0k1h8a62iihz9kcfwybzhb9x13p9nbx9np";
+       version = "0.12.0";
+       sha256 = "0lkrlry4rr1l1c5ncy7wlbv1ll6n0dkw7j1gjpxn3706gan921rb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-better-errors ansi-terminal base base-compat blaze-html
          bower-json boxes bytestring cheapskate clock containers
          data-ordlist deepseq directory dlist edit-distance file-embed
-         filepath fsnotify Glob haskeline http-client http-types
-         language-javascript lens lifted-base monad-control monad-logger mtl
-         parallel parsec pattern-arrows pipes pipes-http process protolude
-         regex-tdfa safe scientific semigroups sourcemap spdx split stm
-         stringsearch syb text time transformers transformers-base
-         transformers-compat unordered-containers utf8-string vector
+         filepath fsnotify Glob haskeline language-javascript lens
+         lifted-base monad-control monad-logger mtl parallel parsec
+         pattern-arrows process protolude regex-tdfa safe scientific
+         semigroups sourcemap spdx split stm stringsearch syb text time
+         transformers transformers-base transformers-compat
+         unordered-containers utf8-string vector
        ];
        executableHaskellDepends = [
          aeson aeson-better-errors ansi-terminal ansi-wl-pprint base
          base-compat blaze-html bower-json boxes bytestring cheapskate clock
          containers data-ordlist deepseq directory dlist edit-distance
-         file-embed filepath fsnotify gitrev Glob haskeline http-client
-         http-types language-javascript lens lifted-base monad-control
-         monad-logger mtl network optparse-applicative parallel parsec
-         pattern-arrows pipes pipes-http process protolude regex-tdfa safe
-         scientific semigroups sourcemap spdx split stm stringsearch syb
-         text time transformers transformers-base transformers-compat
-         unordered-containers utf8-string vector wai wai-websockets warp
-         websockets
+         file-embed filepath fsnotify gitrev Glob haskeline http-types
+         language-javascript lens lifted-base monad-control monad-logger mtl
+         network optparse-applicative parallel parsec pattern-arrows process
+         protolude regex-tdfa safe scientific semigroups sourcemap spdx
+         split stm stringsearch syb text time transformers transformers-base
+         transformers-compat unordered-containers utf8-string vector wai
+         wai-websockets warp websockets
        ];
        testHaskellDepends = [
          aeson aeson-better-errors ansi-terminal base base-compat blaze-html
          bower-json boxes bytestring cheapskate clock containers
          data-ordlist deepseq directory dlist edit-distance file-embed
-         filepath fsnotify Glob haskeline hspec hspec-discover http-client
-         http-types HUnit language-javascript lens lifted-base monad-control
-         monad-logger mtl parallel parsec pattern-arrows pipes pipes-http
-         process protolude regex-tdfa safe scientific semigroups silently
-         sourcemap spdx split stm stringsearch syb text time transformers
-         transformers-base transformers-compat unordered-containers
-         utf8-string vector
+         filepath fsnotify Glob haskeline hspec hspec-discover HUnit
+         language-javascript lens lifted-base monad-control monad-logger mtl
+         parallel parsec pattern-arrows process protolude regex-tdfa safe
+         scientific semigroups sourcemap spdx split stm stringsearch syb
+         tasty tasty-hspec text time transformers transformers-base
+         transformers-compat unordered-containers utf8-string vector
        ];
        doCheck = false;
        homepage = "http://www.purescript.org/";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "rainbow_0_30_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, lens-simple, process, QuickCheck
+     , text
+     }:
+     mkDerivation {
+       pname = "rainbow";
+       version = "0.30.0.2";
+       sha256 = "1isy1xfgsp25x0254gmqkakc185g87wil3n19w5s1rn3bfq1w0my";
+       libraryHaskellDepends = [
+         base bytestring lens-simple process text
+       ];
+       testHaskellDepends = [
+         base bytestring lens-simple process QuickCheck text
+       ];
+       homepage = "https://www.github.com/massysett/rainbow";
+       description = "Print text to terminal with colors and effects";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "rainbow-tests" = callPackage
     ({ mkDerivation, barecheck, base, QuickCheck, rainbow, terminfo
      , text
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "range-set-list_0_1_2_1" = callPackage
+  "range-set-list_0_1_3" = callPackage
     ({ mkDerivation, base, containers, deepseq, hashable, tasty
      , tasty-quickcheck
      }:
      mkDerivation {
        pname = "range-set-list";
-       version = "0.1.2.1";
-       sha256 = "06f8z9rmk2phmds9wv95y2xvjhfx8dr9jbqlv4ybv8m21283x0kw";
+       version = "0.1.3";
+       sha256 = "1pwnriv5r093qvqzzg9s868613nf92d3h8qmqaqc5qq95hykj6z5";
        libraryHaskellDepends = [ base containers deepseq hashable ];
        testHaskellDepends = [
          base containers deepseq hashable tasty tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "rdf4h";
-       version = "3.0.3";
-       sha256 = "0lidqww0d8ckm4iipjx4gq32jspxidz0g009m5xrf8x6qsl26sx0";
+       version = "3.0.4";
+       sha256 = "0jci2d6n157y22ypsjb7kf4pknd53jjh2xj0i6qjsdh13qpwb7xq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, sdl2 }:
      mkDerivation {
        pname = "sdl2-fps";
-       version = "0.0.1";
-       sha256 = "0ci8p6qgs9nmpbypvk75ybz5kh36iiqaz4xl4lr2dbaq0y2d6iri";
+       version = "0.0.2";
+       sha256 = "0lid8c2fdy43i9qjjn60mzn6mrcfnn1jflmbwfl93gc6ab5fwz63";
        libraryHaskellDepends = [ base sdl2 ];
        homepage = "https://github.com/jxv/sdl2-fps#readme";
        description = "Run of the mill, frames per second timer implementation";
···
      }:
      mkDerivation {
        pname = "show-please";
-       version = "0.5.4";
-       sha256 = "0rb6mpbr1qz80zgs4r92ckp28afzlcz9l988y20xhfrvq3bikzkx";
+       version = "0.5.5";
+       sha256 = "00l2bm9507bcyafzyl6dh4ppvz34h4w7vglyd1gxr9piz2z708hx";
        libraryHaskellDepends = [
          base mtl parsec template-haskell th-orphans time
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "simple-log_0_9_4" = callPackage
+  "simple-log_0_9_5" = callPackage
     ({ mkDerivation, async, base, base-unicode-symbols, containers
      , data-default, deepseq, directory, exceptions, filepath, hformat
      , hspec, microlens, microlens-platform, mmorph, mtl, SafeSemaphore
···
      }:
      mkDerivation {
        pname = "simple-log";
-       version = "0.9.4";
-       sha256 = "0chp90h9112sxa7ds0ldzdp59i6b1vy7chkqcb6d5mb9faq6vjqi";
+       version = "0.9.5";
+       sha256 = "042mnsc2mfxdsf49knszk732mj5ryd9309h9ysyzb6z0y9wnp736";
        libraryHaskellDepends = [
          async base base-unicode-symbols containers data-default deepseq
          directory exceptions filepath hformat microlens microlens-platform
···
      }) {};
 
   "simpleconfig" = callPackage
-    ({ mkDerivation, base, containers, generic-deriving, lens, text }:
+    ({ mkDerivation, base, containers, either, generic-deriving, hspec
+     , lens, text
+     }:
      mkDerivation {
        pname = "simpleconfig";
-       version = "0.0.9";
-       sha256 = "1xk8kxdnw118gzwh3i58iy0bdqi80f8li3bjydaqfn073106nf87";
-       libraryHaskellDepends = [ base containers lens ];
+       version = "0.0.10";
+       sha256 = "0yrhgzwc138svs8p8pmlb1nbglhij3zi7228y32j9axzwmsszpg6";
+       libraryHaskellDepends = [ base containers either lens ];
        testHaskellDepends = [
-         base containers generic-deriving lens text
+         base containers either generic-deriving hspec lens text
        ];
        homepage = "https://github.com/koterpillar/simpleconfig#readme";
        description = "Short description of your package";
···
      }) {};
 
   "step-function" = callPackage
-    ({ mkDerivation, base, Cabal, cabal-test-quickcheck, QuickCheck }:
+    ({ mkDerivation, base, base-compat-batteries, containers, deepseq
+     , QuickCheck
+     }:
      mkDerivation {
        pname = "step-function";
-       version = "0.1.1.2";
-       sha256 = "1lsa84mc752lghpjszhwhky9hnpihy7wivdm0r6yl70k721s3ifk";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base Cabal cabal-test-quickcheck QuickCheck
+       version = "0.2";
+       sha256 = "1mg7zqqs32zdh1x1738kk0yydyksbhx3y3x8n31f7byk5fvzqq6j";
+       libraryHaskellDepends = [
+         base base-compat-batteries containers deepseq QuickCheck
        ];
+       testHaskellDepends = [ base QuickCheck ];
        homepage = "https://github.com/jonpetterbergman/step-function";
-       description = "Step functions, staircase functions or piecewise constant functions";
+       description = "Staircase functions or piecewise constant functions";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
     ({ mkDerivation, alsa-mixer, base, cairo, ConfigFile, containers
      , dbus, dbus-hslogger, directory, dyre, either, enclosed-exceptions
      , filepath, gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gdkx11, gi-glib
-     , gi-gtk, glib, gtk-sni-tray, gtk-strut, gtk-traymanager, gtk3
-     , haskell-gi, haskell-gi-base, hslogger, HStringTemplate, HTTP, mtl
-     , multimap, network, network-uri, old-locale, optparse-applicative
-     , parsec, process, rate-limit, regex-compat, safe, split
-     , status-notifier-item, stm, text, time, time-locale-compat
-     , time-units, transformers, transformers-base, tuple, unix
-     , utf8-string, X11, xdg-basedir, xml, xml-helpers, xmonad
-     , xmonad-contrib
+     , gi-gtk, gi-gtk-hs, glib, gtk-sni-tray, gtk-strut, gtk-traymanager
+     , gtk3, haskell-gi, haskell-gi-base, hslogger, HStringTemplate
+     , HTTP, multimap, network, network-uri, old-locale
+     , optparse-applicative, parsec, process, rate-limit, regex-compat
+     , safe, split, status-notifier-item, stm, template-haskell, text
+     , time, time-locale-compat, time-units, transformers
+     , transformers-base, tuple, unix, utf8-string, X11, xdg-basedir
+     , xml, xml-helpers, xmonad, xmonad-contrib
      }:
      mkDerivation {
        pname = "taffybar";
-       version = "2.0.0";
-       sha256 = "1s3nqvsivi4wgi6hi7b3f83r75sl5qp0hsqr0cdwd7s8fqai3wia";
-       revision = "1";
-       editedCabalFile = "1sqgzjv0nhp5nmzn4qh80ghq38p5q7c8nvm1v1wh1dx2j7lkjnzc";
+       version = "2.1.0";
+       sha256 = "1a32wpxjyimn08pmbwwx7crn97hg9wmlva5f0blkw4cwv090jhh8";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          alsa-mixer base cairo ConfigFile containers dbus dbus-hslogger
          directory dyre either enclosed-exceptions filepath gi-cairo gi-gdk
-         gi-gdkpixbuf gi-gdkx11 gi-glib gi-gtk glib gtk-sni-tray gtk-strut
-         gtk-traymanager gtk3 haskell-gi haskell-gi-base hslogger
-         HStringTemplate HTTP mtl multimap network network-uri old-locale
-         parsec process rate-limit regex-compat safe split
-         status-notifier-item stm text time time-locale-compat time-units
+         gi-gdkpixbuf gi-gdkx11 gi-glib gi-gtk gi-gtk-hs glib gtk-sni-tray
+         gtk-strut gtk-traymanager gtk3 haskell-gi haskell-gi-base hslogger
+         HStringTemplate HTTP multimap network network-uri old-locale parsec
+         process rate-limit regex-compat safe split status-notifier-item stm
+         template-haskell text time time-locale-compat time-units
          transformers transformers-base tuple unix utf8-string X11
          xdg-basedir xml xml-helpers xmonad xmonad-contrib
        ];
···
        pname = "tasty-hspec";
        version = "1.1.4";
        sha256 = "17f4rcga0qnynf1h047chwm5nicmik79lw04kiwpw48ahwc0zkp3";
+       revision = "2";
+       editedCabalFile = "1ijz75l5jhyxjk6hjrhbsw4470dxfdnwdwn9q3akxbmk095hpzjl";
        libraryHaskellDepends = [
          base hspec hspec-core QuickCheck tasty tasty-quickcheck
          tasty-smallcheck
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "texmath_0_11" = callPackage
+  "texmath_0_11_0_1" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , mtl, pandoc-types, parsec, process, split, syb, temporary, text
      , utf8-string, xml
      }:
      mkDerivation {
        pname = "texmath";
-       version = "0.11";
-       sha256 = "1sssa9ld13bhs4b6cpv5mwf18bjajr8fgw32g4wp2smgv9p2jv9f";
+       version = "0.11.0.1";
+       sha256 = "11dc09hfnyfsz20ch2c867w0zdgjkzq41506lm61i3dk87ngdisf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        homepage = "https://github.com/mvoidex/text-region";
        description = "Marking text regions";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "text-region_0_3_1_0" = callPackage
+    ({ mkDerivation, aeson, base, base-unicode-symbols, bytestring
+     , groups, hspec, lens, text
+     }:
+     mkDerivation {
+       pname = "text-region";
+       version = "0.3.1.0";
+       sha256 = "1zy5zb7xg1343hlkwawnbca7f6gal9028ps1kp83fg2vmq1aqk57";
+       libraryHaskellDepends = [
+         aeson base base-unicode-symbols bytestring groups lens text
+       ];
+       testHaskellDepends = [ base base-unicode-symbols hspec lens text ];
+       homepage = "https://github.com/mvoidex/text-region";
+       description = "Marking text regions";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "text-register-machine" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "uri-bytestring_0_3_2_0" = callPackage
+    ({ mkDerivation, attoparsec, base, base-compat, blaze-builder
+     , bytestring, containers, criterion, deepseq, deepseq-generics
+     , generics-sop, HUnit, network-uri, QuickCheck
+     , quickcheck-instances, semigroups, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, th-lift-instances
+     , transformers
+     }:
+     mkDerivation {
+       pname = "uri-bytestring";
+       version = "0.3.2.0";
+       sha256 = "1q04j5ybvk37zk2m0bkjwyhblz0ymdj0cn4rvsvdca1ikn5xdv5c";
+       libraryHaskellDepends = [
+         attoparsec base blaze-builder bytestring containers
+         template-haskell th-lift-instances
+       ];
+       testHaskellDepends = [
+         attoparsec base base-compat blaze-builder bytestring containers
+         generics-sop HUnit QuickCheck quickcheck-instances semigroups tasty
+         tasty-hunit tasty-quickcheck transformers
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-builder bytestring criterion deepseq deepseq-generics
+         network-uri
+       ];
+       homepage = "https://github.com/Soostone/uri-bytestring";
+       description = "Haskell URI parsing as ByteStrings";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "uri-bytestring-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, text, uri-bytestring }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "wai-middleware-travisci" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , cryptonite, http-types, text, transformers, vault, wai
+     }:
+     mkDerivation {
+       pname = "wai-middleware-travisci";
+       version = "0.1.0";
+       sha256 = "0a58mlgimr6137aiwcdxjk15zy3y58dds4zxffd3vvn0lkzg5jdv";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring cryptonite http-types text
+         transformers vault wai
+       ];
+       homepage = "https://github.com/mitchellwrosen/wai-middleware-travisci";
+       description = "WAI middleware for authenticating webhook payloads from Travis CI";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "wai-middleware-verbs" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, hashable, http-types
      , mmorph, monad-control, monad-control-aligned, monad-logger, mtl
···
      }:
      mkDerivation {
        pname = "xmlbf";
-       version = "0.4";
-       sha256 = "1f63ibvv7ywly7paam238y4bjhvg7jmn87368dnv5lsz28mq432m";
+       version = "0.4.1";
+       sha256 = "0xfw9z1l3ja4qq0lj9i2n81fdh43ggprsy8rm71pcdacnpl056hq";
        libraryHaskellDepends = [
          base bytestring containers text transformers unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "xmonad-vanessa";
-       version = "0.1.1.8";
-       sha256 = "17w7hj4bgz1xkirj9dwgkbif4vpqvjnp5g2dvjna7qg5rw2hk3zj";
+       version = "0.2.0.1";
+       sha256 = "1rha8aw6pq9pdxznmr1i3q6jh1a7i88kr6arcnihhd21qp6vxz17";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      , data-default, directory, exceptions, fast-logger, monad-control
      , monad-logger, mtl, persistent, persistent-sqlite, random
      , resource-pool, resourcet, string-conversions, text, time
-     , transformers, unordered-containers, wai-logger, yaml
+     , transformers, unliftio-core, unordered-containers, wai-logger
+     , yaml
      }:
      mkDerivation {
        pname = "yam-app";
-       version = "0.1.11";
-       sha256 = "0qbc7s5l030yilq8zlq5hszk6hgqjxp6yablap1ykm2211wipbq3";
+       version = "0.2.0";
+       sha256 = "1fr3q4dih2vzby3jmb13zmi6cmmlp26gymx45pqb2g5fsg2nmp94";
        libraryHaskellDepends = [
          aeson base conduit containers ctrie data-default directory
          exceptions fast-logger monad-control monad-logger mtl persistent
          persistent-sqlite random resource-pool resourcet string-conversions
-         text time transformers unordered-containers wai-logger yaml
+         text time transformers unliftio-core unordered-containers
+         wai-logger yaml
        ];
        homepage = "https://github.com/leptonyu/yam/tree/master/yam-app#readme";
        description = "Yam App";
···
     ({ mkDerivation, base, cron, yam-app }:
      mkDerivation {
        pname = "yam-job";
-       version = "0.1.11";
-       sha256 = "0hs46q1xwwx44f4zxhs4245cdnr9g4r2a67cm191n1wd86sfhrpc";
+       version = "0.2.0";
+       sha256 = "0c6frqjf3xhd5bksaz6rvd6qbqbj15y441476dgj2asm2yd64895";
        libraryHaskellDepends = [ base cron yam-app ];
        homepage = "https://github.com/leptonyu/yam/tree/master/yam-job#readme";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "yam-servant";
-       version = "0.1.11";
-       sha256 = "0z1my2jgcbvdx4v5zh66yw99vnck5rbi54s6adbp26v4szc8j40s";
+       version = "0.2.0";
+       sha256 = "0y1isi6c0pv87hygbbb2xfh4373bij1cig2hrpcq4ivyab0273xb";
        libraryHaskellDepends = [
          aeson base http-types lens servant servant-server servant-swagger
          servant-swagger-ui swagger2 text wai wai-extra warp yam-app yam-job
···
      }) {};
 
   "yam-transaction-postgresql" = callPackage
-    ({ mkDerivation, base, containers, persistent-postgresql, yam-app
+    ({ mkDerivation, base, containers, persistent-postgresql
+     , unliftio-core, yam-app
      }:
      mkDerivation {
        pname = "yam-transaction-postgresql";
-       version = "0.1.11";
-       sha256 = "1li9vmnnj9xw1j60gmjym9rxlljjic9w7bkxip22yhb6qnmidpc9";
+       version = "0.2.0";
+       sha256 = "1nm2bs285ldxv3zqsihha1wl1p46i8gd7w5nk2nnk60qilzhsc9s";
        libraryHaskellDepends = [
-         base containers persistent-postgresql yam-app
+         base containers persistent-postgresql unliftio-core yam-app
        ];
        homepage = "https://github.com/leptonyu/yam/tree/master/yam-transaction-postgresql#readme";
        license = stdenv.lib.licenses.bsd3;

pkgs/development/haskell-modules/lib.nix

···
   # This is useful to build environments for developing on that
   # package.
   getHaskellBuildInputs = p:
-    (p.override { mkDerivation = extractBuildInputs p.compiler;
-                }).haskellBuildInputs;
+    (overrideCabal p (args: {
+      passthru = (args.passthru or {}) // {
+        _getHaskellBuildInputs = extractBuildInputs p.compiler args;
+      };
+    }))._getHaskellBuildInputs;
 
   # Under normal evaluation, simply return the original package. Under
   # nix-shell evaluation, return a nix-shell optimized environment.

pkgs/development/haskell-modules/make-package-set.nix

···
   inherit (stdenv) buildPlatform hostPlatform;
 
   inherit (stdenv.lib) fix' extends makeOverridable;
-  inherit (haskellLib) overrideCabal;
+  inherit (haskellLib) overrideCabal getHaskellBuildInputs;
 
   mkDerivationImpl = pkgs.callPackage ./generic-builder.nix {
     inherit stdenv;
···
     shellFor = { packages, withHoogle ? false, ... } @ args:
       let
         selected = packages self;
-        packageInputs = builtins.map (p: p.override { mkDerivation = haskellLib.extractBuildInputs p.compiler; }) selected;
+        packageInputs = builtins.map getHaskellBuildInputs selected;
         haskellInputs =
           builtins.filter
             (input: pkgs.lib.all (p: input.outPath != p.outPath) selected)

pkgs/development/interpreters/spidermonkey/38.nix

···
-{ stdenv, fetchurl, pkgconfig, gnused_422, perl, python2, zip, libffi, readline, icu, zlib, nspr }:
+{ stdenv, fetchurl, pkgconfig, gnused_422, perl, python2, zip, libffi, readline, icu, zlib, nspr
+, libobjc }:
 
 stdenv.mkDerivation rec {
   version = "38.2.1.rc0";
···
     sha256 = "0p4bmbpgkfsj54xschcny0a118jdrdgg0q29rwxigg3lh5slr681";
   };
 
-  buildInputs = [ libffi readline icu zlib nspr ];
+  buildInputs = [ libffi readline icu zlib nspr ]
+               ++ stdenv.lib.optional stdenv.isDarwin libobjc;
   nativeBuildInputs = [ pkgconfig perl python2 zip gnused_422 ];
 
   postUnpack = "sourceRoot=\${sourceRoot}/js/src";
···
     # TODO: MPL/GPL/LGPL tri-license.
 
     maintainers = [ maintainers.abbradar ];
-    platforms = platforms.linux;
+    platforms = platforms.unix;
   };
 }

pkgs/development/libraries/enet/default.nix

···
     description = "Simple and robust network communication layer on top of UDP";
     license = stdenv.lib.licenses.mit;
     maintainers = with stdenv.lib.maintainers; [ fuuzetsu ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = stdenv.lib.platforms.unix;
   };
 }

pkgs/development/libraries/nvidia-texture-tools/default.nix

···
     description = "A set of cuda-enabled texture tools and compressors";
     homepage = https://github.com/castano/nvidia-texture-tools;
     license = licenses.mit;
-    platforms = platforms.linux;
+    platforms = platforms.unix;
   };
 }

pkgs/development/libraries/oracle-instantclient/default.nix

···
-{ stdenv, requireFile, glibc, patchelf, rpmextract, libaio, makeWrapper, odbcSupport ? false, unixODBC }:
+{ stdenv, requireFile, autoPatchelfHook, rpmextract, libaio, makeWrapper, odbcSupport ? false, unixODBC }:
 
 assert odbcSupport -> unixODBC != null;
-
-with stdenv.lib;
 
 let
     baseVersion = "12.2";
···
   version = "${baseVersion}.0.1.0";
   name = "oracle-instantclient-${version}";
 
-  srcBase = (requireSource version "1" "basic" "43c4bfa938af741ae0f9964a656f36a0700849f5780a2887c8e9f1be14fe8b66");
-  srcDevel = (requireSource version "1" "devel" "4c7ad8d977f9f908e47c5e71ce56c2a40c7dc83cec8a5c106b9ff06d45bb3442");
-  srcSqlplus = (requireSource version "1" "sqlplus" "303e82820a10f78e401e2b07d4eebf98b25029454d79f06c46e5f9a302ce5552");
-  srcOdbc = optionalString odbcSupport (requireSource version "2" "odbc" "e870c84d2d4be6f77c0760083b82b7ffbb15a4bf5c93c4e6c84f36d6ed4dfdf1");
+  buildInputs = [ libaio stdenv.cc.cc.lib ] ++ stdenv.lib.optional odbcSupport unixODBC;
+  nativeBuildInputs = [ autoPatchelfHook makeWrapper rpmextract ];
 
-  buildInputs = [ glibc ] ++
-    optional odbcSupport unixODBC;
+  srcs = [
+    (requireSource version "1" "basic" "43c4bfa938af741ae0f9964a656f36a0700849f5780a2887c8e9f1be14fe8b66")
+    (requireSource version "1" "devel" "4c7ad8d977f9f908e47c5e71ce56c2a40c7dc83cec8a5c106b9ff06d45bb3442")
+    (requireSource version "1" "sqlplus" "303e82820a10f78e401e2b07d4eebf98b25029454d79f06c46e5f9a302ce5552")
+  ] ++ stdenv.lib.optional odbcSupport (requireSource version "2" "odbc" "e870c84d2d4be6f77c0760083b82b7ffbb15a4bf5c93c4e6c84f36d6ed4dfdf1");
 
-  nativeBuildInputs = [ rpmextract patchelf makeWrapper ];
+  unpackCmd = "rpmextract $curSrc";
 
-  buildCommand = ''
-    mkdir -p "${name}"
-    cd "${name}"
-    ${rpmextract}/bin/rpmextract "${srcBase}"
-    ${rpmextract}/bin/rpmextract "${srcDevel}"
-    ${rpmextract}/bin/rpmextract "${srcSqlplus}"
-    '' + optionalString odbcSupport ''${rpmextract}/bin/rpmextract ${srcOdbc}
-    '' + ''
+  installPhase = ''
     mkdir -p "$out/"{bin,include,lib,"share/${name}/demo/"}
-    mv "usr/share/oracle/${baseVersion}/client64/demo/"* "$out/share/${name}/demo/"
-    mv "usr/include/oracle/${baseVersion}/client64/"* "$out/include/"
-    mv "usr/lib/oracle/${baseVersion}/client64/lib/"* "$out/lib/"
-    mv "usr/lib/oracle/${baseVersion}/client64/bin/"* "$out/bin/"
-    ln -s "$out/bin/sqlplus" "$out/bin/sqlplus64"
 
-    for lib in $out/lib/lib*.so; do
-      test -f $lib || continue
-      chmod +x $lib
-      patchelf --force-rpath --set-rpath "$out/lib:${libaio}/lib" \
-               $lib
-    done
-
-    for lib in $out/lib/libsqora*; do
-      test -f $lib || continue
-      chmod +x $lib
-      patchelf --force-rpath --set-rpath "$out/lib:${unixODBC}/lib" \
-               $lib
-    done
-
-    for exe in $out/bin/{adrci,genezi,sqlplus}; do
-      patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
-               --force-rpath --set-rpath "$out/lib:${libaio}/lib" \
-               $exe
-      wrapProgram $exe --prefix LD_LIBRARY_PATH ":" $out/lib
-    done
+    install -Dm755 lib/oracle/${baseVersion}/client64/bin/* $out/bin
+    ln -s $out/bin/sqlplus $out/bin/sqlplus64
+    install -Dm644 lib/oracle/${baseVersion}/client64/lib/* $out/lib
+    install -Dm644 include/oracle/${baseVersion}/client64/* $out/include
+    install -Dm644 share/oracle/${baseVersion}/client64/demo/* $out/share/${name}/demo
   '';
-
-  dontStrip = true;
-  dontPatchELF = true;
 
   meta = with stdenv.lib; {
     description = "Oracle instant client libraries and sqlplus CLI";
···
     '';
     license = licenses.unfree;
     platforms = [ "x86_64-linux" ];
-    maintainers = with maintainers; [ pesterhazy ];
+    maintainers = with maintainers; [ pesterhazy flokli ];
+    hydraPlatforms = [];
   };
 }

pkgs/development/libraries/sfml/default.nix

···
 { stdenv, fetchurl, cmake, libX11, freetype, libjpeg, openal, flac, libvorbis
 , glew, libXrandr, libXrender, udev, xcbutilimage
+, IOKit, Foundation, AppKit, OpenAL
 }:
 
 let
···
     sha256 = "1x3yvhdrln5b6h4g5r4mds76gq8zsxw6icxqpwqkmxsqcq5yviab";
   };
   buildInputs = [ cmake libX11 freetype libjpeg openal flac libvorbis glew
-                  libXrandr libXrender udev xcbutilimage
-                ];
-  cmakeFlags = [ "-DSFML_INSTALL_PKGCONFIG_FILES=yes" ];
+                  libXrandr libXrender xcbutilimage
+                ] ++ stdenv.lib.optional stdenv.isLinux udev
+                  ++ stdenv.lib.optionals stdenv.isDarwin [ IOKit Foundation AppKit OpenAL ];
+  cmakeFlags = [ "-DSFML_INSTALL_PKGCONFIG_FILES=yes"
+                 "-DSFML_MISC_INSTALL_PREFIX=share/SFML"
+                 "-DSFML_BUILD_FRAMEWORKS=no"
+                 "-DSFML_USE_SYSTEM_DEPS=yes" ];
   meta = with stdenv.lib; {
     homepage = http://www.sfml-dev.org/;
     description = "Simple and fast multimedia library";
···
     '';
     license = licenses.zlib;
     maintainers = [ maintainers.astsmtl ];
-    platforms = platforms.linux;
+    platforms = platforms.unix;
   };
 }

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

···
+{ lib, buildPythonPackage, isPy3k, fetchFromGitHub, requests
+, requests-mock, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "pyairvisual";
+  version = "1.0.0";
+
+  src = fetchFromGitHub {
+    owner = "bachya";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0ng6k07n91k5l68zk3hl4fywb33admp84wqdm20qmmw9yc9c64fd";
+  };
+
+  checkInputs = [ pytest requests-mock ];
+  propagatedBuildInputs = [ requests ];
+
+  checkPhase = ''
+    py.test tests
+  '';
+
+  disabled = !isPy3k;
+
+  meta = with lib; {
+    description = "A thin Python wrapper for the AirVisual API";
+    license = licenses.mit;
+    homepage = https://github.com/bachya/pyairvisual;
+  };
+}

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

···
-{ stdenv, buildPythonPackage, isPy3k, fetchFromGitHub }:
+{ stdenv, buildPythonPackage, isPy3k, fetchPypi }:
 
 buildPythonPackage rec {
   pname = "pyhomematic";
-  version = "0.1.42";
+  version = "0.1.43";
 
   disabled = !isPy3k;
 
-  # PyPI tarball does not include tests/ directory
-  src = fetchFromGitHub {
-    owner = "danielperna84";
-    repo = pname;
-    rev = version;
-    sha256 = "0h7bq66q22kzj1xwhxmr7knibsmb4csjwq3jr19fyl9sxxmgqwqy";
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0b6f4f5c8ddca15e0a1df367bafdffb2f08f1e42f17c78b9470573287e5b20bc";
   };
 
+  # PyPI tarball does not include tests/ directory
   # Unreliable timing: https://github.com/danielperna84/pyhomematic/issues/126
   doCheck = false;
 

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

···
+{ stdenv, lib, fetchPypi, buildPythonPackage, fetchurl, libvorbis, flac, libogg, libopus, opusfile }:
+
+buildPythonPackage rec {
+    pname = "PyOgg";
+    version = "0.6.2a1";
+
+    src = fetchPypi {
+      inherit pname version;
+      sha256 = "1mjh5zx7mfy246lya1qc42j4q4pz6v5zbd8blnfib9ncswcb1v6l";
+    };
+
+    buildInputs = [ libvorbis flac libogg libopus ];
+    propagatedBuidInputs = [ libvorbis flac libogg libopus opusfile ];
+    # There are no tests in this package.
+    doCheck = false;
+    postPatch = ''
+      substituteInPlace pyogg/vorbis.py --replace \
+        'libvorbisfile = ExternalLibrary.load("vorbisfile")' "libvorbisfile = ctypes.CDLL('${libvorbis}/lib/libvorbisfile${stdenv.hostPlatform.extensions.sharedLibrary}')"
+      substituteInPlace pyogg/vorbis.py --replace \
+        'libvorbisenc = ExternalLibrary.load("vorbisenc")' "libvorbisenc = ctypes.CDLL('${libvorbis}/lib/libvorbisenc${stdenv.hostPlatform.extensions.sharedLibrary}')"
+      substituteInPlace pyogg/vorbis.py --replace \
+        'libvorbis = ExternalLibrary.load("vorbis")' "libvorbis = ctypes.CDLL('${libvorbis}/lib/libvorbis${stdenv.hostPlatform.extensions.sharedLibrary}')"
+      substituteInPlace pyogg/flac.py --replace \
+        'libflac = ExternalLibrary.load("flac")' "libflac = ctypes.CDLL('${flac.out}/lib/libFLAC${stdenv.hostPlatform.extensions.sharedLibrary}')"
+      substituteInPlace pyogg/ogg.py --replace \
+        'libogg = ExternalLibrary.load("ogg")' "libogg = ctypes.CDLL('${libogg}/lib/libogg${stdenv.hostPlatform.extensions.sharedLibrary}')"
+      substituteInPlace pyogg/opus.py --replace \
+        'libopus = ExternalLibrary.load("opus")' "libopus = ctypes.CDLL('${libopus}/lib/libopus${stdenv.hostPlatform.extensions.sharedLibrary}')"
+      substituteInPlace pyogg/opus.py --replace \
+        'libopusfile = ExternalLibrary.load("opusfile")' "libopusfile = ctypes.CDLL('${opusfile}/lib/libopusfile${stdenv.hostPlatform.extensions.sharedLibrary}')"
+    '';
+
+  meta = {
+    description = "Xiph.org's Ogg Vorbis, Opus and FLAC for Python";
+    homepage = https://github.com/Zuzu-Typ/PyOgg;
+    license = lib.licenses.publicDomain;
+    maintainers = with lib.maintainers; [ pmiddend ];
+  };
+}

pkgs/development/python-modules/timeout-decorator/default.nix

···
+{ stdenv, buildPythonPackage, fetchPypi }:
+buildPythonPackage rec {
+  pname = "timeout-decorator";
+  version = "0.4.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1bckwbi5078z3x9lyf8vl9dhx10nymwwnp46c98wm5m02x5j37g4";
+  };
+
+  meta = with stdenv.lib; {
+    description = "Timeout decorator";
+    license = licenses.mit;
+    homepage = https://github.com/pnpnpn/timeout-decorator;
+  };
+}

pkgs/development/tools/ammonite/default.nix

···
-{ stdenv, lib, fetchurl, makeWrapper, jre
+{ stdenv, lib, fetchurl, makeWrapper, jre, gnused
 , disableRemoteLogging ? true
 }:
 
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "ammonite-${version}";
-  version = "1.1.0";
+  version = "1.1.2";
   scalaVersion = "2.12";
 
   src = fetchurl {
     url = "https://github.com/lihaoyi/Ammonite/releases/download/${version}/${scalaVersion}-${version}";
-    sha256 = "0dx5w1ffnqazsyp6zxrmfcn7yhkkd81h7njwbqqv1pbchj5znj6l";
+    sha256 = "1balr7ya7xlyq32jwb0w9c4klnw13mdn2c5azkwngq5cp29yrfrc";
   };
 
   propagatedBuildInputs = [ jre ] ;
-  buildInputs = [ makeWrapper ] ;
+  buildInputs = [ makeWrapper gnused ] ;
 
   phases = "installPhase";
 
···
     mkdir -p $out/bin
     cp ${src} $out/bin/amm
     chmod +x $out/bin/amm
-    wrapProgram $out/bin/amm \
-      ${optionalString disableRemoteLogging "--add-flags --no-remote-logging"} \
-      --prefix PATH ":" ${jre}/bin ;
+    ${gnused}/bin/sed -i '0,/java/{s|java|${jre}/bin/java|}' $out/bin/amm
+  '' + optionalString (disableRemoteLogging) ''
+    ${gnused}/bin/sed -i '0,/ammonite.Main/{s|ammonite.Main|ammonite.Main --no-remote-logging|}' $out/bin/amm
   '';
 
   meta = {

pkgs/development/tools/build-managers/apache-maven/default.nix

···
 
 assert jdk != null;
 
-let version = "3.5.2"; in
+let version = "3.5.3"; in
 stdenv.mkDerivation rec {
   name = "apache-maven-${version}";
 
···
 
   src = fetchurl {
     url = "mirror://apache/maven/maven-3/${version}/binaries/${name}-bin.tar.gz";
-    sha256 = "1zza5kjf69hnx41gy3yhvsk1kz259nig5njcmzjbsr8a75p1yyvh";
+    sha256 = "0244mpziz4rw35x2cahsqlxpnygvi6qpll16g4kx87db7wvmcadm";
   };
 
   buildInputs = [ makeWrapper ];

pkgs/games/freeciv/default.nix

···
 let
   inherit (stdenv.lib) optional optionals;
 
-  sdlName = if sdlClient then "-sdl" else "";
-  gtkName = if gtkClient then "-gtk" else "";
-
   name = "freeciv";
   version = "2.5.11";
 in
 stdenv.mkDerivation {
-  name = "${name}${sdlName}${gtkName}-${version}";
+  name = "${name}-${version}";
   inherit version;
 
   src = fetchurl {

pkgs/misc/emulators/retroarch/cores.nix

···
       COREDIR="$out/lib/retroarch/cores"
       mkdir -p $out/bin
       mkdir -p $COREDIR
-      mv ${d2u core}_libretro.so $COREDIR/.
+      mv ${d2u core}_libretro${stdenv.hostPlatform.extensions.sharedLibrary} $COREDIR/.
       makeWrapper ${retroarch}/bin/retroarch $out/bin/retroarch-${core} \
-        --add-flags "-L $COREDIR/${d2u core}_libretro.so $@"
+        --add-flags "-L $COREDIR/${d2u core}_libretro${stdenv.hostPlatform.extensions.sharedLibrary} $@"
     '';
 
     enableParallelBuilding = true;
···
       homepage = https://www.libretro.com/;
       inherit license;
       maintainers = with maintainers; [ edwtjo hrdinka MP2E ];
-      platforms = platforms.linux;
+      platforms = platforms.unix;
     };
   } // a);
 
···
     buildPhase = ''
       cd svn-current/trunk \
       && make -f makefile.libretro \
-      && mv fbalpha2012_libretro.so fba_libretro.so
+      && mv fbalpha2012_libretro${stdenv.hostPlatform.extensions.sharedLibrary} fba_libretro${stdenv.hostPlatform.extensions.sharedLibrary}
     '';
   };
 
···
   }).override {
     buildPhase = ''
       make -f Makefile.libretro
-      mv snes9x2010_libretro.so snes9x_next_libretro.so
+      mv snes9x2010_libretro${stdenv.hostPlatform.extensions.sharedLibrary} snes9x_next_libretro${stdenv.hostPlatform.extensions.sharedLibrary}
     '';
   };
 

pkgs/misc/emulators/retroarch/wrapper.nix

···
     mkdir -p $out/lib
     $(for coreDir in $cores
     do
-      $(ln -s $coreDir/*.so $out/lib/.)
+      $(ln -s $coreDir/* $out/lib/.)
     done)
 
     ln -s -t $out ${retroarch}/share

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

···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ libnl openssl sqlite ];
 
+  outputs = [ "out" "man" ];
+
   extraConfig = ''
     CONFIG_DRIVER_WIRED=y
     CONFIG_LIBNL32=y
···
   '';
 
   preInstall = "mkdir -p $out/bin";
+  postInstall = ''
+    install -vD hostapd.8 -t $man/share/man/man8
+    install -vD hostapd_cli.1 -t $man/share/man/man1
+  '';
 
   meta = {
     homepage = http://hostap.epitest.fi;

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

···
 
 stdenv.mkDerivation rec {
   name = "wireguard-${version}";
-  version = "0.0.20180514";
-
-  inherit (wireguard-tools) src;
+  inherit (wireguard-tools) src version;
 
   preConfigure = ''
     cd src
···
   meta = with stdenv.lib; {
     homepage     = https://www.wireguard.com/;
     downloadPage = https://git.zx2c4.com/WireGuard/refs/;
-    description  = " Tools for the WireGuard secure network tunnel";
+    description  = "Kernel module for the WireGuard secure network tunnel";
     maintainers  = with maintainers; [ ericsagnes mic92 zx2c4 ];
     license      = licenses.gpl2;
     platforms    = platforms.linux;

pkgs/servers/home-assistant/component-packages.nix

···
     "lutron_caseta" = ps: with ps; [  ];
     "matrix" = ps: with ps; [ matrix-client ];
     "maxcube" = ps: with ps; [  ];
-    "media_extractor" = ps: with ps; [  ];
+    "media_extractor" = ps: with ps; [ youtube-dl-light ];
     "media_player.anthemav" = ps: with ps; [  ];
     "media_player.aquostv" = ps: with ps; [  ];
     "media_player.blackbird" = ps: with ps; [  ];
···
     "satel_integra" = ps: with ps; [  ];
     "scene.hunterdouglas_powerview" = ps: with ps; [  ];
     "scsgate" = ps: with ps; [  ];
-    "sensor.airvisual" = ps: with ps; [  ];
+    "sensor.airvisual" = ps: with ps; [ pyairvisual ];
     "sensor.alpha_vantage" = ps: with ps; [  ];
     "sensor.bbox" = ps: with ps; [  ];
     "sensor.bh1750" = ps: with ps; [  ];

pkgs/servers/home-assistant/parse-requirements.py

···
 COMPONENT_PREFIX = GENERAL_PREFIX + 'components.'
 PKG_SET = 'python3Packages'
 
+# If some requirements are matched by multiple python packages,
+# the following can be used to choose one of them
+PKG_PREFERENCES = {
+    # Use python3Packages.youtube-dl-light instead of python3Packages.youtube-dl
+    'youtube-dl': 'youtube-dl-light'
+}
+
 def get_version():
     with open(os.path.dirname(sys.argv[0]) + '/default.nix') as f:
         m = re.search('hassVersion = "([\\d\\.]+)";', f.read())
···
 packages = json.loads(output)
 
 def name_to_attr_path(req):
-    attr_paths = []
+    attr_paths = set()
     names = [req]
     # E.g. python-mpd2 is actually called python3.6-mpd2
     # instead of python-3.6-python-mpd2 inside Nixpkgs
···
         pattern = re.compile('^python\\d\\.\\d-{}-\\d'.format(name), re.I)
         for attr_path, package in packages.items():
             if pattern.match(package['name']):
-                attr_paths.append(attr_path)
+                attr_paths.add(attr_path)
+    if len(attr_paths) > 1:
+        for to_replace, replacement in PKG_PREFERENCES.items():
+            try:
+                attr_paths.remove(PKG_SET + '.' + to_replace)
+                attr_paths.add(PKG_SET + '.' + replacement)
+            except KeyError:
+                pass
     # Let's hope there's only one derivation with a matching name
     assert(len(attr_paths) <= 1)
-    if attr_paths:
-        return attr_paths[0]
+    if len(attr_paths) == 1:
+        return attr_paths.pop()
     else:
         return None
 
···
 for component, reqs in OrderedDict(sorted(requirements.items())).items():
     attr_paths = []
     for req in reqs:
-        try:
-            name = req.split('==')[0]
-            attr_path = name_to_attr_path(name)
-            if attr_path is not None:
-                # Add attribute path without "python3Packages." prefix
-                attr_paths.append(attr_path[len(PKG_SET + '.'):])
-        except RequirementParseError:
-            continue
+        name = req.split('==')[0]
+        attr_path = name_to_attr_path(name)
+        if attr_path is not None:
+            # Add attribute path without "python3Packages." prefix
+            attr_paths.append(attr_path[len(PKG_SET + '.'):])
     else:
         build_inputs[component] = attr_paths
 

pkgs/servers/nosql/eventstore/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "EventStore-${version}";
-  version = "4.1.0";
+  version = "4.1.1";
   src = fetchFromGitHub {
     owner  = "EventStore";
     repo   = "EventStore";
     rev    = "oss-v${version}";
-    sha256 = "0mvjz327kfg157fwvy8xkkf5h0g3v373pfwr70cslsy96n45jp10";
+    sha256 = "1069ncb9ps1wi71yw1fzkfd9rfsavccw8xj3a3miwd9x72w8636f";
   };
 
   buildPhase = ''

pkgs/tools/misc/autojump/default.nix

···
-{ fetchurl, stdenv, python, bash }:
+{ stdenv, fetchFromGitHub, python, bash }:
 
-let
+stdenv.mkDerivation rec {
+  name = "autojump-${version}";
   version = "22.5.1";
-in
-  stdenv.mkDerivation rec {
-    name = "autojump-${version}";
 
-    src = fetchurl {
-      url = "http://github.com/joelthelion/autojump/archive/release-v${version}.tar.gz";
-      name = "autojump-${version}.tar.gz";
-      sha256 = "17z9j9936x0nizwrzf664bngh60x5qbvrrf1s5qdzd0f2gdanpvn";
-    };
+  src = fetchFromGitHub {
+    owner = "wting";
+    repo = "autojump";
+    rev = "release-v${version}";
+    sha256 = "1l1278g3k1qfrz41pkpjdhsabassb9si2d1bfbcmvbv5h3wmlqk9";
+  };
 
-    buildInputs = [ python bash ];
-    dontBuild = true;
+  buildInputs = [ python bash ];
+  dontBuild = true;
 
-    installPhase = ''
-      python ./install.py -d $out -p ""
-      chmod +x $out/etc/profile.d/*
+  installPhase = ''
+    python ./install.py -d "$out" -p "" -z "$out/share/zsh/site-functions/"
+
+    chmod +x "$out/etc/profile.d/autojump.sh"
+    install -Dt "$out/share/bash-completion/completions/" -m444 "$out/share/autojump/autojump.bash"
+    install -Dt "$out/share/fish/vendor_conf.d/" -m444 "$out/share/autojump/autojump.fish"
+    install -Dt "$out/share/zsh/site-functions/" -m444 "$out/share/autojump/autojump.zsh"
+  '';
 
-      mkdir -p "$out/etc/bash_completion.d"
-      cp -v $out/share/autojump/autojump.bash "$out/etc/bash_completion.d"
+  meta = with stdenv.lib; {
+    description = "A `cd' command that learns";
+    longDescription = ''
+      One of the most used shell commands is “cd”.  A quick survey
+      among my friends revealed that between 10 and 20% of all
+      commands they type are actually cd commands! Unfortunately,
+      jumping from one part of your system to another with cd
+      requires to enter almost the full path, which isn’t very
+      practical and requires a lot of keystrokes.
 
-      mkdir -p $out/share/fish/vendor_completions.d/
-      cp -v $out/share/autojump/autojump.fish "$out/share/fish/vendor_completions.d/autojump.fish"
+      Autojump is a faster way to navigate your filesystem.  It
+      works by maintaining a database of the directories you use the
+      most from the command line.  The jstat command shows you the
+      current contents of the database.  You need to work a little
+      bit before the database becomes usable.  Once your database
+      is reasonably complete, you can “jump” to a directory by
+      typing "j dirspec", where dirspec is a few characters of the
+      directory you want to jump to.  It will jump to the most used
+      directory whose name matches the pattern given in dirspec.
 
-      cat <<SCRIPT > $out/bin/autojump-share
-      #!/bin/sh
-      # Run this script to find the autojump shared folder where all the shell
-      # integration scripts are living.
-      echo $out/share/autojump
-      SCRIPT
-      chmod +x $out/bin/autojump-share
+      Autojump supports tab-completion.
     '';
-
-    meta = {
-      description = "A `cd' command that learns";
-      longDescription = ''
-        One of the most used shell commands is “cd”.  A quick survey
-        among my friends revealed that between 10 and 20% of all
-        commands they type are actually cd commands! Unfortunately,
-        jumping from one part of your system to another with cd
-        requires to enter almost the full path, which isn’t very
-        practical and requires a lot of keystrokes.
-
-        Autojump is a faster way to navigate your filesystem.  It
-        works by maintaining a database of the directories you use the
-        most from the command line.  The jstat command shows you the
-        current contents of the database.  You need to work a little
-        bit before the database becomes usable.  Once your database
-        is reasonably complete, you can “jump” to a directory by
-        typing "j dirspec", where dirspec is a few characters of the
-        directory you want to jump to.  It will jump to the most used
-        directory whose name matches the pattern given in dirspec.
-
-        Autojump supports tab-completion.
-      '';
-      homepage = http://wiki.github.com/joelthelion/autojump;
-      license = stdenv.lib.licenses.gpl3;
-      platforms = stdenv.lib.platforms.all;
-      maintainers = [ stdenv.lib.maintainers.domenkozar ];
-    };
-  }
+    homepage = http://wiki.github.com/wting/autojump;
+    license = licenses.gpl3;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ domenkozar yurrriq ];
+  };
+}

pkgs/tools/misc/partition-manager/default.nix

···
 { mkDerivation, fetchurl, lib
 , extra-cmake-modules, kdoctools, wrapGAppsHook
 , kconfig, kcrash, kinit, kpmcore
-, eject, libatasmart }:
+, eject, libatasmart , utillinux, makeWrapper, qtbase
+}:
 
 let
   pname = "partitionmanager";
 in mkDerivation rec {
   name = "${pname}-${version}";
-  version = "3.0.1";
+  version = "3.3.1";
 
   src = fetchurl {
     url = "mirror://kde/stable/${pname}/${version}/src/${name}.tar.xz";
-    sha256 = "08sb9xa7dvvgha3k2xm1srl339przxpxd2y5bh1lnx6k1x7dk410";
+    sha256 = "0jhggb4xksb0k0mj752n6pz0xmccnbzlp984xydqbz3hkigra1si";
   };
 
+  enableParallelBuilding = true;
+
+  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook makeWrapper ];
+
+  # refer to kpmcore for the use of eject
+  buildInputs = [ eject libatasmart utillinux ];
+  propagatedBuildInputs = [ kconfig kcrash kinit kpmcore ];
+
+  postInstall = ''
+    wrapProgram "$out/bin/partitionmanager" --prefix QT_PLUGIN_PATH : "${kpmcore}/lib/qt-5.${lib.versions.minor qtbase.version}/plugins"
+  '';
+
   meta = with lib; {
     description = "KDE Partition Manager";
     license = licenses.gpl2;
-    maintainers = with maintainers; [ peterhoeg ];
+    homepage = https://www.kde.org/applications/system/kdepartitionmanager/;
+    maintainers = with maintainers; [ peterhoeg ma27 ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
-  # refer to kpmcore for the use of eject
-  buildInputs = [ eject libatasmart ];
-  propagatedBuildInputs = [ kconfig kcrash kinit kpmcore ];
 }

pkgs/tools/misc/youtube-dl/default.nix

···
-{ stdenv, targetPlatform, fetchurl, buildPythonApplication
+{ stdenv, targetPlatform, fetchurl, buildPythonPackage
 , zip, ffmpeg, rtmpdump, phantomjs2, atomicparsley, pycryptodome, pandoc
 # Pandoc is required to build the package's man page. Release tarballs contain a
 # formatted man page already, though, it will still be installed. We keep the
···
 , makeWrapper }:
 
 with stdenv.lib;
-buildPythonApplication rec {
+buildPythonPackage rec {
 
   pname = "youtube-dl";
   version = "2018.05.18";

pkgs/tools/networking/wireguard-go/default.nix

···
 
 buildGoPackage rec {
   name = "wireguard-go-${version}";
-  version = "0.0.20180514";
+  version = "0.0.20180519";
 
   goPackagePath = "wireguard-go";
 
   src = fetchzip {
     url = "https://git.zx2c4.com/wireguard-go/snapshot/wireguard-go-${version}.tar.xz";
-    sha256 = "1i1w4vj8w353b92nfhs92k0f7fifrwi067qfmgckdk0kk76nv2id";
+    sha256 = "0b3wpc0ccf24567fjafv1sjs3yqq1xjam3gpfp37avxqy9789nb7";
   };
 
   goDeps = ./deps.nix;
···
     description = "Userspace Go implementation of WireGuard";
     homepage = https://git.zx2c4.com/wireguard-go/about/;
     license = licenses.gpl2;
-    maintainers = with maintainers; [ kirelagin ];
-    platforms = with platforms; linux ++ darwin ++ windows;
+    maintainers = with maintainers; [ kirelagin zx2c4 ];
+    platforms = platforms.darwin;
   };
 }

pkgs/tools/networking/wireguard-tools/default.nix

···
-{ stdenv, lib, fetchzip, libmnl, useSystemd ? stdenv.isLinux }:
+{ stdenv, fetchzip, libmnl ? null, makeWrapper ? null, wireguard-go ? null }:
 
-let
-  inherit (lib) optional optionalString;
-in
+with stdenv.lib;
 
 stdenv.mkDerivation rec {
   name = "wireguard-tools-${version}";
   version = "0.0.20180519";
 
   src = fetchzip {
-    url    = "https://git.zx2c4.com/WireGuard/snapshot/WireGuard-${version}.tar.xz";
+    url = "https://git.zx2c4.com/WireGuard/snapshot/WireGuard-${version}.tar.xz";
     sha256 = "0pd04ia0wcm0f6di4gx5kflccc5j35d72j38l8jqpj8vinl6l070";
   };
 
-  preConfigure = "cd src";
-
-  buildInputs = optional stdenv.isLinux libmnl;
+  sourceRoot = "source/src/tools";
 
-  enableParallelBuilding = true;
+  nativeBuildInputs = [ (optional stdenv.isDarwin makeWrapper) ];
+  buildInputs = [ (optional stdenv.isLinux libmnl) ];
 
   makeFlags = [
-    "WITH_BASHCOMPLETION=yes"
-    "WITH_WGQUICK=yes"
-    "WITH_SYSTEMDUNITS=${if useSystemd then "yes" else "no"}"
     "DESTDIR=$(out)"
     "PREFIX=/"
-    "-C" "tools"
+    "WITH_BASHCOMPLETION=yes"
+    "WITH_SYSTEMDUNITS=yes"
+    "WITH_WGQUICK=yes"
   ];
 
-  buildPhase = "make tools";
-
-  postInstall = optionalString useSystemd ''
+  postFixup = ''
     substituteInPlace $out/lib/systemd/system/wg-quick@.service \
       --replace /usr/bin $out/bin
+  '' + optionalString stdenv.isDarwin ''
+    for f in $out/bin/*; do
+      wrapProgram $f --prefix PATH : ${wireguard-go}/bin
+    done
   '';
 
   meta = with stdenv.lib; {
-    homepage     = https://www.wireguard.com/;
+    description = "Tools for the WireGuard secure network tunnel";
     downloadPage = https://git.zx2c4.com/WireGuard/refs/;
-    description  = " Tools for the WireGuard secure network tunnel";
-    maintainers  = with maintainers; [ ericsagnes mic92 zx2c4 ];
-    license      = licenses.gpl2;
-    platforms    = platforms.unix;
+    homepage = https://www.wireguard.com/;
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ ericsagnes mic92 zx2c4 ];
+    platforms = platforms.unix;
   };
 }

pkgs/tools/package-management/nix-du/default.nix

···
+{ stdenv, fetchFromGitHub, rustPlatform, nix, boost, graphviz }:
+rustPlatform.buildRustPackage rec {
+  name = "nix-du-${version}";
+  version = "0.1.1";
+
+  src = fetchFromGitHub {
+    owner = "symphorien";
+    repo = "nix-du";
+    rev = "v${version}";
+    sha256 = "0kxacn5qw21pp4zl6wr9wyb2mm2nlnp6mla3m5p9dm7vrm1fd1x9";
+  };
+  cargoSha256 = "04c48lzi7hny3nq4ffdpvsr4dxbi32faka163fp1yc9953zdw9az";
+
+  doCheck = !stdenv.isDarwin;
+  checkInputs = [ graphviz ];
+  nativeBuildInputs = [] ++ stdenv.lib.optionals doCheck checkInputs;
+
+  buildInputs = [
+    boost
+    nix
+  ];
+
+  meta = with stdenv.lib; {
+    description = "A tool to determine which gc-roots take space in your nix store";
+    homepage = https://github.com/symphorien/nix-du;
+    license = licenses.lgpl3;
+    maintainers = [ maintainers.symphorien ];
+    platforms = platforms.all;
+  };
+}

pkgs/top-level/all-packages.nix

···
   spidermonkey_1_8_5 = callPackage ../development/interpreters/spidermonkey/1.8.5.nix { };
   spidermonkey_17 = callPackage ../development/interpreters/spidermonkey/17.nix { };
   spidermonkey_31 = callPackage ../development/interpreters/spidermonkey/31.nix { };
-  spidermonkey_38 = callPackage ../development/interpreters/spidermonkey/38.nix { };
+  spidermonkey_38 = callPackage ../development/interpreters/spidermonkey/38.nix {
+    inherit (darwin) libobjc;
+  };
   spidermonkey_52 = callPackage ../development/interpreters/spidermonkey/52.nix { };
   spidermonkey = spidermonkey_31;
 
···
 
   simpleitk = callPackage ../development/libraries/simpleitk { lua = lua51Packages.lua; };
 
-  sfml = callPackage ../development/libraries/sfml { };
+  sfml = callPackage ../development/libraries/sfml {
+    inherit (darwin.apple_sdk.frameworks) IOKit Foundation AppKit OpenAL;
+  };
   csfml = callPackage ../development/libraries/csfml { };
 
   shapelib = callPackage ../development/libraries/shapelib { };
···
     gconf = gnome2.GConf;
   };
 
-  atom = callPackage ../applications/editors/atom { };
-  atom-beta = callPackage ../applications/editors/atom/beta.nix { };
+  atomPackages = callPackage ../applications/editors/atom { };
+
+  inherit (atomPackages) atom atom-beta;
 
   aseprite = callPackage ../applications/editors/aseprite { };
   aseprite-unfree = aseprite.override { unfree = true; };
···
   bombono = callPackage ../applications/video/bombono {};
 
   bomi = libsForQt5.callPackage ../applications/video/bomi {
-    youtube-dl = pythonPackages.youtube-dl;
     pulseSupport = config.pulseaudio or true;
     ffmpeg = ffmpeg_2;
   };
···
 
   mpv = callPackage ../applications/video/mpv rec {
     inherit (luaPackages) luasocket;
-    youtube-dl = pythonPackages.youtube-dl;
     waylandSupport     = stdenv.isLinux;
     alsaSupport        = !stdenv.isDarwin;
     pulseSupport       = !stdenv.isDarwin;
···
 
   purple-vk-plugin = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-vk-plugin { };
 
+  purple-xmpp-http-upload = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-xmpp-http-upload { };
+
   telegram-purple = callPackage ../applications/networking/instant-messengers/pidgin-plugins/telegram-purple { };
 
   toxprpl = callPackage ../applications/networking/instant-messengers/pidgin-plugins/tox-prpl {
···
 
   yoshimi = callPackage ../applications/audio/yoshimi { };
 
-  inherit (pythonPackages) youtube-dl;
+  youtube-dl = with pythonPackages; toPythonApplication youtube-dl;
+
+  youtube-dl-light = with pythonPackages; toPythonApplication youtube-dl-light;
 
   youtube-viewer = perlPackages.WWWYoutubeViewer;
 
···
   nix-delegate = haskell.lib.justStaticExecutables haskellPackages.nix-delegate;
   nix-deploy = haskell.lib.justStaticExecutables haskellPackages.nix-deploy;
   nix-diff = haskell.lib.justStaticExecutables haskellPackages.nix-diff;
+
+  nix-du = callPackage ../tools/package-management/nix-du { };
 
   nix-info = callPackage ../tools/nix/info { };
   nix-info-tested = nix-info.override { doCheck = true; };

pkgs/top-level/python-packages.nix

···
 
   pyaes = callPackage ../development/python-modules/pyaes { };
 
+  pyairvisual = callPackage ../development/python-modules/pyairvisual { };
+
   pyamf = callPackage ../development/python-modules/pyamf { };
 
   pyarrow = callPackage ../development/python-modules/pyarrow {
···
     };
   };
 
-  timeout-decorator = buildPythonPackage rec {
-    name    = "timeout-decorator-${version}";
-    version = "0.3.2";
-
-    src = pkgs.fetchurl {
-      url    = "http://pypi.python.org/packages/source/t/timeout-decorator/${name}.tar.gz";
-      sha256 = "1x9l8bwdk72if2d5h5mi4lcaidbsmyh0iz114cfyyj1rzz5rxqaf";
-    };
-  };
+  timeout-decorator = callPackage ../development/python-modules/timeout-decorator { };
 
   pid = buildPythonPackage rec {
     name = "pid-${version}";
···
   prometheus_client = callPackage ../development/python-modules/prometheus_client { };
 
   pysdl2 = callPackage ../development/python-modules/pysdl2 { };
+
+  pyogg = callPackage ../development/python-modules/pyogg { };
 });
 
 in fix' (extends overrides packages)