Merge branch 'master.upstream' into staging.upstream

doc/haskell-users-guide.xml

···
   </para>
   <programlisting>
 $ nix-env -qaP coreutils
-nixos.pkgs.coreutils  coreutils-8.23
+nixos.coreutils  coreutils-8.23
 </programlisting>
   <para>
     If your system responds like that (most NixOS installatios will),
     then the attribute path to <literal>haskellPackages</literal> is
-    <literal>nixos.pkgs.haskellPackages</literal>. Thus, if you want to
+    <literal>nixos.haskellPackages</literal>. Thus, if you want to
     use <literal>nix-env</literal> without giving an explicit
     <literal>-f</literal> flag, then that's the way to do it:
   </para>
   <programlisting>
-$ nix-env -qaP -A nixos.pkgs.haskellPackages
-$ nix-env -iA nixos.pkgs.haskellPackages.cabal-install
+$ nix-env -qaP -A nixos.haskellPackages
+$ nix-env -iA nixos.haskellPackages.cabal-install
 </programlisting>
   <para>
     Our current default compiler is GHC 7.10.x and the

lib/modules.nix

···
 
     in opt //
       { value = addErrorContext "while evaluating the option `${showOption loc}':" value;
-        definitions = map (def: def.value) defsFinal;
+        definitions = map (def: def.value) res.defsFinal;
         files = map (def: def.file) res.defsFinal;
         inherit (res) isDefined;
       };

nixos/doc/manual/configuration/ad-hoc-packages.xml

···
 Mozilla Thunderbird:
 
 <screen>
-$ nix-env -iA nixos.pkgs.thunderbird</screen>
+$ nix-env -iA nixos.thunderbird</screen>
 
 If you invoke this as root, the package is installed in the Nix
 profile <filename>/nix/var/nix/profiles/default</filename> and visible

nixos/doc/manual/configuration/declarative-packages.xml

···
 <para>You can get a list of the available packages as follows:
 <screen>
 $ nix-env -qaP '*' --description
-nixos.pkgs.firefox   firefox-23.0   Mozilla Firefox - the browser, reloaded
+nixos.firefox   firefox-23.0   Mozilla Firefox - the browser, reloaded
 <replaceable>...</replaceable>
 </screen>
 
 The first column in the output is the <emphasis>attribute
 name</emphasis>, such as
-<literal>nixos.pkgs.thunderbird</literal>. (The
+<literal>nixos.thunderbird</literal>. (The
 <literal>nixos</literal> prefix allows distinguishing between
 different channels that you might have.)</para>
 

nixos/doc/manual/release-notes/rl-unstable.xml

···
   </para>
 </listitem>
 
+<listitem>
+  <para>
+    The Nix expression search path (<envar>NIX_PATH</envar>) no longer
+    contains <filename>/etc/nixos/nixpkgs</filename> by default. You
+    can override <envar>NIX_PATH</envar> by setting
+    <option>nix.nixPath</option>.
+  </para>
+</listitem>
+
 </itemizedlist>
 </para>
 

nixos/lib/build-vms.nix

···
 { system, minimal ? false }:
 
-let pkgs = import ./nixpkgs.nix { config = {}; inherit system; }; in
+let pkgs = import ../.. { config = {}; inherit system; }; in
 
 with pkgs.lib;
 with import ../lib/qemu-flags.nix;

nixos/lib/channel-expr.nix

···
-{ system ? builtins.currentSystem }:
-
-{ pkgs =
-    (import nixpkgs/default.nix { inherit system; })
-    // { recurseForDerivations = true; };
-}

nixos/lib/make-channel.nix

···
 
   buildInputs = [ pkgs.nix ];
 
-  expr = builtins.readFile ./channel-expr.nix;
-
   distPhase = ''
     rm -rf .git
     echo -n $VERSION_SUFFIX > .version-suffix
     echo -n ${nixpkgs.rev or nixpkgs.shortRev} > .git-revision
     releaseName=nixos-$VERSION$VERSION_SUFFIX
     mkdir -p $out/tarballs
-    mkdir ../$releaseName
-    cp -prd . ../$releaseName/nixpkgs
+    cp -prd . ../$releaseName
     chmod -R u+w ../$releaseName
-    ln -s nixpkgs/nixos ../$releaseName/nixos
-    echo "$expr" > ../$releaseName/default.nix
+    ln -s . ../$releaseName/nixpkgs # hack to make ‘<nixpkgs>’ work
     NIX_STATE_DIR=$TMPDIR nix-env -f ../$releaseName/default.nix -qaP --meta --xml \* > /dev/null
     cd ..
     chmod -R u+w $releaseName

nixos/lib/nixpkgs.nix

···
-/* Terrible backward compatibility hack to get the path to Nixpkgs
-   from here.  Usually, that's the relative path ‘../..’.  However,
-   when using the NixOS channel, <nixos> resolves to a symlink to
-   nixpkgs/nixos, so ‘../..’ doesn't resolve to the top-level Nixpkgs
-   directory but one above it.  So check for that situation. */
-if builtins.pathExists ../../.version then import ../..
-else if builtins.pathExists ../../nixpkgs then import ../../nixpkgs
-else abort "Can't find Nixpkgs, please set ‘NIX_PATH=nixpkgs=/path/to/nixpkgs’."

nixos/modules/installer/cd-dvd/channel.nix

···
 
   # We need a copy of the Nix expressions for Nixpkgs and NixOS on the
   # CD.  These are installed into the "nixos" channel of the root
-  # user, as expected by nixos-rebuild/nixos-install.
+  # user, as expected by nixos-rebuild/nixos-install. FIXME: merge
+  # with make-channel.nix.
   channelSources = pkgs.runCommand "nixos-${config.system.nixosVersion}"
-    { expr = readFile ../../../lib/channel-expr.nix; }
+    { }
     ''
-      mkdir -p $out/nixos
-      cp -prd ${pkgs.path} $out/nixos/nixpkgs
-      ln -s nixpkgs/nixos $out/nixos/nixos
+      mkdir -p $out
+      cp -prd ${pkgs.path} $out/nixos
       chmod -R u+w $out/nixos
-      rm -rf $out/nixos/nixpkgs/.git
-      echo -n ${config.system.nixosVersion} > $out/nixos/nixpkgs/.version
-      echo -n "" > $out/nixos/nixpkgs/.version-suffix
-      echo "$expr" > $out/nixos/default.nix
+      ln -s . $out/nixos/nixpkgs
+      rm -rf $out/nixos/.git
+      echo -n ${config.system.nixosVersionSuffix} > $out/nixos/.version-suffix
     '';
 
 in

nixos/modules/installer/tools/nixos-build-vms/nixos-build-vms.sh

···
 
 # Build a network of VMs
 
-nix-build '<nixos/modules/installer/tools/nixos-build-vms/build-vms.nix>' \
+nix-build '<nixpkgs/nixos/modules/installer/tools/nixos-build-vms/build-vms.nix>' \
     --argstr networkExpr $networkExpr $noOutLinkArg $showTraceArg

nixos/modules/installer/tools/nixos-checkout.nix

···
 
         if [ -z "$(type -P git)" ]; then
             echo "installing Git..."
-            nix-env -iA nixos.pkgs.git || nix-env -i git
+            nix-env -iA nixos.git
         fi
 
         # Move any old nixpkgs directories out of the way.

nixos/modules/installer/tools/nixos-install.sh

···
 chroot $mountPoint /nix/var/nix/profiles/system/activate
 
 
-# Some systems may not be prepared to use NixOS' paths.
-export PATH=/run/current-system/sw/bin:/run/current-system/sw/sbin:$PATH
-export NIX_PATH=/nix/var/nix/profiles/per-user/root/channels/nixos:nixpkgs=/etc/nixos/nixpkgs
-export NIX_PATH=$NIX_PATH:nixos-config=/etc/nixos/configuration.nix:/nix/var/nix/profiles/per-user/root/channels
-
-
 # Ask the user to set a root password.
-if [ "$(chroot $mountPoint nix-instantiate --eval '<nixpkgs/nixos>' -A config.users.mutableUsers)" = true ] && [ -t 0 ] ; then
+if [ "$(chroot $mountPoint /run/current-system/sw/bin/sh -l -c "nix-instantiate --eval '<nixpkgs/nixos>' -A config.users.mutableUsers")" = true ] && [ -t 0 ] ; then
     echo "setting root password..."
     chroot $mountPoint /var/setuid-wrappers/passwd
 fi

nixos/modules/installer/tools/nixos-rebuild.sh

···
             if ! nix-build '<nixpkgs>' -A nix -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then
                 machine="$(uname -m)"
                 if [ "$machine" = x86_64 ]; then
-                    nixStorePath=/nix/store/ffig6yaggbh12dh9y5pnf1grf5lqyipz-nix-1.8
+                    nixStorePath=/nix/store/664kxr14kfgx4dl095crvmr7pbh9xlh5-nix-1.9
                 elif [[ "$machine" =~ i.86 ]]; then
-                    nixStorePath=/nix/store/lglhfp4mimfa5wzjjf1kqz6f5wlsj2mn-nix-1.8
+                    nixStorePath=/nix/store/p7xdvz72xx3rhm121jclsbdmmcds7xh6-nix-1.9
                 else
                     echo "$0: unsupported platform"
                     exit 1

nixos/modules/misc/assertions.nix

···
     };
 
   };
-  # impl of assertions is in <nixos/modules/system/activation/top-level.nix>
+  # impl of assertions is in <nixpkgs/nixos/modules/system/activation/top-level.nix>
 }

nixos/modules/misc/extra-arguments.nix

···
 
 {
   _module.args = {
-    pkgs_i686 = import ../../lib/nixpkgs.nix {
+    pkgs_i686 = import ../../.. {
       system = "i686-linux";
       config.allowUnfree = true;
     };

nixos/modules/misc/nixpkgs.nix

···
   };
 
   config = {
-    _module.args.pkgs = import ../../lib/nixpkgs.nix {
+    _module.args.pkgs = import ../../.. {
       system = config.nixpkgs.system;
 
       inherit (config.nixpkgs) config;

nixos/modules/profiles/clone-config.nix

···
   relocatedModuleFiles =
     let
       relocateNixOS = path:
-        "<nixos" + removePrefix nixosPath (toString path) + ">";
+        "<nixpkgs/nixos" + removePrefix nixosPath (toString path) + ">";
       relocateOthers = null;
     in
       { nixos = map relocateNixOS partitionedModuleFiles.nixos;

nixos/modules/programs/environment.nix

···
         EDITOR = mkDefault "nano";
       };
 
-    environment.sessionVariables =
-      { NIX_PATH =
-          [ "/nix/var/nix/profiles/per-user/root/channels/nixos"
-            "nixpkgs=/etc/nixos/nixpkgs"
-            "nixos-config=/etc/nixos/configuration.nix"
-            "/nix/var/nix/profiles/per-user/root/channels"
-          ];
-      };
-
     environment.profiles =
       [ "$HOME/.nix-profile"
         "/nix/var/nix/profiles/default"

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

···
         '';
       };
 
+      nixPath = mkOption {
+        type = types.listOf types.str;
+        default =
+          [ "/nix/var/nix/profiles/per-user/root/channels/nixos"
+            "nixos-config=/etc/nixos/configuration.nix"
+            "/nix/var/nix/profiles/per-user/root/channels"
+          ];
+        description = ''
+          The default Nix expression search path, used by the Nix
+          evaluator to look up paths enclosed in angle brackets
+          (e.g. <literal>&lt;nixpkgs&gt;</literal>).
+        '';
+      };
+
     };
 
   };
···
       };
 
     # Set up the environment variables for running Nix.
-    environment.sessionVariables = cfg.envVars;
+    environment.sessionVariables = cfg.envVars //
+      { NIX_PATH = concatStringsSep ":" cfg.nixPath;
+      };
 
     environment.extraInit =
       ''

nixos/modules/services/networking/dnsmasq.nix

···
           ExecStart = "${dnsmasq}/bin/dnsmasq -k --enable-dbus --user=dnsmasq -C ${dnsmasqConf}";
           ExecReload = "${dnsmasq}/bin/kill -HUP $MAINPID";
         };
+        restartTriggers = [ config.environment.etc.hosts.source ];
     };
 
   };

nixos/tests/check-filesystems.nix

···
-{ nixos ? ./..
-, nixpkgs ? /etc/nixos/nixpkgs
-, system ? builtins.currentSystem
-}:
-
-with import ../lib/build-vms.nix { inherit nixos nixpkgs system; };
-
-rec {
-  name = "check-filesystems";
-  meta = with pkgs.stdenv.lib.maintainers; {
-    maintainers = [ eelco chaoflow ];
-  };
-
-  nodes = {
-    share = {pkgs, config, ...}: {
-      services.nfs.server.enable = true;
-      services.nfs.server.exports = ''
-        /repos1 192.168.1.0/255.255.255.0(rw,no_root_squash)
-        /repos2 192.168.1.0/255.255.255.0(rw,no_root_squash)
-      '';
-      services.nfs.server.createMountPoints = true;
-
-      jobs.checkable = {
-        startOn = [
-          config.jobs.nfs_kernel_exports.name
-          config.jobs.nfs_kernel_nfsd.name
-        ];
-        respawn = true;
-      };
-    };
-
-    fsCheck = {pkgs, config, ...}: {
-      fileSystems =
-        let
-          repos1 = {
-            mountPoint = "/repos1";
-            autocreate = true;
-            device = "share:/repos1";
-            fsType = "nfs";
-          };
-
-          repos2 = {
-            mountPoint = "/repos2";
-            autocreate = true;
-            device = "share:/repos2";
-            fsType = "nfs";
-          };
-        in pkgs.lib.mkVMOverride [
-          repos1
-          repos1 # check remount
-          repos2 # check after remount
-        ];
-
-      jobs.checkable = {
-        startOn = "stopped ${config.jobs.filesystems.name}";
-        respawn = true;
-      };
-    };
-  };
-
-  vms = buildVirtualNetwork { inherit nodes; };
-
-  test = runTests vms
-    ''
-      startAll;
-
-      $share->waitForUnit("checkable");
-      $fsCheck->waitForUnit("checkable");
-
-      # check repos1
-      $fsCheck->succeed("test -d /repos1");
-      $share->succeed("touch /repos1/test1");
-      $fsCheck->succeed("test -e /repos1/test1");
-
-      # check repos2 (check after remount)
-      $fsCheck->succeed("test -d /repos2");
-      $share->succeed("touch /repos2/test2");
-      $fsCheck->succeed("test -e /repos2/test2");
-
-      # check without network
-      $share->block();
-      $fsCheck->fail("test -e /repos1/test1");
-      $fsCheck->fail("test -e /repos2/test2");
-    '';
-}

nixos/tests/containers.nix

···
       $machine->fail("curl --fail --connect-timeout 2 http://$ip/ > /dev/null");
 
       # Make sure we have a NixOS tree (required by ‘nixos-container create’).
-      $machine->succeed("PAGER=cat nix-env -qa -A nixos.pkgs.hello >&2");
+      $machine->succeed("PAGER=cat nix-env -qa -A nixos.hello >&2");
 
       # Create some containers imperatively.
       my $id1 = $machine->succeed("nixos-container create foo --ensure-unique-name");

pkgs/applications/audio/drumkv1/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "drumkv1-${version}";
-  version = "0.6.3";
+  version = "0.7.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/drumkv1/${name}.tar.gz";
-    sha256 = "1f0vpwq7vydldrq9fdfipbkzqqndyxlx0n81ch1i9kw81xj3sxjq";
+    sha256 = "1fbi835559qsg9fxgdbdyf5z1zlzf9n8zrq0p67damb55mmigaj8";
   };
 
   buildInputs = [ libjack2 libsndfile lv2 qt4 ];

pkgs/applications/audio/guitarix/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "guitarix-${version}";
-  version = "0.32.3";
+  version = "0.33.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/guitarix/guitarix2-${version}.tar.bz2";
-    sha256 = "1ybc5jk7fj6n8qh9ajzl1f6fzdmzab4nwjrh4fsylm94dn1jv0if";
+    sha256 = "1w6dg2n0alfjsx1iy6s53783invygwxk11p1i65cc3nq3zlidcgx";
   };
 
   nativeBuildInputs = [ gettext intltool pkgconfig python ];

pkgs/applications/audio/samplv1/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "samplv1-${version}";
-  version = "0.6.3";
+  version = "0.7.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/samplv1/${name}.tar.gz";
-    sha256 = "1c62fpfl9xv93m04hfh72vzbljr0c5p409vzf3xxmvj9x610yx1w";
+    sha256 = "0w1cl1vjhzzdyxfn8fcfgx5j5d4gi182w5b89f7qzg1akhmsqmfr";
   };
 
   buildInputs = [ libjack2 libsndfile lv2 qt4 ];

pkgs/applications/editors/emacs-modes/org/default.nix

···
 , texLiveAggregationFun }:
 
 stdenv.mkDerivation rec {
-  name = "org-8.2.10";
+  name = "org-8.3";
 
   src = fetchurl {
     url = "http://orgmode.org/${name}.tar.gz";
-    sha256 = "1xm8n8zwr3676rl4pd32k61rd7rimlihhrw5a7r4z7r154c4a2fz";
+    sha256 = "0yqbl232hfppljz545jbjawwaw7qjdjsq97c0wf0cbkghgpln3wy";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/editors/vim/macvim.nix

···
 stdenv.mkDerivation rec {
   name = "macvim-${version}";
 
-  version = "7.4.479";
+  version = "7.4.648";
 
   src = fetchurl {
-    url = "https://github.com/genoma/macvim/archive/g-snapshot-21.tar.gz";
-    sha256 = "1s86dpb8bcxh309gikiz8gm9ygv3d2jy6i4qlnxarbvcdk65fzv4";
+    url = "https://github.com/genoma/macvim/archive/g-snapshot-32.tar.gz";
+    sha256 = "1wqg5sy7krgqg3sj00gb34avg90ga2kbvv09bsxv2267j7agi0iq";
   };
 
   enableParallelBuilding = true;

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

···
 {stdenv, fetchurl, zlib, openssl, tcl, readline, sqlite, withJson ? true}:
 
 stdenv.mkDerivation rec {
-  name = "fossil-1.32";
+  name = "fossil-1.33";
 
   src = fetchurl {
     urls = 
       [
-        "https://www.fossil-scm.org/fossil/tarball/Fossil-6c40678e.tar.gz?uuid=6c40678e9114c41a50f73cc43f6f942ace0408ec"
-        ];
+        https://www.fossil-scm.org/download/fossil-src-1.33.tar.gz
+      ];
     name = "${name}.tar.gz";
-    sha256 = "0f1rvqiy630z2q1q8r3kgdd0c6sxjx8c8pm46yabn238xvf3bfnr";
+    sha256 = "0gkzd9nj3xyznh9x8whv0phdnj11l5c8164rc3l0jvs5i61c95b2";
   };
 
   buildInputs = [ zlib openssl readline sqlite ];

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

···
   '';
 
   buildInputs = [ subversion apr qt4 ];
+
+  meta.broken = true;
 }

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

···
 
   meta = {
     homepage = https://github.com/nirvdrum/svn2git;
-    description = "Ruby tool for importing existing svn projects into git";
+    description = "Tool for importing Subversion repositories into git";
     license = stdenv.lib.licenses.mit;
 
     maintainers = [ stdenv.lib.maintainers.the-kenny ];

pkgs/data/misc/geolite-legacy/default.nix

···
 
   # Annoyingly, these files are updated without a change in URL. This means that
   # builds will start failing every month or so, until the hashes are updated.
-  version = "2015-08-03";
+  version = "2015-08-05";
 in
 stdenv.mkDerivation {
   name = "geolite-legacy-${version}";
 
   srcGeoIP = fetchDB
     "GeoLiteCountry/GeoIP.dat.gz" "GeoIP.dat.gz"
-    "1yacbh8qcakmnpipscdh99vmsm0874g2gkq8gp8hjgkgi0zvcsnz";
+    "04r1jir9xpd1h5z0a58mwdsbfdbf2kap0ac498w05i11j4vrlh5n";
   srcGeoIPv6 = fetchDB
     "GeoIPv6.dat.gz" "GeoIPv6.dat.gz"
-    "038ll8142svhyffxxrg0isrr16rjbz0cnkhd14mck77f1v8z01y5";
+    "0vr2a4mlqlaxq3jz8282zygb2y5hx7y660yrjcq02rpmgpmaxkrd";
   srcGeoLiteCity = fetchDB
     "GeoLiteCity.dat.xz" "GeoIPCity.dat.xz"
-    "0x5ihg7qikzc195nix9r0izvbdnj4hy4rznvaxk56rf8yqcigdyv";
+    "11jpl54s1r98adlsr2f88zj4x9pg7gwxphd7hhq8jp3hwrgrwhs8";
   srcGeoLiteCityv6 = fetchDB
     "GeoLiteCityv6-beta/GeoLiteCityv6.dat.gz" "GeoIPCityv6.dat.gz"
-    "0j5dq06pjrh6d94wczsg6qdys4v164nvp2a7qqrg8w4knh94qp6n";
+    "1fhi5vm4drfzyl29b491pr1xr2kbsr3izp9a7k5zm3zkqags2187";
   srcGeoIPASNum = fetchDB
     "asnum/GeoIPASNum.dat.gz" "GeoIPASNum.dat.gz"
     "04qlh6zr8m5qxl2gcysb721bqlnqrxhngh128zj1w8rhqckjndgj";

pkgs/desktops/gnome-3/3.16/apps/cheese/default.nix

···
+{ stdenv, intltool, fetchurl, wrapGAppsHook, gnome-video-effects, libcanberra_gtk3
+, pkgconfig, gtk3, glib, clutter_gtk, clutter-gst_2, udev, gst_all_1, itstool
+, adwaita-icon-theme, librsvg, gdk_pixbuf, gnome3, gnome_desktop, libxml2, libtool }:
+
+stdenv.mkDerivation rec {
+  name = "cheese-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/cheese/${gnome3.version}/${name}.tar.xz";
+    sha256 = "184hzwrjjn94ndivb54rrif4jnbr66p1j0nlqqi3nw6qsrm2yqj4";
+  };
+
+  buildInputs = [ pkgconfig gtk3 glib intltool wrapGAppsHook gnome-video-effects itstool
+                  gdk_pixbuf adwaita-icon-theme librsvg udev gst_all_1.gstreamer libxml2
+                  gst_all_1.gst-plugins-base gst_all_1.gst-plugins-good gnome_desktop
+                  gst_all_1.gst-plugins-bad clutter_gtk clutter-gst_2
+                  libtool libcanberra_gtk3 ];
+
+  enableParallelBuilding = true;
+
+  NIX_CFLAGS_COMPILE = "-I${glib}/include/gio-unix-2.0";
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Cheese;
+    description = "Take photos and videos with your webcam, with fun graphical effects";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+  };
+}

pkgs/desktops/gnome-3/3.16/core/gnome-desktop/default.nix

···
   buildInputs = [ pkgconfig python libxml2Python libxslt which libX11
                   xkeyboard_config isocodes itstool wayland
                   gtk3 glib intltool gnome_doc_utils libxkbfile
-                  gnome3.gsettings_desktop_schemas gobjectIntrospection ];
+                  gobjectIntrospection ];
+
+  propagatedBuildInputs = [ gnome3.gsettings_desktop_schemas ];
 
   meta = with stdenv.lib; {
     platforms = platforms.linux;

pkgs/desktops/gnome-3/3.16/default.nix

···
   gnome3 = self // { recurseForDerivations = false; };
   clutter = pkgs.clutter_1_22;
   clutter_gtk = pkgs.clutter_gtk_1_6.override { inherit clutter gtk3; };
+  clutter-gst_2 = pkgs.clutter-gst;
   clutter-gst = pkgs.clutter-gst_3_0.override { inherit clutter; };
   cogl = pkgs.cogl_1_20;
   gtk = gtk3;
···
     webkitgtk = webkitgtk24x;
   };
 
+  cheese = callPackage ./apps/cheese { };
+
   evolution = callPackage ./apps/evolution {
     webkitgtk = webkitgtk24x;
   };
···
   gtkhtml = callPackage ./misc/gtkhtml { };
 
   pomodoro = callPackage ./misc/pomodoro { };
+
+  gnome-video-effects = callPackage ./misc/gnome-video-effects { };
 
     };
   in self; # pkgsFun

pkgs/desktops/gnome-3/3.16/misc/gnome-video-effects/default.nix

···
+{ stdenv, fetchurl, pkgconfig, intltool, gnome3 }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-video-effects-${version}";
+  version = "0.4.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-video-effects/0.4/${name}.tar.xz";
+    sha256 = "0jl4iny2dqpcgi3sgxzpgnbw0752i8ay3rscp2cgdjlp79ql5gil";
+  };
+
+  buildInputs = [ pkgconfig intltool ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Projects/GnomeVideoEffects;
+    platforms = platforms.linux;
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+  };
+}

pkgs/development/compilers/ghc/7.10.2.nix

···
 in
 
 stdenv.mkDerivation rec {
-  version = "7.10.1.20150630";
+  version = "7.10.2";
   name = "ghc-${version}";
 
   src = fetchurl {
-    url = "https://downloads.haskell.org/~ghc/7.10.2-rc2/${name}-src.tar.xz";
-    sha256 = "1wxf7jkkgpvvrg3q311c4rca4vsxrqrmnrqg4j4klgj445yj82gb";
+    url = "https://downloads.haskell.org/~ghc/7.10.2/${name}-src.tar.xz";
+    sha256 = "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal";
   };
 
   buildInputs = [ ghc perl ];

pkgs/development/compilers/ghcjs/default.nix

···
   version = "0.1.0";
   ghcjsBoot = fetchgit {
     url = git://github.com/ghcjs/ghcjs-boot.git;
-    rev = "d3581514d0a5073f8220a2f5baafe6866faa35a0"; # 7.10 branch
-    sha256 = "1p13ifidpi7y1mjq5qv9229isfnsiklizci7i55sf83mp6wqdyvr";
+    rev = "d435c60b62d24b7a4117493f7aaecbfa09968fe6"; # 7.10 branch
+    sha256 = "07vhmjz21ccnqccms003550xacmwb08pjdkhnjcwcbl2603v4na1";
     fetchSubmodules = true;
   };
   shims = fetchgit {
     url = git://github.com/ghcjs/shims.git;
-    rev = "9b196ff5ff13a24997011009b37c980c5534e24f"; # master branch
-    sha256 = "1zsfxka692fr3zb710il7g1sj64xwaxmasimciylb4wx84h7c30w";
+    rev = "0b670ca27fff3f0bad515c37e56ccb8b4d6758fb"; # master branch
+    sha256 = "19zq79f2y59lw7c8m100awh3rcra5yhbsvpb5xmp3mq6grac7h08";
   };
 in mkDerivation (rec {
   pname = "ghcjs";
   inherit version;
   src = fetchgit {
     url = git://github.com/ghcjs/ghcjs.git;
-    rev = "c1b6239b0289371dc6b8d17dfd845c14bd4dc490"; # master branch
-    sha256 = "0ncbk7m1l7cpdgmabm14d7f97fw3vy0hmpj4vs4kkwhhfjf6kp8s";
+    rev = "fb1faa9cb0a11a8b27b0033dfdb07aafb6add35e"; # master branch
+    sha256 = "1vqf19059j86h3rnbvzcp55bdqd5dkw3krb5vkw5mgsmva2g8sch";
   };
   isLibrary = true;
   isExecutable = true;

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

···
   cabal-install = (dontCheck super.cabal-install).overrideScope (self: super: { Cabal = self.Cabal_1_22_4_0; zlib = self.zlib_0_5_4_2; });
   cabal-install_1_18_1_0 = (dontCheck super.cabal-install_1_18_1_0).overrideScope (self: super: { Cabal = self.Cabal_1_18_1_6; zlib = self.zlib_0_5_4_2; });
 
+  # Link statically to avoid runtime dependency on GHC.
+  jailbreak-cabal = disableSharedExecutables super.jailbreak-cabal;
+
   # Break infinite recursions.
   Dust-crypto = dontCheck super.Dust-crypto;
   hasql-postgres = dontCheck super.hasql-postgres;
···
   Frames = dontDistribute super.Frames;
   hgeometry = dontDistribute super.hgeometry;
   hipe = dontDistribute super.hipe;
+  hsqml-datamodel-vinyl = dontDistribute super.hsqml-datamodel-vinyl;
   singleton-nats = dontDistribute super.singleton-nats;
   singletons = markBroken super.singletons;
   units-attoparsec = dontDistribute super.units-attoparsec;
···
 
   # https://ghc.haskell.org/trac/ghc/ticket/9825
   vimus = overrideCabal super.vimus (drv: { broken = pkgs.stdenv.isLinux && pkgs.stdenv.isi686; });
+
+  # https://github.com/hspec/mockery/issues/6
+  mockery = overrideCabal super.mockery (drv: { preCheck = "export TRAVIS=true"; });
 
 }

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

···
   unix = null;
 
   # binary is not a core library for this compiler.
-  binary = self.binary_0_7_5_0;
+  binary = self.binary_0_7_6_1;
 
   # deepseq is not a core library for this compiler.
   deepseq_1_3_0_1 = dontJailbreak super.deepseq_1_3_0_1;

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

···
   unix = null;
 
   # binary is not a core library for this compiler.
-  binary = self.binary_0_7_5_0;
+  binary = self.binary_0_7_6_1;
 
   # deepseq is not a core library for this compiler.
   deepseq = self.deepseq_1_4_1_1;
···
 
   # Needs hashable on pre 7.10.x compilers.
   nats = addBuildDepend super.nats self.hashable;
+
+  # Newer versions require bytestring >=0.10.
+  tar = super.tar_0_4_1_0;
 
 }

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

···
   transformers = self.transformers_0_4_3_0;
 
   # https://github.com/haskell/cabal/issues/2322
-  Cabal_1_22_4_0 = super.Cabal_1_22_4_0.override { binary = self.binary_0_7_5_0; process = self.process_1_2_3_0; };
+  Cabal_1_22_4_0 = super.Cabal_1_22_4_0.override { binary = self.binary_0_7_6_1; process = self.process_1_2_3_0; };
 
   # Newer versions don't compile.
   Cabal_1_18_1_6 = dontJailbreak super.Cabal_1_18_1_6;
···
 
   # Needs hashable on pre 7.10.x compilers.
   nats = addBuildDepend super.nats self.hashable;
+
+  # Newer versions require bytestring >=0.10.
+  tar = super.tar_0_4_1_0;
 
 }

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

···
   transformers = self.transformers_0_4_3_0;
 
   # https://github.com/haskell/cabal/issues/2322
-  Cabal_1_22_4_0 = super.Cabal_1_22_4_0.override { binary = dontCheck self.binary_0_7_5_0; };
+  Cabal_1_22_4_0 = super.Cabal_1_22_4_0.override { binary = dontCheck self.binary_0_7_6_1; };
 
   # Avoid inconsistent 'binary' versions from 'text' and 'Cabal'.
-  cabal-install = super.cabal-install.overrideScope (self: super: { binary = dontCheck self.binary_0_7_5_0; });
+  cabal-install = super.cabal-install.overrideScope (self: super: { binary = dontCheck self.binary_0_7_6_1; });
 
   # https://github.com/tibbe/hashable/issues/85
   hashable = dontCheck super.hashable;
···
 
   # Avoid depending on tasty-golden.
   monad-par = dontCheck super.monad-par;
+
+  # Newer versions require bytestring >=0.10.
+  tar = super.tar_0_4_1_0;
 
 }

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

···
   xhtml = self.xhtml_3000_2_1;
 
   # https://github.com/haskell/cabal/issues/2322
-  Cabal_1_22_4_0 = super.Cabal_1_22_4_0.override { binary = dontCheck self.binary_0_7_5_0; };
+  Cabal_1_22_4_0 = super.Cabal_1_22_4_0.override { binary = dontCheck self.binary_0_7_6_1; };
 
   # Avoid inconsistent 'binary' versions from 'text' and 'Cabal'.
-  cabal-install = super.cabal-install.overrideScope (self: super: { binary = dontCheck self.binary_0_7_5_0; });
+  cabal-install = super.cabal-install.overrideScope (self: super: { binary = dontCheck self.binary_0_7_6_1; });
 
   # https://github.com/tibbe/hashable/issues/85
   hashable = dontCheck super.hashable;

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

···
   seqid-streams = super.seqid-streams_0_1_0;
 
   # Need binary >= 0.7.2, but our compiler has only 0.7.1.0.
-  hosc = super.hosc.overrideScope (self: super: { binary = self.binary_0_7_5_0; });
-  tidal-midi = super.tidal-midi.overrideScope (self: super: { binary = self.binary_0_7_5_0; });
+  hosc = super.hosc.overrideScope (self: super: { binary = self.binary_0_7_6_1; });
+  tidal-midi = super.tidal-midi.overrideScope (self: super: { binary = self.binary_0_7_6_1; });
 
   # These packages need mtl 2.2.x directly or indirectly via dependencies.
   amazonka = markBroken super.amazonka;

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

···
 , useCpphs ? false
 } @ args:
 
-assert pkgconfigDepends != [] -> pkgconfig != null;
 assert editedCabalFile != null -> revision != null;
 
 let
···
   isHaskellPkg = x: (x ? pname) && (x ? version) && (x ? env);
   isSystemPkg = x: !isHaskellPkg x;
 
+  allPkgconfigDepends = pkgconfigDepends ++ libraryPkgconfigDepends ++ executablePkgconfigDepends ++
+                        optionals doCheck testPkgconfigDepends;
+
   propagatedBuildInputs = buildDepends ++ libraryHaskellDepends ++ executableHaskellDepends;
   otherBuildInputs = extraLibraries ++ librarySystemDepends ++ executableSystemDepends ++
                      buildTools ++ libraryToolDepends ++ executableToolDepends ++
-                     optionals (pkgconfigDepends != []) ([pkgconfig] ++ pkgconfigDepends ++ libraryPkgconfigDepends ++ executablePkgconfigDepends) ++
+                     optionals (allPkgconfigDepends != []) ([pkgconfig] ++ allPkgconfigDepends) ++
                      optionals doCheck (testDepends ++ testHaskellDepends ++ testSystemDepends);
   allBuildInputs = propagatedBuildInputs ++ otherBuildInputs;
 
···
   ghcCommandCaps = toUpper ghcCommand;
 
 in
+
+assert allPkgconfigDepends != [] -> pkgconfig != null;
+
 stdenv.mkDerivation ({
   name = "${optionalString (hasActiveLibrary && pname != "ghcjs") "haskell-"}${pname}-${version}";
 

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

···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "AAI" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "AAI";
+       version = "0.2.0.1";
+       sha256 = "0vdq0hscpbl5a9bpf8fiykmyg2c3yvivb0mzcdy99ha0j1p4rwfh";
+       buildDepends = [ base ];
+       description = "Abstract Application Interface";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "ABList" = callPackage
     ({ mkDerivation, base, HUnit, linear, newtype, QuickCheck
      , test-framework, test-framework-hunit, test-framework-quickcheck2
···
      mkDerivation {
        pname = "Agda";
        version = "2.4.2.3";
+       revision = "1";
        sha256 = "09vvipvab6bys8g7cdka1iirs0wc0jzcyynncccgb614wd2yyvdw";
+       editedCabalFile = "25fe17a2302a30f23a57bedf6bc66a8966f4d5f6b10353e2502e18ba98f80eeb";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          transformers-compat unordered-containers xhtml zlib
        ];
        buildTools = [ alex cpphs emacs happy ];
-       jailbreak = true;
        postInstall = ''
          $out/bin/agda -c --no-main $(find $out/share -name Primitive.agda)
          $out/bin/agda-mode compile
···
      }:
      mkDerivation {
        pname = "Allure";
-       version = "0.4.101.1";
-       sha256 = "1wla31n3jiynjb2fk22shq46g365x6il270jqpy234vjz308sdvw";
+       version = "0.5.0.0";
+       sha256 = "0lmkfa6wk0hqin43lf6ll3227c4h7qvya7s6k6sfz8syy51ggqx7";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "Chart";
-       version = "1.5";
-       sha256 = "1h40322g9nj8hlya6iw9dgvvgzbq816v36vm2vz0lii586j0nqyx";
+       version = "1.5.1";
+       sha256 = "0jm1wr2nb1r8rxqc564nmnclns160y7girc7j2ihvyhm0v34p59g";
        buildDepends = [
          array base colour data-default-class lens mtl old-locale
          operational time vector
        ];
-       jailbreak = true;
        homepage = "https://github.com/timbod7/haskell-chart/wiki";
        description = "A library for generating 2D Charts and Plots";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "Chart-cairo";
-       version = "1.5";
-       sha256 = "19p4fg12r91jhhifwlda6rqm2bm0x6bz2fv3dqr2ni1y3cz7v56c";
+       version = "1.5.1";
+       sha256 = "1fwjgms76z2spgfw3kfmzivkgp6gdkx24mp5nb562kza4y6yjz7f";
        buildDepends = [
          array base cairo Chart colour data-default-class lens mtl
          old-locale operational time
        ];
-       jailbreak = true;
        homepage = "https://github.com/timbod7/haskell-chart/wiki";
        description = "Cairo backend for Charts";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "Chart-diagrams";
-       version = "1.5";
-       sha256 = "1i6l6gvy4vlw98b2r5wr5c7dzp01jwca6c5y0pgq663fnp1pwjph";
+       version = "1.5.1";
+       sha256 = "1slsq9p9mq9jxlyhpd90bh32s6fqvy149p4cb7ckygzd77r1aqxz";
        buildDepends = [
          base blaze-markup bytestring Chart colour containers
          data-default-class diagrams-core diagrams-lib diagrams-postscript
          diagrams-svg lens lucid-svg mtl old-locale operational SVGFonts
          text time
        ];
-       jailbreak = true;
        homepage = "https://github.com/timbod7/haskell-chart/wiki";
        description = "Diagrams backend for Charts";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "Chart-gtk";
-       version = "1.5";
-       sha256 = "1iwr31ri4f24yxnmg101y30sg3a03nrmp5nr2id2r471c0f4x2gy";
+       version = "1.5.1";
+       sha256 = "025snbbsnd2gsldw2j8r3vxh94jrv57h8z4qvkq3dwyh2mvq21lw";
        buildDepends = [
          array base cairo Chart Chart-cairo colour data-default-class gtk
          mtl old-locale time
···
      mkDerivation {
        pname = "Diff";
        version = "0.3.2";
+       revision = "1";
        sha256 = "13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz";
+       editedCabalFile = "86ab9f6bcb253cabff2673437995faa4c130be7c3898df778b27a801c5361328";
        buildDepends = [ array base pretty ];
        description = "O(ND) diff algorithm in haskell";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, containers, MonadRandom }:
      mkDerivation {
        pname = "Dist";
-       version = "0.2.0.0";
-       sha256 = "0w9n123rngl85qsgwm0dgqnc0v8zn9lsi2v0n4hfxdvxlhcjr3ir";
+       version = "0.3.0.0";
+       sha256 = "00h0cxlxk72k829w8cf2gi2y4v4qj9bdzdmvnphnvc9wz5pyiz26";
        buildDepends = [ base containers MonadRandom ];
        testDepends = [ base containers MonadRandom ];
-       jailbreak = true;
        homepage = "https://github.com/wyager/Dist";
        description = "A Haskell library for probability distributions";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "Ebnf2ps";
-       version = "1.0.13";
-       sha256 = "1ymfj2n23n1j37p5nw8xwhfccx4xc6wyf3372dr9gxv232jk8znz";
+       version = "1.0.14";
+       sha256 = "0dv7lbw3nb3wyrrq8q4wd26i445ylwiixhhzdl574sw58mw60rk3";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [ array base containers directory old-time unix ];
···
      }:
      mkDerivation {
        pname = "Frames";
-       version = "0.1.2";
-       sha256 = "11444jhck56y2iclgn1daj087qpi99pznk3w82vhbya3pdvrkjac";
+       version = "0.1.2.1";
+       sha256 = "0vw1fh0nqk3s5p08j4cnwb95jgzxk140wvszjlmr3ms9m0xcx61y";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        license = "GPL";
      }) {};
 
+  "GeneralTicTacToe" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "GeneralTicTacToe";
+       version = "0.1.0.1";
+       sha256 = "0dng5shk5zs4j6lyjz971axrqziv6davpcyv509mz8fvdjn8q4kg";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [ base ];
+       jailbreak = true;
+       homepage = "http://afonso.xyz";
+       description = "A general TicTacToe game implementation";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "GenericPretty" = callPackage
     ({ mkDerivation, base, ghc-prim, pretty }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "HList";
-       version = "0.4.0.0";
-       sha256 = "0f6d97vfxlml4dp6zfk95kk4la8xr5m91hiw4zj98kvwvvhb99mz";
+       version = "0.4.1.0";
+       sha256 = "0vbfq2jfdm3dn059flyzxrlhcw7hkni75fpi2gqcl5s6ha95ak10";
        buildDepends = [
          array base ghc-prim mtl profunctors tagged template-haskell
        ];
···
     ({ mkDerivation, base, doctest, hspec, parsec }:
      mkDerivation {
        pname = "HostAndPort";
-       version = "0.1.0";
-       revision = "1";
-       sha256 = "0rykpzp3vvc81ra917vicwsh8x1mr1ykw9a597ks959nmjy06mz8";
-       editedCabalFile = "5ad1783e80502877a1de17cb92308dd9e0cc003a1302c5d4c09103b1c98bd627";
+       version = "0.2.0";
+       sha256 = "1rjv6c7j6fdy6gnn1zr5jnfmiqiamsmjfw9h3bx119giw3sjb9hm";
        buildDepends = [ base parsec ];
        testDepends = [ base doctest hspec ];
        homepage = "https://github.com/bacher09/hostandport";
-       description = "Parser host and port pairs like localhost:22";
+       description = "Parser for host and port pairs like localhost:22";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "JuicyPixels";
-       version = "3.2.5.2";
-       sha256 = "07fyn0ns3g66aqpa1jg1v694yvf5idf7cknrkh30hs312lwm1sjl";
+       version = "3.2.5.3";
+       sha256 = "1knq5jbwggf59h8a6aa758387q71fpzcvssg8dsr84bqwqqg2dpw";
        buildDepends = [
          base binary bytestring containers deepseq mtl primitive
          transformers vector zlib
···
      }:
      mkDerivation {
        pname = "LambdaHack";
-       version = "0.4.101.1";
-       sha256 = "065j2zyqi4adh3f01jywxqvsl45i69ky2y0bavkkpzz2klspg6zw";
+       version = "0.5.0.0";
+       sha256 = "0vzra6020jmir6pqs26fnw2pgap7l10160v5admk7wnrrnfr91r5";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "MoeDict";
-       version = "0.0.2";
-       sha256 = "06dhk0n1v1axj0qbx29n2g9p0nw24ix5ij2vq5nfs7jbrb9m7r0n";
+       version = "0.0.3";
+       sha256 = "0sf7qhw3z984mnprgq2jxqsx9z5v2q36hdb84fdn34rgjzrv3z9a";
        buildDepends = [
          aeson base bytestring containers text unordered-containers
        ];
···
      }) {};
 
   "MonadCompose" = callPackage
-    ({ mkDerivation, base, data-default, ghc-prim, MaybeT, mmorph
-     , monad-products, mtl, random, transformers
+    ({ mkDerivation, base, data-default, ghc-prim, mmorph, monad-loops
+     , monad-products, mtl, parallel, random, transformers
+     , transformers-compat
      }:
      mkDerivation {
        pname = "MonadCompose";
-       version = "0.8.2.0";
-       sha256 = "1nzb4x8az1m4d5i75cshgjfr4xnkfi3s27rq6jkib9i67my0hsrq";
+       version = "0.8.3.1";
+       sha256 = "0njvbz2cwc3339h87wxhl5kzb2v1ny5skqvhrsdzp95f1k8chnxa";
        buildDepends = [
-         base data-default ghc-prim MaybeT mmorph monad-products mtl random
-         transformers
+         base data-default ghc-prim mmorph monad-loops monad-products mtl
+         parallel random transformers transformers-compat
        ];
-       jailbreak = true;
        homepage = "http://alkalisoftware.net";
        description = "Methods for composing monads";
        license = stdenv.lib.licenses.bsd3;
···
        license = "LGPL";
      }) {};
 
+  "MyPrimes" = callPackage
+    ({ mkDerivation, base, containers }:
+     mkDerivation {
+       pname = "MyPrimes";
+       version = "0.1.0.0";
+       sha256 = "1bwq0fwhkw4i2kjx9xbdfn0y86j9s78kyrw9vlxq7zmv4pddazly";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [ base containers ];
+       jailbreak = true;
+       homepage = "http://afonso.xyz";
+       description = "Generate all primes";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "NGrams" = callPackage
     ({ mkDerivation, base, HCL, HTTP, network, regex-compat }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "Neks";
-       version = "0.4.0.0";
-       sha256 = "0xi5d9wvk2xzsn500d61b6mmvwd36fs2n92l5qy4hzhww5lmkrrb";
+       version = "0.5.0.0";
+       sha256 = "083hkcgmrk42pyjm1xz1amdjpmccw0c72axmkk163ar6ir7aznc8";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          base bytestring cereal containers directory hashable messagepack
          network stm vector
        ];
-       jailbreak = true;
        description = "Simple networked key/value store";
        license = stdenv.lib.licenses.mit;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "OrchestrateDB" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, HTTP, http-conduit
+     , http-types, lifted-base, random
+     }:
+     mkDerivation {
+       pname = "OrchestrateDB";
+       version = "1.0.0.3";
+       sha256 = "0d12jbdgpfkzax5c8djab6n611hcwi1bkphwmn5qmny43fb3wsaz";
+       buildDepends = [
+         aeson base bytestring HTTP http-conduit http-types lifted-base
+       ];
+       testDepends = [
+         aeson base bytestring HTTP http-conduit http-types lifted-base
+         random
+       ];
+       homepage = "https://github.com/dwd31415/Haskell-OrchestrateDB";
+       description = "Unofficial Haskell Client Library for the Orchestrate.io API";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "OrderedBits" = callPackage
     ({ mkDerivation, base, bits, primitive, QuickCheck, test-framework
      , test-framework-quickcheck2, test-framework-th, vector
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "Phsu" = callPackage
+    ({ mkDerivation, acid-state, aeson, base, blaze-html, blaze-markup
+     , containers, curl, filepath, friendly-time, happstack-server
+     , happstack-server-tls, lifted-base, MissingH, monad-control, mtl
+     , network, network-uri, old-locale, process, regex-base, regex-pcre
+     , safecopy, string-conversions, temporary, text, time
+     }:
+     mkDerivation {
+       pname = "Phsu";
+       version = "0.1.0.3";
+       sha256 = "12f6hqgxyf3svr53g0irn15q69wp9py1bxfw3a5inpkqzmrs04x9";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         acid-state aeson base blaze-html blaze-markup containers curl
+         filepath friendly-time happstack-server happstack-server-tls
+         lifted-base MissingH monad-control mtl network network-uri
+         old-locale process regex-base regex-pcre safecopy
+         string-conversions temporary text time
+       ];
+       jailbreak = true;
+       homepage = "localhost:9119";
+       description = "Personal Happstack Server Utils";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "Pipe" = callPackage
     ({ mkDerivation, base, filepath, process, unix }:
      mkDerivation {
···
   "Spock" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , case-insensitive, containers, directory, hashable, hspec
-     , hspec-wai, http-types, list-t, monad-control, mtl, old-locale
-     , path-pieces, random, reroute, resource-pool, resourcet, stm
-     , stm-containers, text, time, transformers, transformers-base
-     , unordered-containers, vault, wai, wai-extra, warp
+     , hspec-wai, http-types, hvect, list-t, monad-control, mtl
+     , old-locale, path-pieces, random, reroute, resource-pool
+     , resourcet, stm, stm-containers, text, time, transformers
+     , transformers-base, unordered-containers, vault, wai, wai-extra
+     , warp
      }:
      mkDerivation {
        pname = "Spock";
-       version = "0.7.10.0";
-       sha256 = "0agis3cy6ijynbzgwyc2wd08db16yz0qhcjj41l6d7a6804ns8nj";
+       version = "0.7.12.0";
+       sha256 = "05vglqzf75dphxx2wnkxqn7aqcb19nh8g560zfpw56jrfbbmygwg";
        buildDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
-         directory hashable http-types list-t monad-control mtl old-locale
-         path-pieces random reroute resource-pool resourcet stm
+         directory hashable http-types hvect list-t monad-control mtl
+         old-locale path-pieces random reroute resource-pool resourcet stm
          stm-containers text time transformers transformers-base
          unordered-containers vault wai wai-extra warp
        ];
···
     ({ mkDerivation, base, stm }:
      mkDerivation {
        pname = "Updater";
-       version = "0.1";
-       sha256 = "0wd6ydj6s44mxncg817f9ar4cwxjxakb9m5a4p6yxhzgkwcl7hp2";
+       version = "0.2";
+       sha256 = "03n2r02bgv9hzlvxypdy1mrvdmzrxlm717bf7qp9f9ky1sj3ixp4";
        buildDepends = [ base stm ];
        homepage = "https://github.com/yokto/Updater";
        description = "Monadic FRP library based on stm";
···
      }:
      mkDerivation {
        pname = "Win32";
-       version = "2.3.0.2";
-       sha256 = "0s2hp50yb91cmj78shpp7s7v096y6lnipk4j7h3lxph3zgj06zsi";
+       version = "2.3.1.0";
+       sha256 = "1y9z682gmgjkrc8lijkidrlwh5pr30zgpvx2sc3gnvn8krg6jnk8";
        buildDepends = [ base bytestring ];
        extraLibraries = [ advapi32 gdi32 shell32 shfolder user32 winmm ];
        homepage = "https://github.com/haskell/win32";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) { inherit (pkgs) readline;};
 
+  "ZEBEDDE" = callPackage
+    ({ mkDerivation, base, vect }:
+     mkDerivation {
+       pname = "ZEBEDDE";
+       version = "0.1.0.0";
+       sha256 = "1i85pah79342ivmcg73q305awbf9fi6gw4ckg9i019d6vmdg5d17";
+       buildDepends = [ base vect ];
+       jailbreak = true;
+       description = "Polymer growth simulation method";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "ZFS" = callPackage
     ({ mkDerivation, base, CC-delcont, containers, mtl, network, unix
      }:
···
      }:
      mkDerivation {
        pname = "abcBridge";
-       version = "0.12";
-       sha256 = "1432hjaj0fccsd16if0wyiayp9wj66gam6c48fc1lgnqc5lvw5jj";
+       version = "0.14";
+       sha256 = "1ki5h3058n3kpvaspl8g1vadprw6kb3xxyadb3a4k1irkfz8lfkf";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [ aig base containers directory vector ];
···
     ({ mkDerivation, base, mtl, QuickCheck, vector }:
      mkDerivation {
        pname = "aig";
-       version = "0.2.1";
-       sha256 = "0wcqw5scaw2ximhbv9pnpngdlr36adci7hpqwj9haa9ql5pwqqxk";
+       version = "0.2.3";
+       sha256 = "0363wr5fnryz49ksj6mvwngpqi2bj7ldgyzh6hgvmvvdz5nmmxzr";
        buildDepends = [ base mtl QuickCheck vector ];
        description = "And-inverter graphs in Haskell";
        license = stdenv.lib.licenses.bsd3;
···
        sha256 = "1fhk5ydnf0l0n579gqg5lfg2cc9z8xbgqsqzgkpcw0046kp53rjw";
        buildDepends = [ alloy base mtl ];
        description = "Some add-on instances for the Alloy library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "almost-fix" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "almost-fix";
+       version = "0.0.2";
+       sha256 = "03x715jcrsxfs2d08hsg3y5f6a4bnlzfxsmhzimvpdp9bw0psn90";
+       buildDepends = [ base ];
+       description = "Recurse while a predicate is satisfied";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
     ({ mkDerivation, amazonka-core, base }:
      mkDerivation {
        pname = "amazonka-ec2";
-       version = "0.3.6";
-       sha256 = "050gspxplhch66awd7gmxyyy3s466ca3jbzp2yq4qh32dn7n1hvi";
+       version = "0.3.6.1";
+       sha256 = "19gyqga1qp50jsi6pykykkivfz18357p6pd6fg84bir0j9d4vawy";
        buildDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Elastic Compute Cloud SDK";
···
     ({ mkDerivation, amazonka-core, base }:
      mkDerivation {
        pname = "amazonka-route53";
-       version = "0.3.6";
-       sha256 = "1xk44z5zp8pr2hyhdshzgwm572y33f9lvjz6yrglc4vpangslcx3";
+       version = "0.3.6.1";
+       sha256 = "155d4yfc96x99mw8h89n2waj7ywx4hcw8izcx1sk1x96lcd6h9mw";
        buildDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Route 53 SDK";
···
      }:
      mkDerivation {
        pname = "applicative-fail";
-       version = "1.1.0";
-       sha256 = "0slxvf7iah7k8mpap6sc1kfibgah8pjls5z82zf62kf7ywzqmfkf";
+       version = "1.1.1";
+       sha256 = "11bk0svzdys8rgx6nzb80fkxz8mp6r0238ylmb5wzsnl8nc9y041";
        buildDepends = [
          base bifunctors dlist mtl transformers transformers-base
        ];
        testDepends = [
          base checkers mtl QuickCheck tasty tasty-quickcheck
        ];
-       jailbreak = true;
        homepage = "https://bitbucket.org/s9gf4ult/applicative-fail";
        description = "Applicative functor and monad which collects all your fails";
        license = stdenv.lib.licenses.bsd3;
···
   "avers" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
      , bytestring, clock, containers, cryptohash, filepath, hspec
-     , inflections, MonadRandom, mtl, network, resource-pool
-     , rethinkdb-client-driver, scrypt, stm, template-haskell, text
-     , time, unordered-containers, vector
+     , inflections, MonadRandom, mtl, network, network-uri
+     , resource-pool, rethinkdb-client-driver, safe, scrypt, stm
+     , template-haskell, text, time, unordered-containers, vector
      }:
      mkDerivation {
        pname = "avers";
-       version = "0.0.8";
-       sha256 = "1wnhzkjwp6243mqfwxmw8lhs59vn5v0544hsivcfps427cqamrbq";
+       version = "0.0.9";
+       sha256 = "0zcgq4b20vvg2mqm9yqm4gvakafn9r8mghki8bn87xhk0w7h99km";
        buildDepends = [
          aeson attoparsec base base16-bytestring bytestring clock containers
-         cryptohash filepath inflections MonadRandom mtl network
-         resource-pool rethinkdb-client-driver scrypt stm template-haskell
-         text time unordered-containers vector
+         cryptohash filepath inflections MonadRandom mtl network network-uri
+         resource-pool rethinkdb-client-driver safe scrypt stm
+         template-haskell text time unordered-containers vector
        ];
        testDepends = [
          aeson attoparsec base base16-bytestring bytestring containers
···
          rethinkdb-client-driver scrypt stm text time unordered-containers
          vector
        ];
-       jailbreak = true;
        description = "empty";
        license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }) {};
 
   "base-orphans" = callPackage
-    ({ mkDerivation, base, ghc-prim, hspec }:
+    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
      mkDerivation {
        pname = "base-orphans";
-       version = "0.4.0";
-       sha256 = "06knj296mkhbmfr0b12pfvhzr0bk8p1avabh1llwmx67nnn41r5i";
+       version = "0.4.2";
+       sha256 = "1mfmhvb7zvyi3m5660755ph7xk4fdvhki6ssfd3i2ghzas8g1v7a";
        buildDepends = [ base ghc-prim ];
-       testDepends = [ base hspec ];
+       testDepends = [ base hspec QuickCheck ];
        homepage = "https://github.com/haskell-compat/base-orphans#readme";
        description = "Backwards-compatible orphan instances for base";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "basex-client" = callPackage
+    ({ mkDerivation, base, network, pureMD5, utf8-string }:
+     mkDerivation {
+       pname = "basex-client";
+       version = "0.1.0.0";
+       sha256 = "189bmv479fmljy9w7nhc5mb7546iz8vahrmxffvgny51ywklk58n";
+       buildDepends = [ base network pureMD5 utf8-string ];
+       description = "A BaseX client for Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "bash" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers
      , hxt-regex-xmlschema, mtl, SHA, shell-escape
···
      }) {};
 
   "bet" = callPackage
-    ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
-     , exceptions, HsOpenSSL, http-client-openssl, lens, mtl, pipes
-     , pipes-http, QuickCheck, semigroupoids, semigroups, test-framework
-     , test-framework-quickcheck2, test-framework-th, text, time
+    ({ mkDerivation, aeson, base, bifunctors, binary, bytestring
+     , containers, exceptions, HsOpenSSL, http-client
+     , http-client-openssl, lens, mtl, QuickCheck, semigroupoids
+     , semigroups, test-framework, test-framework-quickcheck2
+     , test-framework-th, text, time
      }:
      mkDerivation {
        pname = "bet";
-       version = "0.1.2.2";
-       sha256 = "1sk8sgfcywxr54g25ah978k0d1x263mzi69zbx5wk67bs4sqvmds";
+       version = "0.1.2.3";
+       sha256 = "0gy12m81bc6vgzq4m0v134jbq5lw1210dxsq4s28c0www0kxj658";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         aeson base bifunctors bytestring containers exceptions HsOpenSSL
-         http-client-openssl lens mtl pipes pipes-http semigroupoids
+         aeson base bifunctors binary bytestring containers exceptions
+         HsOpenSSL http-client http-client-openssl lens mtl semigroupoids
          semigroups text time
        ];
        testDepends = [
          base lens QuickCheck semigroups test-framework
          test-framework-quickcheck2 test-framework-th
        ];
-       jailbreak = true;
        homepage = "https://github.com/Noeda/bet/";
        description = "Betfair API bindings. Bet on sports on betting exchanges.";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "binary_0_7_5_0" = callPackage
+  "binary_0_7_6_1" = callPackage
     ({ mkDerivation, array, base, bytestring, Cabal, containers
      , directory, filepath, HUnit, QuickCheck, random, test-framework
      , test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "binary";
-       version = "0.7.5.0";
-       sha256 = "06gg61srfva7rvzf4s63c068s838i5jf33d6cnjb9769gjmca2a7";
+       version = "0.7.6.1";
+       sha256 = "0rqhz349w72h1bi79lga5x1d95g59h15srlahxbhfrmy2pycm1cg";
        buildDepends = [ array base bytestring containers ];
        testDepends = [
          array base bytestring Cabal containers directory filepath HUnit
···
      }:
      mkDerivation {
        pname = "blaze-html";
-       version = "0.8.0.2";
-       sha256 = "1h3z857kqj9h87zyi84pck2rnykfk7i4amlh0vkv5wws5zn9xs74";
+       version = "0.8.1.0";
+       sha256 = "0cgddwdwjszhcd3grfxazvy6jwaxa90s8yw6ir9ji2apbdsw0vgv";
        buildDepends = [ base blaze-builder blaze-markup bytestring text ];
        testDepends = [
          base blaze-builder blaze-markup bytestring containers HUnit
···
     ({ mkDerivation, aeson, base, binary, blaze-html, bytestring
      , configurator, cryptohash, directory, hashtables, http-types, mtl
      , random, Spock, text, transformers, wai, wai-extra
-     , wai-middleware-static, warp, xdg-basedir
+     , wai-middleware-static, warp, warp-tls, xdg-basedir
      }:
      mkDerivation {
        pname = "breve";
-       version = "0.3.0.0";
-       sha256 = "14vhwicdi1cln594bfhhj65kwaxmimpzg4jh35mrycw0fpbfk6rp";
+       version = "0.4.0.0";
+       sha256 = "1ndzqwxj7dzff75mgjssh7sgrhxlicdwkcx8j71x52rxyav4aa0j";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
          aeson base binary blaze-html bytestring configurator cryptohash
          directory hashtables http-types mtl random Spock text transformers
-         wai wai-extra wai-middleware-static warp xdg-basedir
+         wai wai-extra wai-middleware-static warp warp-tls xdg-basedir
        ];
        homepage = "https://github.com/rnhmjoj/breve";
        description = "a url shortener";
···
      }:
      mkDerivation {
        pname = "cabal-helper";
-       version = "0.3.6.0";
-       sha256 = "1c6pdrq8ypy9halw6cqdasr0zdr0hdb76h66vs9g0qkqqbpgiyyq";
+       version = "0.3.7.0";
+       sha256 = "1lq8i45wvk8rqilay7j9i9iv5irhqvdg3bp96mj2xxaxrpfi7l20";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "cassandra-cql";
-       version = "0.5.0.1";
-       sha256 = "0n1w1hriscrjky3d4qwzzm3p41yg9gvnxyq9sfm3kb7lijc4xj2d";
+       version = "0.5.0.2";
+       sha256 = "1nk0psvmzhvxls4h0p4blrm8qjn6lyh08bdxpiagpw6nrpvbda54";
        buildDepends = [
          base bytestring cereal containers cryptohash Decimal hslogger
          MonadCatchIO-transformers mtl network resource-pool stm text time
···
      }) {};
 
   "cgrep" = callPackage
-    ({ mkDerivation, ansi-terminal, array, base, bytestring, cmdargs
-     , containers, directory, dlist, either, filepath, ghc-prim, mtl
-     , regex-posix, safe, split, stm, stringsearch, unix-compat
+    ({ mkDerivation, ansi-terminal, array, async, base, bytestring
+     , cmdargs, containers, directory, dlist, either, filepath, ghc-prim
+     , mtl, regex-posix, safe, split, stm, stringsearch, unix-compat
      , unordered-containers
      }:
      mkDerivation {
        pname = "cgrep";
-       version = "6.4.20";
-       sha256 = "1p0nm6gb7hvxvfkgrync1a66zl58s041pgnkly2vx91cpm6yavcm";
+       version = "6.5.2";
+       sha256 = "021cwllz5cljb9j0klh3xn4jpg2vxfqwqyjm631gkpzndc9711wr";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
-         ansi-terminal array base bytestring cmdargs containers directory
-         dlist either filepath ghc-prim mtl regex-posix safe split stm
-         stringsearch unix-compat unordered-containers
+         ansi-terminal array async base bytestring cmdargs containers
+         directory dlist either filepath ghc-prim mtl regex-posix safe split
+         stm stringsearch unix-compat unordered-containers
        ];
        homepage = "http://awgn.github.io/cgrep/";
        description = "Command line tool";
···
 
   "clafer" = callPackage
     ({ mkDerivation, aeson, array, base, bytestring, cmdargs
-     , containers, data-stringmap, directory, executable-path, filepath
-     , ghc, HaXml, HTTP, HUnit, json-builder, lens, lens-aeson, mtl
+     , containers, data-stringmap, directory, doctest, executable-path
+     , filepath, ghc, HTTP, HUnit, json-builder, lens, lens-aeson, mtl
      , network, network-uri, parsec, process, QuickCheck, split
      , string-conversions, tasty, tasty-hunit, tasty-th, text
      , transformers
      }:
      mkDerivation {
        pname = "clafer";
-       version = "0.3.10";
-       sha256 = "0f780l5nh3r93w4ikxliqjg70ih4k4j00s7f4nj1li0dv6bprc3x";
+       version = "0.4.0";
+       sha256 = "1xnjvqwdp7679hr6jkl6xnsrdidw494p1xr8mlng6gybflm8v9gn";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          aeson array base bytestring cmdargs containers data-stringmap
-         directory executable-path filepath HaXml HTTP json-builder lens
+         directory executable-path filepath HTTP json-builder lens
          lens-aeson mtl network network-uri parsec process split
          string-conversions text transformers
        ];
        testDepends = [
-         base containers data-stringmap directory filepath ghc HaXml HUnit
+         base containers data-stringmap directory doctest filepath ghc HUnit
          lens lens-aeson mtl QuickCheck tasty tasty-hunit tasty-th
        ];
        homepage = "http://clafer.org";
-       description = "clafer compiles Clafer models to other formats, such as Alloy, XML, HTML, Dot";
+       description = "Compiles Clafer models to other formats: Alloy, JavaScript, JSON, HTML, Dot";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "claferIG";
-       version = "0.3.10";
-       sha256 = "17g4jdfla0x90y2jn54yk56h6ih3d1jk4fzdpfvh85xs6dh79n0x";
+       version = "0.4.0";
+       sha256 = "01ilmmhz1wd142qpclk1b5nksm6cacr07pdj5cl5prfv7y04k9nw";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "claferwiki";
-       version = "0.3.10";
-       sha256 = "0v0nad7n3m8gs3l7prv2kwqzdp93g309j4l3l3dv1ibfnf5jr2l9";
+       version = "0.4.0";
+       sha256 = "1in0lzph5h7v9z9b974ibzh0rq7j343q474i9zfkylmdd1aivdyh";
        buildDepends = [
          base clafer containers directory gitit MissingH mtl network
          network-uri process SHA split time transformers utf8-string
···
      }:
      mkDerivation {
        pname = "clash-ghc";
-       version = "0.5.10";
-       sha256 = "02zv08mkx228fxx1hdraaqmiv1mfq6rgsr3gflh0awyf6x5g6jzn";
+       version = "0.5.11";
+       sha256 = "1lwc47b2iw2l7djga11gp4xdikb8gycqv4fxz1cxrf23xzkg5ggg";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "clash-lib";
-       version = "0.5.9";
-       sha256 = "1kh40vy5sqxpb2akzwyc7k7z251lg3h3a12qj2vq4vkgwx5xcqkh";
+       version = "0.5.10";
+       sha256 = "039j561r7kgrd5b7z55axgjniwm5yi5y1y0azps4ipmvjsvalbdl";
        buildDepends = [
          aeson attoparsec base bytestring clash-prelude concurrent-supply
          containers deepseq directory errors fgl filepath hashable lens mtl
···
      }:
      mkDerivation {
        pname = "clash-prelude";
-       version = "0.9.1";
-       sha256 = "00d4ap4jfw1298g59sfywkjza33s5p5p4n2nc69anwc31lxqnss8";
+       version = "0.9.2";
+       sha256 = "1gl75mbqpv5g5dwg2c2vvqn36ydwhkcv7g6i8gjm41500dsrky0i";
        buildDepends = [
          array base data-default ghc-prim ghc-typelits-natnormalise
          integer-gmp lens QuickCheck singletons template-haskell th-lift
···
      }:
      mkDerivation {
        pname = "comonad";
-       version = "4.2.7";
-       revision = "1";
-       sha256 = "03h36hr7vgxxyxfp9yc87vahbm3d6chvrkcrjh5abxg6i42aflma";
-       editedCabalFile = "70542238a847c5b973832fa7e5623a76a485df25b36d511bfd5f5116e4014619";
+       version = "4.2.7.2";
+       sha256 = "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp";
        buildDepends = [
          base containers contravariant distributive semigroups tagged
          transformers transformers-compat
        ];
        testDepends = [ base directory doctest filepath ];
-       jailbreak = true;
        homepage = "http://github.com/ekmett/comonad/";
        description = "Comonads";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "conduit-combinators";
-       version = "1.0.1.1";
-       sha256 = "02x0n4yar1s3x73pbaxs6ghd5kihl3wz3svrvvm24xnmwv5j9aaz";
+       version = "1.0.2";
+       sha256 = "1yfck6syqqi5zlp41n3qs8w5ljg63jhg25m8irrcks35n9i541j5";
        buildDepends = [
          base base16-bytestring base64-bytestring bytestring chunked-data
          conduit conduit-extra filepath monad-control mono-traversable
···
      }:
      mkDerivation {
        pname = "consumers";
-       version = "0.1";
-       sha256 = "0y977lhxcaxjw6c760fifmisxn62lji0qs8aqgyag6jmzmkfymdb";
+       version = "1.0";
+       sha256 = "1f7jn9lja9fsznjz7d3wfhbd0dc8whcx9jl74jl39mv20k2sdhib";
        buildDepends = [
          base containers exceptions hpqtypes lifted-base lifted-threads log
          monad-control mtl stm time transformers-base
···
      }:
      mkDerivation {
        pname = "contravariant";
-       version = "1.3.1.1";
-       sha256 = "0kjfild3zp34w745p79658i84k45cg9qjhv154sa0plqgk2vmdfs";
+       version = "1.3.2";
+       sha256 = "0fb6az12604vwvfhnmvxfin68n0fb2jcvrliv3vvrmfnfq3axfjj";
        buildDepends = [
          base semigroups StateVar transformers transformers-compat void
        ];
···
      }:
      mkDerivation {
        pname = "coordinate";
-       version = "0.0.18";
-       sha256 = "0avag247d74qwy6gikcmva5k41iriba42rkxik781dsnp2caxq1f";
+       version = "0.0.19";
+       sha256 = "01f6dmyx2kqyzf1n06awcyx0ygqgy829snxw6bbxbvih9yhkjq2r";
        buildDepends = [ base lens radian tagged transformers ];
        testDepends = [
          base directory doctest filepath QuickCheck template-haskell
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "cpio-conduit" = callPackage
+    ({ mkDerivation, base, base16-bytestring, binary, bytestring
+     , conduit, conduit-extra, resourcet
+     }:
+     mkDerivation {
+       pname = "cpio-conduit";
+       version = "0.7.0";
+       sha256 = "04zma03ivg9x5f1xkdpc828fk2lh6qrn7cig7gprci13id9yf2wg";
+       buildDepends = [
+         base base16-bytestring binary bytestring conduit conduit-extra
+       ];
+       testDepends = [
+         base base16-bytestring binary bytestring conduit conduit-extra
+         resourcet
+       ];
+       homepage = "http://github.com/da-x/cpio-conduit";
+       description = "Conduit-based CPIO";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "cplusplus-th" = callPackage
     ({ mkDerivation, base, bytestring, containers, process, QuickCheck
      , template-haskell
···
      }:
      mkDerivation {
        pname = "cpphs";
-       version = "1.19";
-       sha256 = "0fiyqyy7zzzbp0jsgl3syvm5db8n42h88ps7qzayxbsycjz9fp70";
+       version = "1.19.2";
+       sha256 = "194hcvhjgm6rmbqp857y3j39lvl2p91mqrrgpi15jq00icnv4idv";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [ base directory old-locale old-time polyparse ];
···
     ({ mkDerivation, array, base, containers, parallel }:
      mkDerivation {
        pname = "cpsa";
-       version = "2.5.1";
-       sha256 = "1lgscv3jkfzr35fwx7aymsgjg3i3sszxdc0hxmrbna8ba509cizk";
+       version = "2.5.2";
+       sha256 = "0zm2waj17ak43rhri9rhvwy970dv22r0k42fzbm3n6gcl5h2mcq5";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [ array base containers parallel ];
···
   "cql" = callPackage
     ({ mkDerivation, base, bytestring, cereal, Decimal, iproute
      , network, QuickCheck, tasty, tasty-quickcheck, template-haskell
-     , text, time, transformers, uuid
+     , text, time, transformers, uuid, vector
      }:
      mkDerivation {
        pname = "cql";
-       version = "3.0.4";
-       sha256 = "0b4yfmfxb4j039s5il321bc65dmbcbxqvaiqk97ly4fcc8pmdld9";
+       version = "3.0.5";
+       sha256 = "12v5hhlji9w73chxdhazpmhbaxmjs98lw1y6cm8p29bgxdi75q61";
        buildDepends = [
          base bytestring cereal Decimal iproute network template-haskell
-         text time transformers uuid
+         text time transformers uuid vector
        ];
        testDepends = [
          base bytestring cereal Decimal iproute network QuickCheck tasty
···
      }:
      mkDerivation {
        pname = "cql-io";
-       version = "0.14.4";
-       sha256 = "09nkp0c8brh87x93ib5ss010kh2izzs05ad7gmf7q54zw6qxask2";
+       version = "0.14.5";
+       sha256 = "0ks2sn3dfrr8ilvmw48hfz3140x9dsi79w6ci4vfksn1g5ndnpiy";
        buildDepends = [
          async auto-update base bytestring containers cql cryptohash
          data-default-class exceptions hashable iproute lens monad-control
···
 
   "creatur" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, cereal, cond
-     , directory, filepath, gray-extended, hdaemonize, hsyslog, HUnit
-     , MonadRandom, mtl, old-locale, process, QuickCheck, random, split
-     , temporary, test-framework, test-framework-hunit
+     , directory, exceptions, filepath, gray-extended, hdaemonize
+     , hsyslog, HUnit, MonadRandom, mtl, old-locale, process, QuickCheck
+     , random, split, temporary, test-framework, test-framework-hunit
      , test-framework-quickcheck2, time, transformers, unix, zlib
      }:
      mkDerivation {
        pname = "creatur";
-       version = "5.9.7";
-       sha256 = "1617whwg9f0l6ji3jmd7fcs3n650mz0jpvrw4hf97r7mqzlyfkjp";
+       version = "5.9.8.2";
+       sha256 = "15cjk5hb4j7ydsis8fz7gag3sa17i6yr26pfbf8aqkw7iakmjqs9";
        buildDepends = [
-         array base bytestring cereal cond directory filepath gray-extended
-         hdaemonize hsyslog MonadRandom mtl old-locale process random split
-         time transformers unix zlib
+         array base bytestring cereal cond directory exceptions filepath
+         gray-extended hdaemonize hsyslog MonadRandom mtl old-locale process
+         random split time transformers unix zlib
        ];
        testDepends = [
          array base binary cereal directory filepath hsyslog HUnit
···
      }:
      mkDerivation {
        pname = "cryptonite";
-       version = "0.5";
-       sha256 = "17b2axxb9i9cmwjhji1lm5nwhqm2wikxzy1cwmk2v8h64dy0rjc5";
+       version = "0.6";
+       sha256 = "0lzqmhslq1pwj6pp82l3vdnnxbqvh0bqjyl02x2yp6sp72mcq5m0";
        buildDepends = [
          base bytestring deepseq ghc-prim integer-gmp memory
        ];
···
      }:
      mkDerivation {
        pname = "csound-expression";
-       version = "4.8.1";
-       sha256 = "0mag076inyg9hs37anq7g7545wfjaphk831h8jj1fykp8iag95l4";
+       version = "4.8.2";
+       sha256 = "1zhx4smvs8xnqfcv2hxhq57n16cl3sycz659viw8l6v8f36ibj5i";
        buildDepends = [
          base Boolean colour csound-expression-dynamic
          csound-expression-opcodes csound-expression-typed data-default
···
      }:
      mkDerivation {
        pname = "csound-expression-opcodes";
-       version = "0.0.2";
-       sha256 = "0friwwx0ia2wk75ylmvlladswqfwhza8grsbnqfn5q8ffsjv632r";
+       version = "0.0.3";
+       sha256 = "0f7nwrnrpsi31q9vaxy2yihripzqjzp6683qy94ljkmxmfnm9sb5";
        buildDepends = [
          base csound-expression-dynamic csound-expression-typed transformers
        ];
···
      }:
      mkDerivation {
        pname = "csound-expression-typed";
-       version = "0.0.7.6";
-       sha256 = "01zi1hychx6vinxpqh7zdcj6jrlcpp86v7cmdzzq42z44apg8d3y";
+       version = "0.0.7.7";
+       sha256 = "1z9hvkgl6lqwrdhngq79425s2frhkg4llkcpsar21d5ld4fhzfdl";
        buildDepends = [
          base Boolean colour containers csound-expression-dynamic
          data-default deepseq ghc-prim stable-maps temporal-media
···
      }) {};
 
   "delta" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath
+    ({ mkDerivation, base, containers, directory, filepath, hspec
      , optparse-applicative, process, sodium, time
      }:
      mkDerivation {
        pname = "delta";
-       version = "0.2.1.1";
-       sha256 = "06msfi733jmqqgxyx5p4mifjgxrgh0x8ls4j0fkcan5377sydjcv";
+       version = "0.2.1.2";
+       revision = "2";
+       sha256 = "0r2a2vffs3rn2xp56nhanyywzbm2wph5664spgj4lbsna6zgjnfj";
+       editedCabalFile = "630e85a07132fe54b49c71f855b3d633982026d78120279e00888bc95a9d14dd";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          base containers directory filepath optparse-applicative process
          sodium time
        ];
+       testDepends = [ base directory filepath hspec ];
        homepage = "https://github.com/kryoxide/delta";
        description = "A library for detecting file changes";
        license = stdenv.lib.licenses.gpl3;
···
      }:
      mkDerivation {
        pname = "dependent-sum-template";
-       version = "0.0.0.3";
-       sha256 = "0if3mr0cmaz3yc0hbn0fpx14kwnjsaj3hd8mw9z4va4qp85wya69";
+       version = "0.0.0.4";
+       sha256 = "103jxzzw3drg7pkgmh39s7258zcwr8ixg8mijm6p33b87a8wdpwr";
        buildDepends = [ base dependent-sum template-haskell th-extras ];
        homepage = "/dev/null";
        description = "Template Haskell code to generate instances of classes in dependent-sum package";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "deriving-compat" = callPackage
+    ({ mkDerivation, base, base-compat, containers, ghc-prim, hspec
+     , QuickCheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "deriving-compat";
+       version = "0.1";
+       sha256 = "1v503lj9dds1hwnqhmw8rfbj9337gcyqqzys1d93r7s0bs3glgf3";
+       buildDepends = [ base containers ghc-prim template-haskell ];
+       testDepends = [ base base-compat hspec QuickCheck ];
+       homepage = "https://github.com/haskell-compat/deriving-compat";
+       description = "Backports of GHC deriving extensions";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "derp" = callPackage
     ({ mkDerivation, base, containers }:
      mkDerivation {
···
     ({ mkDerivation, base, hspec, mtl }:
      mkDerivation {
        pname = "deterministic-game-engine";
-       version = "0.2.1";
-       sha256 = "0igs10h0mj8xxw9z57icx4y7mb7ag6m4cg7qiqk3b41xipxqn1ig";
+       version = "0.4.0";
+       sha256 = "1hdwr1vxfng3yc9mdnnsraapikq9kq1c07ik16csgp2ggnhgpprs";
        buildDepends = [ base mtl ];
        testDepends = [ base hspec ];
        homepage = "https://github.com/TGOlson/deterministic-game-engine";
···
          process semigroups system-filepath tagged text transformers
          unordered-containers
        ];
+       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams";
        description = "Embedded domain-specific language for declarative graphics";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "diagrams-pandoc" = callPackage
+    ({ mkDerivation, base, diagrams-builder, diagrams-cairo
+     , diagrams-lib, directory, filepath, linear, optparse-applicative
+     , pandoc-types
+     }:
+     mkDerivation {
+       pname = "diagrams-pandoc";
+       version = "0.1";
+       sha256 = "02dz0w2im68667v5k1ykdnl3cijvqfd5pgb7qqdyyizkgza88pb4";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         base diagrams-builder diagrams-cairo diagrams-lib directory
+         filepath linear optparse-applicative pandoc-types
+       ];
+       description = "A pandoc filter to express diagrams inline using the haskell EDSL _diagrams_";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
 
   "dump" = callPackage
     ({ mkDerivation, base, haskell-src-meta, hspec
-     , interpolatedstring-perl6, template-haskell, text
+     , interpolatedstring-perl6, QuickCheck, template-haskell, text
      }:
      mkDerivation {
        pname = "dump";
-       version = "0.2.6";
-       sha256 = "0rhjx4g83pbm0zfqgz8ykfccaq8wa7wspjc6k1n4d1bgcwkc617y";
+       version = "0.2.8";
+       sha256 = "0p0wwcxm2lgfbx82s226dprd8qa526pnrnpakxmdz5svd6ib0gh4";
        buildDepends = [
          base haskell-src-meta interpolatedstring-perl6 template-haskell
          text
        ];
        testDepends = [
-         base haskell-src-meta hspec interpolatedstring-perl6
+         base haskell-src-meta hspec interpolatedstring-perl6 QuickCheck
          template-haskell text
        ];
        homepage = "https://github.com/Wizek/dump";
···
      }) {};
 
   "ekg" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, ekg-core, filepath
-     , network, snap-core, snap-server, text, time, transformers
-     , unordered-containers
+    ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json
+     , filepath, network, snap-core, snap-server, text, time
+     , transformers, unordered-containers
      }:
      mkDerivation {
        pname = "ekg";
-       version = "0.4.0.7";
-       sha256 = "0isq39a1c8laiigxi5yqv7d6798xc828xh4p0zan0a6m6glrmygr";
+       version = "0.4.0.8";
+       sha256 = "0cp88b5bf4bpjd6qzib00n7j76svwsykzizk52fk1dmknfx8h12v";
        buildDepends = [
-         aeson base bytestring ekg-core filepath network snap-core
+         aeson base bytestring ekg-core ekg-json filepath network snap-core
          snap-server text time transformers unordered-containers
        ];
        homepage = "https://github.com/tibbe/ekg";
···
      }:
      mkDerivation {
        pname = "ekg-core";
-       version = "0.1.0.4";
-       sha256 = "04ym37hc2l3k185dbkmfa4n7ya412cgc5zf0kynwgfvdwggjnxwh";
+       version = "0.1.1.0";
+       sha256 = "07h6lwig1cwb526ack1g3f6w8irmaj4kibn11ihhdffk7avix8bv";
        buildDepends = [
          base containers ghc-prim text unordered-containers
        ];
        homepage = "https://github.com/tibbe/ekg-core";
        description = "Tracking of system metrics";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "ekg-json" = callPackage
+    ({ mkDerivation, aeson, base, ekg-core, text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "ekg-json";
+       version = "0.1.0.0";
+       sha256 = "1nhqlajidg94zk6rs86ri5ar4cmkbdz04hwjp8qgam0vgpp5bi2j";
+       buildDepends = [ aeson base ekg-core text unordered-containers ];
+       homepage = "https://github.com/tibbe/ekg-json";
+       description = "JSON encoding of ekg metrics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }) {};
 
   "engine-io-wai" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, engine-io
-     , http-types, mtl, text, transformers, unordered-containers, wai
-     , wai-websockets, websockets
+    ({ mkDerivation, attoparsec, base, bytestring, either, engine-io
+     , http-types, mtl, text, transformers, transformers-compat
+     , unordered-containers, wai, wai-websockets, websockets
      }:
      mkDerivation {
        pname = "engine-io-wai";
-       version = "1.0.1";
-       sha256 = "0cr53x8bxfmrx97v7jsb7gw3hqb94zp9xvvnl16080zmqm0gi2rh";
+       version = "1.0.3";
+       sha256 = "0p296y3xnpx0wj6yd152y7i765x0pwg8rg2bpcz92hkcmz57gdz7";
        buildDepends = [
-         attoparsec base bytestring engine-io http-types mtl text
-         transformers unordered-containers wai wai-websockets websockets
+         attoparsec base bytestring either engine-io http-types mtl text
+         transformers transformers-compat unordered-containers wai
+         wai-websockets websockets
        ];
        homepage = "http://github.com/ocharles/engine.io";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "equal-files";
-       version = "0.0.5.1";
-       sha256 = "1rm0hk42xnzix1ba7bxfrc910v4nnhvqk3cbdrxy7avzhad31nbf";
+       version = "0.0.5.2";
+       sha256 = "07n9xdsi00nz9xwd0bqrdn2d03q7dzlrr13wlym5lgc15r7iwf8w";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "2.2.10";
-       sha256 = "0chxxcy52xrhdq7pgwzq3vk9filrrc3mdnx6j26r2ih56j1ac02l";
+       version = "2.2.11";
+       sha256 = "0ldgiim5d23avzqgzmpyb1nfp9xpxc51fc98f3ii8ic4mxn4bjvp";
        buildDepends = [
          base conduit monad-logger persistent resourcet tagged text
          transformers unordered-containers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "euphoria" = callPackage
+    ({ mkDerivation, base, containers, data-default, deepseq, elerea
+     , enummapset-th, hashable, HUnit, test-framework
+     , test-framework-hunit, test-framework-th, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "euphoria";
+       version = "0.6.0.1";
+       sha256 = "1bml75lj30y83bln5a7b36gcb9d6gci4vhmr8ins9nz6bc1l29m9";
+       buildDepends = [
+         base containers data-default deepseq elerea enummapset-th hashable
+         HUnit transformers unordered-containers
+       ];
+       testDepends = [
+         base HUnit test-framework test-framework-hunit test-framework-th
+       ];
+       homepage = "http://github.com/tsurucapital/euphoria";
+       description = "Dynamic network FRP with events and continuous values";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "eurofxref" = callPackage
     ({ mkDerivation, base, bytestring, conduit, containers, failure
      , hexpat, http-conduit, http-types, monad-control, mtl, time
···
      }) {};
 
   "ewe" = callPackage
-    ({ mkDerivation, alex, array, base, containers, happy, mtl
+    ({ mkDerivation, alex, array, base, containers, happy, mtl, pretty
      , transformers
      }:
      mkDerivation {
        pname = "ewe";
-       version = "0.1.0.40";
-       sha256 = "0r9kcpb6j2x4cmg26rvzd2gp4bjjmlsd0rbk1y2dc7vyivd0m14l";
+       version = "0.1.0.44";
+       sha256 = "0v313l0akvw9b3zn7xffy4ixz2c70i40k6kh4vdlrw8dvyv7zxk3";
        isLibrary = false;
        isExecutable = true;
-       buildDepends = [ array base containers mtl transformers ];
+       buildDepends = [ array base containers mtl pretty transformers ];
        buildTools = [ alex happy ];
        homepage = "http://github.com/jfcmacro/ewe";
        description = "An language using in Programming Languages teaching";
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "exact-pi";
-       version = "0.2.0.0";
-       sha256 = "0az47bzrkhb5xmws1rpp080kvsq2pcxjgrm0wzjqqbcqiy5pi3f9";
+       version = "0.2.1.1";
+       sha256 = "1f8lxdaal7m4vw8akzwlhn0j3vw5bh983f02j842g1vzs3n47x3g";
        buildDepends = [ base ];
        homepage = "https://github.com/dmcclean/exact-pi";
        description = "Exact rational multiples of pi (and integer powers of pi)";
···
      }:
      mkDerivation {
        pname = "extra";
-       version = "1.4";
-       sha256 = "1cp9vsqgjc46v1i8w8lhakdk1qj6q2bd0y365qj0madpjj7q1qi8";
+       version = "1.4.1";
+       sha256 = "00fhy9l2cgfwj8873jf1iyz2fmhj1b3m0qlf38i4pd1yad8sfb70";
        buildDepends = [ base directory filepath process time unix ];
        testDepends = [ base directory filepath QuickCheck time unix ];
        homepage = "https://github.com/ndmitchell/extra#readme";
···
      }:
      mkDerivation {
        pname = "fast-builder";
-       version = "0.0.0.0";
-       sha256 = "1ga28vxsv4hk8491jv51jd8xqvafss56kkm97x2ma4naqx4v6snw";
+       version = "0.0.0.2";
+       sha256 = "07fnn282ldfmgkfnsdnjr11hx89jhw7waz573a7nx2a329r1p4pf";
        buildDepends = [ base bytestring ghc-prim ];
        testDepends = [ base bytestring process QuickCheck stm ];
        homepage = "http://github.com/takano-akio/fast-builder";
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "fast-digits" = callPackage
+    ({ mkDerivation, base, digits, integer-gmp, QuickCheck, smallcheck
+     , tasty, tasty-quickcheck, tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "fast-digits";
+       version = "0.1.0.0";
+       sha256 = "1dhvlsjbp4qrgcr9xlzbaps59160j2zl98xl5nrz6rffypz0gi72";
+       buildDepends = [ base integer-gmp ];
+       testDepends = [
+         base digits QuickCheck smallcheck tasty tasty-quickcheck
+         tasty-smallcheck
+       ];
+       homepage = "https://github.com/Bodigrim/fast-digits";
+       description = "The fast library for integer-to-digits conversion";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "fast-logger" = callPackage
     ({ mkDerivation, array, auto-update, base, bytestring
      , bytestring-builder, directory, filepath, hspec, text
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "fast-math";
-       version = "1.0.1";
-       sha256 = "1a36mvrdr8gai4sn1s52fyc8alcl6ks6dlmr77df5dgvc2z74hhb";
+       version = "1.0.2";
+       sha256 = "15dyw88z9abiv6n40fz4g3jpj9v6qbxvqaf0ds32wh46igf1s425";
        buildDepends = [ base ];
        description = "Non IEEE-754 compliant compile-time floating-point optimisations";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "fasta";
-       version = "0.7.2.0";
-       sha256 = "1zsghi7883y4ygl0iammfh1dmnsnh3x4ly77jhxg8xz8saw7dbir";
+       version = "0.7.2.1";
+       sha256 = "1jwx8h3z3zlrnandqgmgrkam4y0awm3k1mfzljf7pn9acq6nxhs4";
        buildDepends = [
          base bytestring containers foldl lens parsec pipes pipes-bytestring
          pipes-group pipes-text split text
···
      }:
      mkDerivation {
        pname = "fgl";
-       version = "5.5.2.0";
-       sha256 = "1r9vkv5v32nyqghr4fq3ijrdl2sr9bncfpj3zix53h5m2zyn7kg3";
+       version = "5.5.2.1";
+       sha256 = "1nfm3gkr6cccqhi1g46k2d0l99yw2vq7xjd1hxxzcci5gidp8bhc";
        buildDepends = [ array base containers deepseq transformers ];
        testDepends = [ base containers hspec QuickCheck ];
        description = "Martin Erwig's Functional Graph Library";
···
      }:
      mkDerivation {
        pname = "filestore";
-       version = "0.6.0.6";
-       sha256 = "1lknngdg1c4a58qxbzzvpy72nx1pncm2p4akid2b3s7ydl7j96xr";
+       version = "0.6.1";
+       sha256 = "0mfllnnb1mqix1v65fyhd9jsvnrjbawd6l4h4012jk8401zwj280";
        buildDepends = [
          base bytestring containers Diff directory filepath old-locale
          parsec process split time utf8-string xml
···
      }) {};
 
   "fsnotify" = callPackage
-    ({ mkDerivation, async, base, containers, directory, hinotify
-     , system-fileio, system-filepath, tasty, tasty-hunit, temporary-rc
-     , text, time
+    ({ mkDerivation, async, base, containers, directory, filepath
+     , hinotify, tasty, tasty-hunit, temporary-rc, text, time
+     , unix-compat
      }:
      mkDerivation {
        pname = "fsnotify";
-       version = "0.1.0.3";
-       sha256 = "0m6jyg45azk377jklgwyqrx95q174cxd5znpyh9azznkh09wq58z";
+       version = "0.2.1";
+       sha256 = "0asl313a52qx2w6dw25g845683xsl840bwjh118nkwi5v1xipkzb";
        buildDepends = [
-         async base containers hinotify system-fileio system-filepath text
-         time
+         async base containers directory filepath hinotify text time
+         unix-compat
        ];
        testDepends = [
-         async base directory system-fileio system-filepath tasty
-         tasty-hunit temporary-rc
+         async base directory filepath tasty tasty-hunit temporary-rc
+         unix-compat
        ];
+       homepage = "https://github.com/haskell-fswatch/hfsnotify";
        description = "Cross platform library for file change notification";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fuzzy" = callPackage
+    ({ mkDerivation, base, HUnit, monoid-subclasses }:
+     mkDerivation {
+       pname = "fuzzy";
+       version = "0.1.0.0";
+       sha256 = "1jz9arrg33x64ygipk0115b7jfchxh20cy14177iwg0na8mpl2l2";
+       buildDepends = [ base monoid-subclasses ];
+       testDepends = [ base HUnit ];
+       homepage = "http://github.com/joom/fuzzy";
+       description = "Filters a list based on a fuzzy string search";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "fuzzy-timings" = callPackage
     ({ mkDerivation, base, containers, glpk-hs, HUnit, mtl, QuickCheck
      , random, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "fwgl";
-       version = "0.1.2.0";
-       revision = "1";
-       sha256 = "1b18xzxbbrnmmvjgmzhy5r4ww7rvbli76m7vh3li30fb95k1sznr";
-       editedCabalFile = "d97edefc7ee59578d181dfc36d85b1a82a6e0c9ed1bb602918655a3439a5eb51";
+       version = "0.1.2.2";
+       sha256 = "1s4j1wgnncn6cmsarsc989zxz1qsqhsa722h7bv2k43093ww0nnh";
        buildDepends = [
          base hashable transformers unordered-containers vector Yampa
        ];
···
      }:
      mkDerivation {
        pname = "fwgl-glfw";
-       version = "0.1.0.4";
-       revision = "1";
-       sha256 = "1pph1arlmi905rkcjcn3yf5ypdmk82363vgdmwg26dbrb2sb4cs8";
-       editedCabalFile = "26e4026f5ac7fe57292c5df79d35894b736728c31cad845f11641d833f789fb8";
+       version = "0.1.0.5";
+       sha256 = "1y30mqayih5cd74dm90y7mbb9a0fw9sirzjlrmayvcm7aniyvmql";
        buildDepends = [
          base fwgl gl GLFW-b hashable JuicyPixels transformers
          unordered-containers vector Yampa
···
      }:
      mkDerivation {
        pname = "fwgl-javascript";
-       version = "0.1.0.4";
-       sha256 = "1bwg6dzp2kgny5s6zygdi120pcrdclql22rgp43vhwim5aqkp9d7";
+       version = "0.1.0.6";
+       sha256 = "0fxnnjp7403c29pjks739j0j92a1sldrrxg3sp4nrjb1ax01nia9";
        buildDepends = [
          base fwgl ghcjs-base hashable unordered-containers Yampa
        ];
···
      }) {};
 
   "getopt-generics" = callPackage
-    ({ mkDerivation, base, base-compat, base-orphans, generics-sop
-     , hspec, hspec-expectations, markdown-unlit, QuickCheck, silently
-     , tagged
+    ({ mkDerivation, base, base-compat, base-orphans, directory
+     , filepath, generics-sop, hspec, process, QuickCheck, silently
+     , tagged, temporary
      }:
      mkDerivation {
        pname = "getopt-generics";
-       version = "0.8";
-       sha256 = "0qxdr9y3dvr4w7hhbgkianaijsqfh36gfwh1blhbr1nf7cv9khmd";
+       version = "0.10.0.1";
+       sha256 = "0x8vh0sng1m05blxr24ijrz16bsyvryxkk70jqkdvq173x5fj8lf";
        buildDepends = [
          base base-compat base-orphans generics-sop tagged
        ];
        testDepends = [
-         base base-compat base-orphans generics-sop hspec hspec-expectations
-         markdown-unlit QuickCheck silently tagged
+         base base-compat base-orphans directory filepath generics-sop hspec
+         process QuickCheck silently tagged temporary
        ];
        homepage = "https://github.com/zalora/getopt-generics#readme";
-       description = "Simple command line argument parsing";
+       description = "Create command line interfaces with ease";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
 
   "ghc-exactprint" = callPackage
     ({ mkDerivation, base, containers, directory, filemanip, filepath
-     , free, ghc, ghc-paths, HUnit, mtl, random, silently, syb
+     , free, ghc, ghc-paths, HUnit, mtl, silently, syb
      }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "0.3";
-       sha256 = "0wgqlll95fbxnni1dzlyiyb4d7lqp3hrfw9xh5hqsnqm45smi7j1";
+       version = "0.3.1";
+       sha256 = "07kyifdh8s7jjp1jsm9f823hr0axgpxv54fr0vg8k3ibhdrw5dj1";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        ];
        testDepends = [
          base containers directory filemanip filepath ghc ghc-paths HUnit
-         mtl random silently syb
+         mtl silently syb
        ];
+       jailbreak = true;
        description = "ExactPrint for GHC";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }) {};
 
   "ghcjs-dom" = callPackage
-    ({ mkDerivation, base, glib, gtk3, mtl, text, transformers
-     , webkitgtk3
+    ({ mkDerivation, base, glib, gtk, mtl, text, transformers, webkit
      }:
      mkDerivation {
        pname = "ghcjs-dom";
        version = "0.1.1.3";
        sha256 = "0pdxb2s7fflrh8sbqakv0qi13jkn3d0yc32xhg2944yfjg5fvlly";
-       buildDepends = [ base glib gtk3 mtl text transformers webkitgtk3 ];
+       buildDepends = [ base glib gtk mtl text transformers webkit ];
        description = "DOM library that supports both GHCJS and WebKitGTK";
        license = stdenv.lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "gipeda";
-       version = "0.1.2";
-       sha256 = "0a32q4gi0vfmgvy4ir0ng52nk2gkfxcivyybh5bfh04b3saf5ya4";
+       version = "0.1.2.1";
+       sha256 = "0wra67d2jdnx463vw8hf2yzzwmnkbs9791x5mgarlgc6zj68g926";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
          gitlib gitlib-libgit2 scientific shake split tagged text
          unordered-containers vector yaml
        ];
-       jailbreak = true;
        homepage = "https://github.com/nomeata/gipeda";
        description = "Git Performance Dashboard";
        license = stdenv.lib.licenses.mit;
···
      , git, gnupg, gnutls, hinotify, hslogger, http-client, http-conduit
      , http-types, IfElse, json, lsof, MissingH, monad-control
      , monad-logger, mtl, network, network-info, network-multicast
-     , network-protocol-xmpp, network-uri, openssh, optparse-applicative
-     , path-pieces, perl, persistent, persistent-sqlite
-     , persistent-template, process, QuickCheck, random, regex-tdfa
-     , resourcet, rsync, SafeSemaphore, sandi, securemem, shakespeare
-     , stm, tasty, tasty-hunit, tasty-quickcheck, tasty-rerun
-     , template-haskell, text, time, torrent, transformers, unix
-     , unix-compat, utf8-string, uuid, wai, wai-extra, warp, warp-tls
-     , wget, which, xml-types, yesod, yesod-core, yesod-default
-     , yesod-form, yesod-static
+     , network-protocol-xmpp, network-uri, old-locale, openssh
+     , optparse-applicative, path-pieces, perl, persistent
+     , persistent-sqlite, persistent-template, process, QuickCheck
+     , random, regex-tdfa, resourcet, rsync, SafeSemaphore, sandi
+     , securemem, shakespeare, stm, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-rerun, template-haskell, text, time, torrent, transformers
+     , unix, unix-compat, utf8-string, uuid, wai, wai-extra, warp
+     , warp-tls, wget, which, xml-types, yesod, yesod-core
+     , yesod-default, yesod-form, yesod-static
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "5.20150710";
-       sha256 = "0q7q8ikgv3dhvs3vad04z1bfa6l92v97jrh0n4zqc0c44wx9a3wp";
+       version = "5.20150731";
+       sha256 = "18akv0xj4mf2ypzzd12briv0rw9ba7xw8k1qxvl10m9z4x6gvvm2";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
          edit-distance esqueleto exceptions fdo-notify feed filepath gnutls
          hinotify hslogger http-client http-conduit http-types IfElse json
          MissingH monad-control monad-logger mtl network network-info
-         network-multicast network-protocol-xmpp network-uri
+         network-multicast network-protocol-xmpp network-uri old-locale
          optparse-applicative path-pieces persistent persistent-sqlite
          persistent-template process QuickCheck random regex-tdfa resourcet
          SafeSemaphore sandi securemem shakespeare stm tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "gitit";
-       version = "0.11";
-       sha256 = "1833rxx3c28rvjz1h1nnm0h838zl941zr51r3dp89zn59rs72hn9";
+       version = "0.11.1";
+       sha256 = "06wxy4hpbkbmlwrgnsxbr47k2a791094gzqsmlqzhsq6wa1bgfr9";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "glib";
-       version = "0.13.1.1";
-       sha256 = "1wa3kfwwb7hf5g0hw1vcmrgcxd4pykvzbvc6ylx7903vxqbb9574";
+       version = "0.13.2.1";
+       sha256 = "1pxc2a0hnjaryf3f8d410rnhxmc7byx6lwcypgqg4zma6r3qhqwp";
        buildDepends = [ base bytestring containers text utf8-string ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ glib ];
···
      mkDerivation {
        pname = "gloss-banana";
        version = "0.1.0.4";
+       revision = "1";
        sha256 = "0zzpdryfcqvxpzv53ymsvkm2nza9ryvzqgf3n89pnvrni91avgj3";
+       editedCabalFile = "232cec279cb20afd92056320c24d3d3041199b014981492ddbbe57eeff312a5a";
        buildDepends = [ base gloss reactive-banana ];
-       jailbreak = true;
        homepage = "https://github.com/Twey/gloss-banana";
        description = "An Interface for gloss in terms of a reactive-banana Behavior";
        license = stdenv.lib.licenses.gpl3;
···
     ({ mkDerivation, array, base, containers, deepseq, glpk, mtl }:
      mkDerivation {
        pname = "glpk-hs";
-       version = "0.3.4";
-       sha256 = "0wyasd0dqi5nnh52lx980vnyhm0rwib0sd7qnpj4s9hq8rn994cm";
+       version = "0.3.5";
+       sha256 = "1nx0mcy009cj1h2fsz00qfpr9zawagwsp3w370251hdc5q6bw52p";
        buildDepends = [ array base containers deepseq mtl ];
        extraLibraries = [ glpk ];
        description = "Comprehensive GLPK linear programming bindings";
···
      }) {};
 
   "graphics-drawingcombinators" = callPackage
-    ({ mkDerivation, base, bitmap, FTGL, OpenGL, stb-image }:
+    ({ mkDerivation, base, bitmap, bitmap-opengl, FTGL, OpenGL
+     , stb-image
+     }:
      mkDerivation {
        pname = "graphics-drawingcombinators";
-       version = "1.5";
-       sha256 = "064g5zcdm0xpczyf8xwx0q0yr6jrd54461qpfxbvsh90lq0pa051";
+       version = "1.5.1";
+       sha256 = "0j0ilr54pdz61c78khy8bm37g89cvk1n56h5d6c55jabsv5gx3sf";
        isLibrary = true;
        isExecutable = true;
-       buildDepends = [ base bitmap FTGL OpenGL stb-image ];
+       buildDepends = [ base bitmap bitmap-opengl FTGL OpenGL stb-image ];
        jailbreak = true;
        homepage = "http://github.com/luqui/graphics-drawingcombinators";
        description = "A functional interface to 2D drawing in OpenGL";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "gridland" = callPackage
+    ({ mkDerivation, array, astar, base, containers, grid, htiled, mtl
+     , random, safe, SDL, SDL-gfx, SDL-image, SDL-mixer, tuple, vector
+     }:
+     mkDerivation {
+       pname = "gridland";
+       version = "0.1.0.3";
+       sha256 = "0q5p73n6h5ngg992f1msdqzxds2baafjypdx53zf2rdhbqp4fdi9";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         array astar base containers grid htiled mtl random safe SDL SDL-gfx
+         SDL-image SDL-mixer tuple vector
+       ];
+       description = "Grid-based multimedia engine";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "grm" = callPackage
     ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, happy
      , parsec, process, syb, wl-pprint
···
      }:
      mkDerivation {
        pname = "gtk3";
-       version = "0.13.9";
-       sha256 = "1zmcvp295sknc2h529nprclw11lnwp79dniyyg573wc99bdzijvr";
+       version = "0.14.0";
+       sha256 = "1j6nwjvjmzb144vbizraax0yf5bbkicg5hx2mm4z9ayacf58sm7c";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ gtk3 ];
        homepage = "http://projects.haskell.org/gtk2hs/";
-       description = "Binding to the Gtk+ graphical user interface library";
+       description = "Binding to the Gtk+ 3 graphical user interface library";
        license = stdenv.lib.licenses.lgpl21;
      }) { gtk3 = null;};
 
···
      }:
      mkDerivation {
        pname = "gtk3-mac-integration";
-       version = "0.3.1.1";
-       sha256 = "0j6fpzk1gq1y15cjpkq3k1azkn7xvlqiidn3m0g9czz5iy303adv";
+       version = "0.3.2.0";
+       sha256 = "0m7659ca92w9yhd1fnraa255sx74qjagwsavd3navl41h687bzqj";
        buildDepends = [ array base containers glib gtk3 mtl ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ gtk-mac-integration-gtk3 ];
···
      }:
      mkDerivation {
        pname = "gtksourceview3";
-       version = "0.13.1.5";
-       sha256 = "15bm58pr92izhwa0sqf8vkzfcg1455947cgl29ak2kwaj3fkzbq1";
+       version = "0.13.2.0";
+       sha256 = "0chn0rl5kkfi7y02h1x0gfkpbm4hfcl6pxrbdpfv20jk4m88a0qj";
        buildDepends = [ array base containers glib gtk3 mtl text ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ gtksourceview ];
···
      }:
      mkDerivation {
        pname = "hadoop-tools";
-       version = "0.6";
-       revision = "2";
-       sha256 = "1nkkv9i0qk4k9vijabf1lylq8wsfsycllxvkza7abljii5jpj5fp";
-       editedCabalFile = "31166d3ed285e22977d237a1ae42d29b33503ad7be39c11f97b5890571da19ec";
+       version = "0.7.2";
+       sha256 = "0grwi26xardg8fxvz7g10v9111bgph77s3pdrr58r9hqgm8lhx5v";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
      , snap-server, system-filepath, tagsoup, test-framework
      , test-framework-hunit, test-framework-quickcheck2, text, time
+     , time-locale-compat
      }:
      mkDerivation {
        pname = "hakyll";
-       version = "4.7.2.0";
-       sha256 = "0krj7kaikdbxiqkcd5c3pyhp3zchgy74dzx336f8x1ywlja4802r";
+       version = "4.7.2.2";
+       sha256 = "1gy7j15qqh8m0wf8xkpb1hglahylwyy7vq6c4bm9arap3viak29c";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          http-conduit http-types lrucache mtl network network-uri pandoc
          pandoc-citeproc parsec process random regex-base regex-tdfa
          snap-core snap-server system-filepath tagsoup text time
+         time-locale-compat
        ];
        testDepends = [
          base binary blaze-html blaze-markup bytestring cmdargs containers
···
          Agda base containers directory filepath hakyll mtl pandoc
          transformers xhtml
        ];
+       jailbreak = true;
        homepage = "https://github.com/bitonic/hakyll-agda";
        description = "Wrapper to integrate literate Agda files with Hakyll";
        license = stdenv.lib.licenses.bsd3;
···
        isExecutable = true;
        buildDepends = [ base glib gtk3 text ];
        pkgconfigDepends = [ appindicator ];
+       jailbreak = true;
        homepage = "https://github.com/mlacorte/happindicator3";
        description = "Binding to the appindicator library";
        license = stdenv.lib.licenses.lgpl21;
···
 
   "hashable-extras" = callPackage
     ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
-     , filepath, generic-deriving, hashable, transformers
+     , filepath, hashable, transformers
      }:
      mkDerivation {
        pname = "hashable-extras";
-       version = "0.2.1";
-       sha256 = "02hzffyns0id9vhaqzax7ijprh1pfb8llrfi67hmji2wrh3nvmml";
+       version = "0.2.2";
+       sha256 = "118l23n78xs1faa0q42h996q210l2p9mzl85a73krljzsz8wkc1b";
        buildDepends = [
-         base bifunctors bytestring generic-deriving hashable transformers
+         base bifunctors bytestring hashable transformers
        ];
        testDepends = [ base directory doctest filepath ];
-       jailbreak = true;
        homepage = "http://github.com/analytics/hashable-extras/";
        description = "Higher-rank Hashable";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "haskellscrabble";
-       version = "1.0";
-       sha256 = "099qhvi7v7bimjqdlnz6scmyr7xqxjk65y861630n9jr133bclnz";
+       version = "1.1";
+       sha256 = "1wb9ncpzsacvwk8gmh8gzxm54viwlzsikj05lk14gpyp8xwhl54h";
        buildDepends = [
          array arrows base containers errors mtl parsec QuickCheck random
          safe semigroups split transformers unordered-containers
···
      }) {};
 
   "haste-compiler" = callPackage
-    ({ mkDerivation, array, base, binary, blaze-builder, bytestring
-     , bzlib, containers, data-binary-ieee754, data-default, directory
-     , either, filepath, ghc, ghc-paths, ghc-prim, HTTP, monads-tf, mtl
-     , network, network-uri, process, random, shellmate, system-fileio
-     , tar, transformers, utf8-string, websockets
+    ({ mkDerivation, array, base, bin-package-db, binary, blaze-builder
+     , bytestring, bzlib, Cabal, containers, data-binary-ieee754
+     , data-default, directory, either, filepath, ghc, ghc-paths
+     , ghc-prim, ghc-simple, HTTP, monads-tf, mtl, network, network-uri
+     , process, random, shellmate, system-fileio, tar, terminfo
+     , transformers, unix, utf8-string, websockets
      }:
      mkDerivation {
        pname = "haste-compiler";
-       version = "0.4.4.4";
-       revision = "1";
-       sha256 = "19raiciwll7pgc73h2h704yi9wcifcn7s2gxyjrndp6d7kf1ygyy";
-       editedCabalFile = "de636e39473869692b1fa1dd6047fc2987b6f63c1403a511aab6bd1dcaa98f6f";
+       version = "0.5.0";
+       sha256 = "18n9sl9m2fpzshpj3gqvd7wlmvz5mrgsz8awcd3imcb7136qa9s9";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         array base binary blaze-builder bytestring bzlib containers
-         data-binary-ieee754 data-default directory either filepath ghc
-         ghc-paths ghc-prim HTTP monads-tf mtl network network-uri process
-         random shellmate system-fileio tar transformers utf8-string
-         websockets
+         array base bin-package-db binary blaze-builder bytestring bzlib
+         Cabal containers data-binary-ieee754 data-default directory either
+         filepath ghc ghc-paths ghc-prim ghc-simple HTTP monads-tf mtl
+         network network-uri process random shellmate system-fileio tar
+         terminfo transformers unix utf8-string websockets
        ];
        configureFlags = [ "-fportable" ];
        homepage = "http://haste-lang.org/";
···
      }) {};
 
   "hdocs" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
-     , filepath, ghc, ghc-paths, haddock-api, haddock-library
-     , MonadCatchIO-transformers, mtl, network, process, text
-     , transformers
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal
+     , containers, filepath, ghc, ghc-paths, haddock-api
+     , haddock-library, MonadCatchIO-transformers, mtl, network, process
+     , text, transformers
      }:
      mkDerivation {
        pname = "hdocs";
-       version = "0.4.3.0";
-       sha256 = "10z4aq9f3gy6cqkhz0dxp0q3rr9625hka3c4w4cbczad2qgciiil";
+       version = "0.4.4.0";
+       sha256 = "153rwd1f390j6sjfxx135h3bh80pb8zb5myws9q8d0jkrx2sl198";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         aeson aeson-pretty base bytestring containers filepath ghc
+         aeson aeson-pretty base bytestring Cabal containers filepath ghc
          ghc-paths haddock-api haddock-library MonadCatchIO-transformers mtl
          network process text transformers
        ];
···
        description = "Explicit closures in Haskell distributed parallel Haskell";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "headergen" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
+     , filepath, haskeline, time
+     }:
+     mkDerivation {
+       pname = "headergen";
+       version = "0.2.0.0";
+       sha256 = "1hc1pmbj9452k4a71iiazxg6id7caf783m08lqnf3flf77cdjxpa";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         aeson aeson-pretty base bytestring directory filepath haskeline
+         time
+       ];
+       homepage = "https://github.com/aka-bash0r/headergen";
+       description = "Creates a header for a haskell source file";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "heap" = callPackage
···
     ({ mkDerivation, aeson, base, hedis, scientific, text, time }:
      mkDerivation {
        pname = "hedis-config";
-       version = "0.0.1";
-       sha256 = "1c524klmsl8n6alphxdmwm4hw05hhq3rcyb5540ksnnys77b8y2b";
+       version = "0.0.2";
+       sha256 = "1ism20ddgcdsypbic6ikalvajq3918wm53ppiic68zaqfzwk9gk2";
        buildDepends = [ aeson base hedis scientific text time ];
-       jailbreak = true;
        homepage = "https://bitbucket.org/s9gf4ult/hedis-config";
        description = "Easy trivial configuration for Redis";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "hedis-monadic";
-       version = "0.0.3";
-       sha256 = "1z80kdm1cs1pk6fpbby20q49ji840zp9xwbynbry2v43g5q18lq6";
+       version = "0.0.4";
+       sha256 = "1540c4ra65y2kc97n7wxx7rdzf3dkaqqx7r4lwz4qpg3kzfi6q8w";
        buildDepends = [
          base hedis monad-control mtl transformers transformers-base
          transformers-compat
        ];
-       jailbreak = true;
        homepage = "https://bitbucket.org/s9gf4ult/redis-monadic";
        description = "A la MonadReader for Redis connection";
        license = stdenv.lib.licenses.bsd3;
···
 
   "heyefi" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, configurator
-     , containers, directory, errors, exceptions, filemanip, filepath
-     , HandsomeSoup, hspec, HTTP, http-types, hxt, iso8601-time
-     , MissingH, mtl, multipart, old-locale, optparse-applicative
-     , random, silently, stm, tar, temporary, text, time, transformers
-     , unix, unordered-containers, utf8-string, wai, warp
+     , containers, directory, exceptions, filepath, HandsomeSoup, hspec
+     , http-types, hxt, iso8601-time, MissingH, mtl, multipart
+     , optparse-applicative, random, silently, stm, tar, temporary, text
+     , time, transformers, unix, unordered-containers, utf8-string, wai
+     , warp
      }:
      mkDerivation {
        pname = "heyefi";
-       version = "0.1.1.0";
-       sha256 = "13m66ix0kmvqwgvqh56mjdwgwpjjqi67hyr6giwhs63fr3wxw3f3";
+       version = "0.1.1.1";
+       sha256 = "0dm9dyn12jgpc317pk5z3rhhgw2hbmbxyfba97jzq34b5z6crz0f";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
-         base bytestring case-insensitive configurator directory errors
-         exceptions filemanip filepath HandsomeSoup HTTP http-types hxt
-         iso8601-time MissingH mtl multipart old-locale optparse-applicative
-         random stm tar temporary text time transformers unix
-         unordered-containers utf8-string wai warp
+         base bytestring case-insensitive configurator directory exceptions
+         filepath HandsomeSoup http-types hxt iso8601-time MissingH mtl
+         multipart optparse-applicative random stm tar temporary text time
+         transformers unix unordered-containers utf8-string wai warp
        ];
        testDepends = [
          base bytestring case-insensitive configurator containers directory
-         errors exceptions filemanip filepath HandsomeSoup hspec HTTP
-         http-types hxt iso8601-time MissingH mtl multipart old-locale
-         optparse-applicative random silently stm tar temporary text time
-         transformers unix unordered-containers utf8-string wai warp
+         exceptions filepath HandsomeSoup hspec http-types hxt iso8601-time
+         MissingH mtl multipart optparse-applicative random silently stm tar
+         temporary text time transformers unix unordered-containers
+         utf8-string wai warp
        ];
        homepage = "https://github.com/ryantm/heyefi";
        description = "A server for Eye-Fi SD cards";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hgearman" = callPackage
+    ({ mkDerivation, base, binary, bytestring, monad-control, mtl
+     , network, resource-pool, transformers, transformers-base
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "hgearman";
+       version = "0.1.0.2";
+       sha256 = "0bfipd7s6czp3aha0jx1yjzfzn8vywiswd07k68q2207j3br8yxk";
+       buildDepends = [
+         base binary bytestring monad-control mtl network resource-pool
+         transformers transformers-base unordered-containers
+       ];
+       description = "A Gearman client for Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "hgen" = callPackage
     ({ mkDerivation, base, directory, filepath, hylolib, mtl, random }:
      mkDerivation {
···
      }) {};
 
   "highjson" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers, hashable
-     , hspec, hvect, scientific, text, unordered-containers, vector
+    ({ mkDerivation, attoparsec, base, buffer-builder, bytestring
+     , containers, hashable, hspec, hvect, QuickCheck, scientific, text
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "highjson";
-       version = "0.1.0.0";
-       sha256 = "1j0gcbgawimzr8vvglikmdr8q58zvvak68k8221ljydppanc30k0";
+       version = "0.2.0.2";
+       sha256 = "07qz7zb53vbpb9ixrw0qwn5qhvgwzvrvfkp343a1cvbb42slpmkz";
        buildDepends = [
-         attoparsec base bytestring containers hashable hvect scientific
-         text unordered-containers vector
+         attoparsec base buffer-builder bytestring containers hashable hvect
+         scientific text unordered-containers vector
        ];
-       testDepends = [ base hspec text ];
+       testDepends = [ base hspec QuickCheck text ];
        homepage = "https://github.com/agrafix/highjson";
-       description = "Very fast JSON parsing";
+       description = "Very fast JSON serialisation and parsing library";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "hjsmin";
-       version = "0.1.4.7";
-       sha256 = "1gw9is6piqrqxnrwp8v3vij90icmym58rxqnnklrcjfi3ai7y58f";
+       version = "0.1.5.0";
+       sha256 = "1mzi7czzw1b8avkfzmsl79hqg57dcrcfp6klzx15drnbl7c1zn7l";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          language-javascript QuickCheck test-framework test-framework-hunit
          text
        ];
-       homepage = "http://github.com/alanz/hjsmin";
+       homepage = "http://github.com/erikd/hjsmin";
        description = "Haskell implementation of a javascript minifier";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, hledger-lib, time }:
      mkDerivation {
        pname = "hledger-diff";
-       version = "0.2.0.3";
-       sha256 = "0m2wbjbihv0zlz2y3khy81xhh2c261fb4wr55csqy22rds73fwy8";
+       version = "0.2.0.4";
+       sha256 = "1p0b2xc2axsigmbc5lhl12acsjjvn0j8gjlwp3v4ggyanwyj686r";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [ base hledger-lib time ];
-       jailbreak = true;
        homepage = "https://github.com/gebner/hledger-diff";
        description = "Compares the transactions in two ledger files";
        license = stdenv.lib.licenses.gpl3;
···
          base binary containers monad-stm stm transformers
        ];
        description = "In-memory relational database";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "hmenu" = callPackage
+    ({ mkDerivation, base, MissingH, process }:
+     mkDerivation {
+       pname = "hmenu";
+       version = "0.1.0.1";
+       sha256 = "0ym3nzyx1jwcc7m6qj8zchs2q73rj82d7f1r2rvykhns7ca20hrp";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [ base MissingH process ];
+       jailbreak = true;
+       description = "CLI fuzzy finder and launcher";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }) {};
 
   "hothasktags" = callPackage
-    ({ mkDerivation, base, cmdargs, containers, cpphs, filepath
-     , haskell-src-exts
+    ({ mkDerivation, array, base, containers, cpphs, filepath
+     , haskell-src-exts, optparse-applicative, split
      }:
      mkDerivation {
        pname = "hothasktags";
-       version = "0.3.3";
-       sha256 = "1nyr77lm813v521fhhsd3zf7hlpad70g1aj729plrwaxj8c0cizl";
+       version = "0.3.4";
+       sha256 = "0pnp0xkqk2l29p5kr3kjmxl7hb8g1qd198n36vmfx1x8kc8bahdy";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
-         base cmdargs containers cpphs filepath haskell-src-exts
+         array base containers cpphs filepath haskell-src-exts
+         optparse-applicative split
        ];
        homepage = "http://github.com/luqui/hothasktags";
        description = "Generates ctags for Haskell, incorporating import lists and qualified imports";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hourglass-fuzzy-parsing" = callPackage
+    ({ mkDerivation, base, hourglass, parsec }:
+     mkDerivation {
+       pname = "hourglass-fuzzy-parsing";
+       version = "0.1.0.1";
+       sha256 = "188mw1z8n650y3qik98x2m70sr8q66x4l4pg34mirk6kg4mgzy37";
+       buildDepends = [ base hourglass parsec ];
+       homepage = "https://gitlab.com/doshitan/hourglass-fuzzy-parsing";
+       description = "A small library for parsing more human friendly date/time formats";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hp2any-core" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers
      , directory, filepath, network, old-locale, process, time
···
      }:
      mkDerivation {
        pname = "hprotoc";
-       version = "2.1.3";
-       sha256 = "1fy2bnk8jlakfgvap9ma5qxyvqgl25dbqk7a7n9m4q0z8ba0s1di";
+       version = "2.1.4";
+       sha256 = "01848yssmpi0fgkgnlgwmcrmkmpdqc6yc19z91kj46sl187k2k8j";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "hreader";
-       version = "0.1.0";
-       sha256 = "102i17879ha49yh87i9k5lxrlrjd1fxcb8k8adidqwghbn55dyjc";
+       version = "0.2.0";
+       sha256 = "1a0zllljfjpz6fwq2h0l5wwl1wg1v68n6r84fs70vnny0c3wl6hg";
        buildDepends = [
          base exceptions hset mmorph monad-control mtl transformers-base
        ];
···
      }:
      mkDerivation {
        pname = "hruby";
-       version = "0.3.1.4";
-       sha256 = "0pymwdpdl1xwjcgpblsrfyyib4sz2avxwidgxzr2bac91lhf3fpm";
+       version = "0.3.1.5";
+       sha256 = "1x9j3rc3kk64l8idkar35ap4y5kxh4abfssd2iphp8dqnjld3jxa";
        buildDepends = [
          aeson attoparsec base bytestring scientific stm text
          unordered-containers vector
        ];
        testDepends = [ aeson attoparsec base QuickCheck text vector ];
        extraLibraries = [ ruby ];
-       jailbreak = true;
        description = "Embed a Ruby intepreter in your Haskell program !";
        license = stdenv.lib.licenses.bsd3;
      }) { inherit (pkgs) ruby;};
···
      , bin-package-db, bytestring, Cabal, containers, deepseq, directory
      , exceptions, filepath, fsnotify, ghc, ghc-mod, ghc-paths
      , haddock-api, haskell-src-exts, hdocs, hlint, HTTP, lens
-     , monad-loops, MonadCatchIO-transformers, mtl, network, process
+     , lifted-base, monad-control, monad-loops
+     , MonadCatchIO-transformers, mtl, network, process
      , regex-pcre-builtin, scientific, simple-log, system-filepath
-     , template-haskell, text, time, transformers, uniplate, unix
-     , unordered-containers, vector
+     , template-haskell, text, time, transformers, transformers-base
+     , uniplate, unix, unordered-containers, vector
      }:
      mkDerivation {
        pname = "hsdev";
-       version = "0.1.4.0";
-       sha256 = "1m7pfrzi23wq7b3bwp4fc885di96gkg453q8xmlwdip37mh2swgz";
+       version = "0.1.4.1";
+       sha256 = "180xrxamas2fg2366k3cpy7al8mq82d1hgjrs7i1r2s3gr877xz8";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          aeson aeson-pretty array attoparsec base bin-package-db bytestring
          Cabal containers deepseq directory exceptions filepath fsnotify ghc
          ghc-mod ghc-paths haddock-api haskell-src-exts hdocs hlint HTTP
-         lens monad-loops MonadCatchIO-transformers mtl network process
-         regex-pcre-builtin scientific simple-log system-filepath
-         template-haskell text time transformers uniplate unix
-         unordered-containers vector
+         lens lifted-base monad-control monad-loops
+         MonadCatchIO-transformers mtl network process regex-pcre-builtin
+         scientific simple-log system-filepath template-haskell text time
+         transformers transformers-base uniplate unix unordered-containers
+         vector
        ];
        testDepends = [ base ];
        jailbreak = true;
···
     ({ mkDerivation, base, HUnit, mtl }:
      mkDerivation {
        pname = "hset";
-       version = "1.0.1";
-       sha256 = "1iix3syq0cvpiwf6qr6hvcxii6qlzwqcnm416pvndcm7ymkhw04v";
+       version = "1.1.0";
+       sha256 = "15ls3wkk29mf2nyrm80dcmg66q0dd0srgwyv46ix3zkaxs239mbl";
        buildDepends = [ base mtl ];
        testDepends = [ base HUnit mtl ];
        homepage = "https://bitbucket.org/s9gf4ult/hset";
···
      }:
      mkDerivation {
        pname = "hsexif";
-       version = "0.6.0.3";
-       sha256 = "02jpp2p8xmhmx6srpcm330k73x306h34ik2rdavfwpgw5mjk88hl";
+       version = "0.6.0.4";
+       sha256 = "0k9a6d6c2n0x5g6vls4848gydnvw790lf1nyy5piz1rdzsd6bx3k";
        buildDepends = [
          base binary bytestring containers iconv text time
        ];
···
      }:
      mkDerivation {
        pname = "hspec";
-       version = "2.1.8";
-       sha256 = "0nfg9pmlvp8gnllfx01sfslhznjs5xa432ag9s2q2r7c17bxfnwf";
+       version = "2.1.10";
+       sha256 = "0m51afa2n187jjx0fwarg11chakhv3z7fbmqq5rr7j60d9ix9ypq";
        buildDepends = [
          base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
          transformers
···
      }) {};
 
   "hspec-contrib" = callPackage
-    ({ mkDerivation, base, hspec, hspec-core, HUnit, logging-facade
-     , QuickCheck
-     }:
+    ({ mkDerivation, base, hspec, hspec-core, HUnit, QuickCheck }:
      mkDerivation {
        pname = "hspec-contrib";
-       version = "0.2.2";
-       sha256 = "1jdiv41kf73x8rygj7439wrgm345qlfbkshhdy8ikrqs1k43grw6";
-       buildDepends = [ base hspec-core HUnit logging-facade ];
-       testDepends = [
-         base hspec hspec-core HUnit logging-facade QuickCheck
-       ];
+       version = "0.3.0";
+       sha256 = "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4";
+       buildDepends = [ base hspec-core HUnit ];
+       testDepends = [ base hspec hspec-core HUnit QuickCheck ];
        homepage = "http://hspec.github.io/";
        description = "Contributed functionality for Hspec";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "hspec-core";
-       version = "2.1.8";
-       sha256 = "07jhiw0492xcgiidpyizqwaqjja23m35179s12vb54gw4xbh7b6q";
+       version = "2.1.10";
+       sha256 = "1q0fnag7lw54zf6aj55cckcfzs5ykpc841bczap6q9gnwrvpwbk8";
        buildDepends = [
          ansi-terminal async base deepseq hspec-expectations HUnit
          QuickCheck quickcheck-io random setenv tf-random time transformers
···
     ({ mkDerivation, base, directory, filepath, hspec-meta }:
      mkDerivation {
        pname = "hspec-discover";
-       version = "2.1.8";
-       sha256 = "1pyk901rngv1yv4p502qcbbhhw6sgdsdmdwxk1f5r1s7gkvbd9n4";
+       version = "2.1.10";
+       sha256 = "02qs0y7nn8wczjjs606d8ivixxib0024kny2al6mgvxyp524xcgg";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [ base directory filepath ];
···
     ({ mkDerivation, base, HUnit }:
      mkDerivation {
        pname = "hspec-expectations";
-       version = "0.7.0";
-       sha256 = "1gzjnmhi6ia2p5i5jlnj4586rkml5af8f7ijgipzs6fczpx7ds4l";
+       version = "0.7.1";
+       sha256 = "0n52k7qwqc5awig08fvajvymb9bb235q6pp8w0cbcb9a96rwdjmg";
        buildDepends = [ base HUnit ];
        homepage = "https://github.com/sol/hspec-expectations#readme";
        description = "Catchy combinators for HUnit";
···
        license = stdenv.lib.licenses.bsd3;
      }) { qt5 = null;};
 
+  "hsqml-datamodel" = callPackage
+    ({ mkDerivation, base, hsqml, qt5, template-haskell, text }:
+     mkDerivation {
+       pname = "hsqml-datamodel";
+       version = "0.0.0.1";
+       sha256 = "16q92q00q96kyg41xh8smp5vvkvlfrps6nj7ds1y09msdqvihw9v";
+       buildDepends = [ base hsqml template-haskell text ];
+       pkgconfigDepends = [ qt5 ];
+       homepage = "https://github.com/marcinmrotek/hsqml-datamodel";
+       description = "HsQML (Qt5) data model";
+       license = stdenv.lib.licenses.bsd3;
+     }) { qt5 = null;};
+
+  "hsqml-datamodel-vinyl" = callPackage
+    ({ mkDerivation, base, exceptions, hsqml-datamodel, type-list
+     , vinyl
+     }:
+     mkDerivation {
+       pname = "hsqml-datamodel-vinyl";
+       version = "0.1.0.0";
+       sha256 = "0jg3jl1h4jf92vazyf7wb88dhrl89zm9hh21hymzy3pnc5kssd91";
+       buildDepends = [ base exceptions hsqml-datamodel type-list vinyl ];
+       homepage = "https://github.com/marcinmrotek/hsqml-datamodel-vinyl";
+       description = "HsQML DataModel instances for Vinyl Rec";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hsqml-demo-morris" = callPackage
     ({ mkDerivation, base, containers, deepseq, directory, hsqml
      , OddWord, text
···
      }) {};
 
   "htar" = callPackage
-    ({ mkDerivation, base, bytestring, bzlib, directory, filepath
-     , old-locale, tar, time, zlib
+    ({ mkDerivation, base, bytestring, bzlib, directory, filepath, tar
+     , time, zlib
      }:
      mkDerivation {
        pname = "htar";
···
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
-         base bytestring bzlib directory filepath old-locale tar time zlib
+         base bytestring bzlib directory filepath tar time zlib
        ];
-       jailbreak = true;
        description = "Command-line tar archive utility";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.4.18";
-       sha256 = "0skla9kvlak482fsk21gz57jcwc568x3q62nkanxjn1pgxc1jili";
+       version = "0.4.18.1";
+       sha256 = "0v0mmsbh8hgzkxyg7gkn3dlq5l21ljzbxr9c3wmmz6viwhhabfv9";
        buildDepends = [
          array base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie data-default-class deepseq
···
      }:
      mkDerivation {
        pname = "http-conduit";
-       version = "2.1.7.1";
-       sha256 = "15caswd172i8hzwmxsd3rynnfz96v5iqg9avv1ybydikvvgbqx56";
+       version = "2.1.7.2";
+       sha256 = "0inw95a2vdmsffh3ns1kh8hr7xrx2pbgdrq0yv68bwf1v4sd1mfc";
        buildDepends = [
          base bytestring conduit http-client http-client-tls http-types
          lifted-base monad-control mtl resourcet transformers
···
      }) {};
 
   "http-link-header" = callPackage
-    ({ mkDerivation, attoparsec, base, errors, hspec, hspec-attoparsec
-     , network-uri, QuickCheck, text
+    ({ mkDerivation, attoparsec, base, bytestring-conversion, errors
+     , hspec, hspec-attoparsec, network-uri, QuickCheck, text
      }:
      mkDerivation {
        pname = "http-link-header";
-       version = "0.1.0";
-       sha256 = "1lcl0ylj8lq0i2b806k1yqvzbv9dg1m4ka9bmvmhz4z78kiahck1";
-       buildDepends = [ attoparsec base errors network-uri text ];
+       version = "0.2.0";
+       sha256 = "0vdmb0w7ppss8lffdghn9d2vjawn6nvhx7cx1dcvl4fllxfiaihc";
+       buildDepends = [
+         attoparsec base bytestring-conversion errors network-uri text
+       ];
        testDepends = [ base hspec hspec-attoparsec QuickCheck text ];
-       jailbreak = true;
        homepage = "https://github.com/myfreeweb/http-link-header";
        description = "A parser and writer for the HTTP Link header as specified in RFC 5988 \"Web Linking\"";
-       license = stdenv.lib.licenses.asl20;
+       license = stdenv.lib.licenses.publicDomain;
      }) {};
 
   "http-media" = callPackage
···
      }:
      mkDerivation {
        pname = "http2";
-       version = "1.0.2";
-       sha256 = "0wkzphzxzzvqm947l759vxnl6g60nrx7jygyxdlxfgxi51fd7gap";
+       version = "1.0.3";
+       sha256 = "075j4xhfmgiij431zn5mzmq6m40fj74l5f5wckqa22aq2ay19p8c";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "hyperloglog";
-       version = "0.3.3.1";
-       sha256 = "1ns0vz80byssmi39mgdkprpwy26szbmfqqzs1lb6amqf7nx4i14l";
+       version = "0.3.4";
+       sha256 = "122qdkg1xwyhbxll5zimp8w6j79i30102g3iqf41lrbrx0xllpag";
        buildDepends = [
          approximate base binary bits bytes cereal cereal-vector comonad
-         deepseq distributive generic-deriving hashable hashable-extras lens
-         reflection safecopy semigroupoids semigroups siphash tagged vector
+         deepseq distributive hashable hashable-extras lens reflection
+         safecopy semigroupoids semigroups siphash tagged vector
        ];
        testDepends = [
          base directory doctest filepath generic-deriving semigroups
          simple-reflect
        ];
-       jailbreak = true;
        homepage = "http://github.com/analytics/hyperloglog";
        description = "An approximate streaming (constant space) unique object counter";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "hyphenation" = callPackage
-    ({ mkDerivation, base, containers, directory, doctest, filepath
-     , unordered-containers
+    ({ mkDerivation, base, bytestring, containers, directory, doctest
+     , filepath, unordered-containers, zlib
      }:
      mkDerivation {
        pname = "hyphenation";
-       version = "0.5";
-       sha256 = "10xw74d1q2kz8mv8gspa9amgax5a864iz9jxihyjcs9x1pgh762a";
-       buildDepends = [ base containers unordered-containers ];
+       version = "0.6";
+       sha256 = "1xqj4na1gm40ssirc4k70r27bzxhg2dkiipp48a5hqwgq5k3crrg";
+       buildDepends = [
+         base bytestring containers unordered-containers zlib
+       ];
        testDepends = [
          base containers directory doctest filepath unordered-containers
        ];
···
      }) {};
 
   "ib-api" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, network }:
+    ({ mkDerivation, attoparsec, base, bytestring, network, unix }:
      mkDerivation {
        pname = "ib-api";
-       version = "0.1.0.0";
-       revision = "1";
-       sha256 = "1030bj90myx5x3y297qmlmnzppfnh5d3cmwglqj1s7i6nyrh86k5";
-       editedCabalFile = "7cb1fe96767e6253ef55d4997404eb3f4048f1b9bfccfb9e6cca627a734c3bcd";
-       buildDepends = [ attoparsec base bytestring network ];
+       version = "0.1.0.1";
+       sha256 = "0zswsb7mvbm8zycb14sks2kvg4jy2wn3vc7z6lb00s0alm1v0srk";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [ attoparsec base bytestring network unix ];
        jailbreak = true;
        homepage = "https://github.com/rbermani/ib-api";
        description = "An API for the Interactive Brokers Trading Workstation written in pure Haskell";
···
      }:
      mkDerivation {
        pname = "ig";
-       version = "0.3";
-       sha256 = "1sg1dbwjvhixy7qgchg6a2nh76jyp3qlwancj3fcn7c87fmhxdqg";
+       version = "0.3.1";
+       sha256 = "0ggr6h5inwwxvqs9qywiagi1c5bx1vky5h0zvhz0df88nbfd3d21";
        buildDepends = [
          aeson base base16-bytestring bytestring conduit conduit-extra
          crypto-api cryptohash cryptohash-cryptoapi data-default
···
      }) {};
 
   "informative" = callPackage
-    ({ mkDerivation, base, csv, highlighting-kate, http-conduit
-     , monad-logger, pandoc, persistent, persistent-postgresql
-     , shakespeare, text, time, time-locale-compat, yesod, yesod-auth
-     , yesod-core, yesod-form
+    ({ mkDerivation, base, containers, csv, highlighting-kate
+     , http-conduit, monad-logger, pandoc, persistent
+     , persistent-postgresql, shakespeare, text, time
+     , time-locale-compat, yesod, yesod-auth, yesod-core, yesod-form
      }:
      mkDerivation {
        pname = "informative";
-       version = "0.1.0.7";
-       sha256 = "0xzckvbscs3946y7sscx15mixyh3xhahjmwli72311gmyxkf767y";
+       version = "0.1.0.20";
+       sha256 = "1xglpqwr4bc7rqaspq7w6pc9g5ilzvxfb6lfkji3inagg5xksl7n";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         base csv highlighting-kate http-conduit monad-logger pandoc
-         persistent persistent-postgresql shakespeare text time
+         base containers csv highlighting-kate http-conduit monad-logger
+         pandoc persistent persistent-postgresql shakespeare text time
          time-locale-compat yesod yesod-auth yesod-core yesod-form
        ];
        jailbreak = true;
···
      }:
      mkDerivation {
        pname = "inilist";
-       version = "0.1.0.0";
-       sha256 = "18f93kvc5x0y1wqcicrh510r3skldf52jn0n6cxyn7fk2271cc1b";
+       version = "0.2.0.0";
+       sha256 = "1rr71yajc6j0idsqgna8mbnawiv6iw1x8kswkv7x2l0ih89r6y3a";
        buildDepends = [ base bifunctors containers safe trifecta ];
        testDepends = [
          base bifunctors containers deepseq HUnit safe tasty tasty-hunit
···
      mkDerivation {
        pname = "instant-generics";
        version = "0.5";
+       revision = "1";
        sha256 = "174avn0jjxv4h04m6k85gvv6x3kvrlwhcbhqg9ih0ps5mp7crmvr";
+       editedCabalFile = "c69a74fef28272e5e46a0e37711bb980ac07d2f3feeed3513da1cc572a1ab6bc";
        buildDepends = [ base containers syb template-haskell ];
        homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/InstantGenerics";
        description = "Generic programming library with a sum of products view";
···
      mkDerivation {
        pname = "instant-zipper";
        version = "0.0.0";
+       revision = "1";
        sha256 = "0gd5hzlm5rlmzba2dl37al711vp1nn2b30d36rvb2j8y90y8c44c";
+       editedCabalFile = "a0e15510d3e3eefaa18d20fbfce7a1840519e160e2a8a8b36c498a3664b9c037";
        buildDepends = [ base instant-generics mtl ];
+       jailbreak = true;
        description = "Heterogenous Zipper in Instant Generics";
        license = "GPL";
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }) {};
 
   "invariant" = callPackage
-    ({ mkDerivation, base, contravariant, hspec, QuickCheck }:
+    ({ mkDerivation, array, base, bifunctors, containers, contravariant
+     , ghc-prim, hspec, profunctors, QuickCheck, semigroups, stm, tagged
+     , template-haskell, transformers, transformers-compat
+     , unordered-containers
+     }:
      mkDerivation {
        pname = "invariant";
-       version = "0.1.2";
-       sha256 = "02p114wnpxbqxik4sz87bd9rcqfs9klgsxi9pc4v1qwyb64mb92b";
-       buildDepends = [ base contravariant ];
+       version = "0.2";
+       sha256 = "0zxzpbha3z4z23xmsbgajjxk477ad1v28ml3rry0102lpcpvl6j1";
+       buildDepends = [
+         array base bifunctors containers contravariant ghc-prim profunctors
+         semigroups stm tagged template-haskell transformers
+         transformers-compat unordered-containers
+       ];
        testDepends = [ base hspec QuickCheck ];
+       homepage = "https://github.com/nfrisby/invariant-functors";
        description = "Haskell 98 invariant functors";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "io-streams";
-       version = "1.3.1.0";
-       sha256 = "1fic83lgvyji75gyx8c9ik9lj6jf65wbqmzp30siqmkhdp9y1rxf";
+       version = "1.3.2.0";
+       sha256 = "0gqj2adc3zlwz81wy38y8x4rihvhk4zm9xb0rd04a77nn15xlc0y";
        buildDepends = [
          attoparsec base bytestring bytestring-builder network primitive
          process text time transformers vector zlib-bindings
···
          time transformers vector zlib zlib-bindings
        ];
        configureFlags = [ "-fnointeractivetests" ];
-       jailbreak = true;
        description = "Simple, composable, and easy-to-use stream I/O";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "irc-client";
-       version = "0.2.3.1";
-       sha256 = "1i5wsqkz8b0h3vc4xjb1n7dqjhqqlka1pchhwax9w9lvnhw5wl9v";
+       version = "0.2.4.0";
+       sha256 = "137ix1x2qy92v5naaq3lz3iyvbxvf32gnsq09flddadx88d51vv6";
        buildDepends = [
          base bytestring conduit data-default-class irc-conduit irc-ctcp
          old-locale stm stm-conduit text time transformers
        ];
        homepage = "https://github.com/barrucadu/irc-client";
        description = "An IRC client library";
-       license = "unknown";
+       license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "irc-conduit";
-       version = "0.1.1.2";
-       sha256 = "1ib75a7dp9f6v7zl51a5z1pvv0vpll6czf5i8zad7ajn3q9d4z3p";
+       version = "0.1.2.0";
+       sha256 = "1mw418frhbnk7gncilvb2c3cj4fvzm5fvafq0p28vggxisda9bkp";
        buildDepends = [
          async base bytestring conduit conduit-extra connection irc irc-ctcp
          network-conduit-tls text time tls transformers x509-validation
        ];
        homepage = "https://github.com/barrucadu/irc-conduit";
        description = "Streaming IRC message library using conduits";
-       license = "unknown";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "irc-core" = callPackage
···
     ({ mkDerivation, base, bytestring, text }:
      mkDerivation {
        pname = "irc-ctcp";
-       version = "0.1.2.1";
-       revision = "1";
-       sha256 = "1bpn9i9mqmhiif6mhw6q9nzy5cwx1x1yh81216gkqc5gi43gsc5s";
-       editedCabalFile = "23e92ff7cad332b34f89273fe543e9b8b87a19b30fb1a18fad61c9c3952d0dce";
+       version = "0.1.3.0";
+       sha256 = "16mp9dpp57id760zc932dszd5r1ncskwwxrp0djka5r1alddjz6n";
        buildDepends = [ base bytestring text ];
        homepage = "https://github.com/barrucadu/irc-ctcp";
        description = "A CTCP encoding and decoding library for IRC clients";
-       license = "unknown";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "irc-fun-color" = callPackage
···
      }) {};
 
   "kademlia" = callPackage
-    ({ mkDerivation, base, bytestring, containers, mtl, network, stm
+    ({ mkDerivation, base, bytestring, containers, HUnit, mtl, network
+     , QuickCheck, stm, tasty, tasty-hunit, tasty-quickcheck
      , transformers, transformers-compat
      }:
      mkDerivation {
        pname = "kademlia";
-       version = "1.0.0.0";
-       revision = "1";
-       sha256 = "0f1kwflpizabzyal3x3p9sra3kxlgm2m14xfxnl4k3bndmj02sdb";
-       editedCabalFile = "2553e98d53372b8d4947c115dd696e33f526f0304e9ed39566e6beec276ca641";
+       version = "1.1.0.0";
+       sha256 = "0wjyslrhbms6cnm495g40yl6365h3vgjcka12lka8xdy89v3c0yy";
        buildDepends = [
          base bytestring containers mtl network stm transformers
          transformers-compat
+       ];
+       testDepends = [
+         base bytestring containers HUnit mtl network QuickCheck stm tasty
+         tasty-hunit tasty-quickcheck transformers transformers-compat
        ];
        homepage = "https://github.com/froozen/kademlia";
        description = "An implementation of the Kademlia DHT Protocol";
···
      , conduit-extra, containers, data-default, directory, filepath
      , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
      , http-types, HUnit, lifted-base, mtl, network, process, random
-     , regex-tdfa, stm, system-filepath, tar, template-haskell, text
-     , time, transformers, unix, unix-compat, unordered-containers
-     , vector, wai, wai-app-static, wai-extra, warp, warp-tls, yaml
-     , zlib
+     , regex-tdfa, stm, tar, template-haskell, text, time, transformers
+     , unix, unix-compat, unordered-containers, vector, wai
+     , wai-app-static, wai-extra, warp, warp-tls, yaml, zlib
      }:
      mkDerivation {
        pname = "keter";
-       version = "1.4.2.1";
-       sha256 = "1xwnprbmssvvymwyvcgczlsldplr2va53mzdphqs6969xhhpahh3";
+       version = "1.4.3.1";
+       sha256 = "0bsq6z7krisshcrkb528kixiw6liabb7chgk87088vn3gpwx048i";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          case-insensitive conduit conduit-extra containers data-default
          directory filepath fsnotify http-client http-conduit
          http-reverse-proxy http-types lifted-base mtl network process
-         random regex-tdfa stm system-filepath tar template-haskell text
-         time transformers unix unix-compat unordered-containers vector wai
-         wai-app-static wai-extra warp warp-tls yaml zlib
+         random regex-tdfa stm tar template-haskell text time transformers
+         unix unix-compat unordered-containers vector wai wai-app-static
+         wai-extra warp warp-tls yaml zlib
        ];
        testDepends = [
          base bytestring conduit hspec HUnit transformers unix
···
      }) {};
 
   "kmeans-vector" = callPackage
-    ({ mkDerivation, base, mtl, QuickCheck, vector }:
+    ({ mkDerivation, base, mtl, probable, vector }:
      mkDerivation {
        pname = "kmeans-vector";
-       version = "0.3";
-       sha256 = "0n957b7pcq3v8kf4507crbrd172mv9g14p5hmpalfjzlpb3b5ll1";
+       version = "0.3.2";
+       sha256 = "1ckw3dmwwqzgbl0wcd6h435afjddqmim3y19p2wqcghxd2rk8bdv";
        isLibrary = true;
        isExecutable = true;
-       buildDepends = [ base mtl QuickCheck vector ];
+       buildDepends = [ base mtl probable vector ];
        homepage = "http://github.com/alpmestan/kmeans-vector";
        description = "An implementation of the kmeans clustering algorithm based on the vector package";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "kraken" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-client
+     , http-client-tls, mtl
+     }:
+     mkDerivation {
+       pname = "kraken";
+       version = "0.0.1";
+       sha256 = "1df6g65wrhzfz3kj9n4bcja09adr4qhl3kzv5vaxl37lbr9nwzr2";
+       buildDepends = [
+         aeson base bytestring http-client http-client-tls mtl
+       ];
+       description = "Kraken.io API client";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "krpc" = callPackage
     ({ mkDerivation, base, bencoding, bytestring, containers
      , data-default-class, hspec, lifted-base, monad-control
···
     ({ mkDerivation, base, containers, mtl, read-bounded }:
      mkDerivation {
        pname = "lambda-options";
-       version = "0.7.0.0";
-       sha256 = "0y8q9k3lk71703qzm0bvqh30y7r5ms392gfzh2lcrqkr0mhlf89j";
+       version = "0.8.0.0";
+       sha256 = "1z9gmps06w458v8i3zpkalby83p367r3z9i0c312jxl0zp51q891";
        buildDepends = [ base containers mtl read-bounded ];
        jailbreak = true;
        homepage = "https://github.com/thomaseding/lambda-options";
···
      }:
      mkDerivation {
        pname = "lambdabot";
-       version = "5.0.2.2";
-       sha256 = "148s2qlwcs7g89a77xv07yjyjrcnd6x7alvghbldvv4p067f0n86";
+       version = "5.0.3";
+       sha256 = "1kbrmxz5604jzcx9l6j4lmbb0xqz2cmj0f30nmpzdkmzsqv1hfj2";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "lambdabot-core";
-       version = "5.0.1";
-       sha256 = "06asm62k2nb32yr0z4sw70z0r4ikakgkph6zqhjw7wj14ic2nxbk";
+       version = "5.0.3";
+       sha256 = "12gawsimdqch61rh4zwvzrx6pqx8yd645wqpki8dr56wnmbhbr03";
        buildDepends = [
          base binary bytestring containers dependent-map dependent-sum
          dependent-sum-template directory edit-distance filepath haskeline
···
      }:
      mkDerivation {
        pname = "lambdabot-haskell-plugins";
-       version = "5.0.2.1";
-       sha256 = "06jcx3qp87fk58cvnwljr4zyvlqcsfrq0nxg2m67kd2imyg10iyd";
+       version = "5.0.3";
+       sha256 = "0iya4zipjjaqrld0a1v334praw1vnw186scfsi6inqdg314jc7x1";
        buildDepends = [
          array arrows base bytestring containers data-memocombinators
          directory filepath haskell-src-exts hoogle HTTP IOSpec
···
          parsec pretty process QuickCheck regex-tdfa show split syb
          transformers utf8-string vector-space
        ];
-       jailbreak = true;
        homepage = "http://haskell.org/haskellwiki/Lambdabot";
        description = "Lambdabot Haskell plugins";
        license = "GPL";
···
      }:
      mkDerivation {
        pname = "lambdabot-irc-plugins";
-       version = "5.0.1";
-       sha256 = "13ybjyx5x84g0w7l2yyni5yary59j4kpaqc4pl1942bp6y7lbfrp";
+       version = "5.0.3";
+       sha256 = "1v4zh2yjdgy9ix6dmxdh8j5iqyrixaln78c5jgpiyjcwgi17blrw";
        buildDepends = [
          base bytestring containers directory filepath lambdabot-core
          lifted-base mtl network SafeSemaphore split time
···
      }:
      mkDerivation {
        pname = "lambdabot-novelty-plugins";
-       version = "5.0.2.1";
-       sha256 = "07zx59jfsdq7lbfmfq9l3xbbdm0fhzidi5vcripfp5wry8xshn5y";
+       version = "5.0.3";
+       sha256 = "086y8p92a8g2zjjkxj1ny4s1dlza2dz1v64g3jg7p0dz1n1s1jpy";
        buildDepends = [
          base binary brainfuck bytestring containers dice directory
          lambdabot-core misfortune process random-fu regex-tdfa unlambda
···
      }:
      mkDerivation {
        pname = "lambdabot-reference-plugins";
-       version = "5.0.2.1";
-       sha256 = "0xg70m58n03lym8z3lsf0mh634xwb48sj39cfydsacdn5gx0i8kc";
+       version = "5.0.3";
+       sha256 = "1yw1l0jl4iym2q2lfgzcmxm8865av37kf7zji0f7in2phqs3r1zz";
        buildDepends = [
          base bytestring containers HTTP lambdabot-core mtl network
          network-uri oeis process regex-tdfa split tagsoup utf8-string
        ];
-       jailbreak = true;
        homepage = "http://haskell.org/haskellwiki/Lambdabot";
        description = "Lambdabot reference plugins";
        license = "GPL";
···
      }:
      mkDerivation {
        pname = "lambdacms-media";
-       version = "0.3.0.1";
-       sha256 = "074bghfbi3m4ffla34z0yq2qgbw3ps81fq2cm8ibqry3bps511xp";
+       version = "0.4.0.0";
+       sha256 = "0vq32qppnasc24jrjh6c19hr2pxby65c5m5k90fk7afyms307b5c";
        buildDepends = [
          base directory filepath lambdacms-core persistent shakespeare text
          time yesod yesod-form
···
      }:
      mkDerivation {
        pname = "language-javascript";
-       version = "0.5.13.3";
-       sha256 = "069spax169v0qq5axwccgxdmiyjlnjg1bhzqh09dp5yx9w5fk47x";
+       version = "0.5.14.2";
+       sha256 = "0inm6yncl5dv9ij3fyk38c6mad8fm1vqs70rpqi1a7w2n5cbv1ia";
        buildDepends = [
          array base blaze-builder bytestring containers mtl utf8-string
        ];
···
          utf8-string
        ];
        buildTools = [ alex happy ];
-       homepage = "http://github.com/alanz/language-javascript";
+       homepage = "http://github.com/erikd/language-javascript";
        description = "Parser for JavaScript";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }) {};
 
   "language-thrift" = callPackage
-    ({ mkDerivation, base, mtl, parsers, text, trifecta }:
+    ({ mkDerivation, base, hspec, hspec-discover, mtl, parsers
+     , QuickCheck, text, trifecta, wl-pprint
+     }:
      mkDerivation {
        pname = "language-thrift";
-       version = "0.2.0.0";
-       sha256 = "01wvpm4aa222ic8z6wg0wdjyfnkd8gh2kqsda7qfckcyxs9679qw";
-       buildDepends = [ base mtl parsers text trifecta ];
+       version = "0.4.0.0";
+       sha256 = "0al6a9j9hwla8kyfw30m9ylw4wzxv0nr3nvri8w9wnh6ckaf5j2w";
+       buildDepends = [ base mtl parsers text trifecta wl-pprint ];
+       testDepends = [
+         base hspec hspec-discover QuickCheck text trifecta wl-pprint
+       ];
        homepage = "https://github.com/abhinav/language-thrift";
-       description = "Parser for the Thrift IDL format";
+       description = "Parser and pretty printer for the Thrift IDL format";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
···
          leksah-server ltk monad-loops QuickCheck stm text transformers
          webkitgtk3
        ];
+       jailbreak = true;
        homepage = "http://www.leksah.org";
        description = "Haskell IDE written in Haskell";
        license = "GPL";
···
      }:
      mkDerivation {
        pname = "lens";
-       version = "4.12.1";
-       revision = "1";
-       sha256 = "0rzi0z5vz78v99f1hk8izixhxf3linz3xjkancg8x65g03brwl33";
-       editedCabalFile = "fedce7a783a5a622bb19e00145e775ff8ea7d797f71fd22c9eb2257672b7f741";
+       version = "4.12.3";
+       sha256 = "0898z1ws9sy77yfhvx5did0pibpp81yxz0jg418gdx3znd39vyj8";
        buildDepends = [
          array base base-orphans bifunctors bytestring comonad containers
          contravariant distributive exceptions filepath free ghc-prim
···
      }:
      mkDerivation {
        pname = "lentil";
-       version = "0.1.2.7";
-       sha256 = "1g3if2y41li6wyg7ffvpybqvbywiq8bf5b5fb6pz499hinzahb9d";
+       version = "0.1.3.1";
+       sha256 = "19zjwkj9is5fdayvwf6w8r42z0lyrbj2lqqw822zr87xaq96r2g2";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }) {};
 
   "libpafe" = callPackage
-    ({ mkDerivation, base, bytestring, iconv, pafe }:
+    ({ mkDerivation, base, bytestring, iconv, pafe, transformers }:
      mkDerivation {
        pname = "libpafe";
-       version = "0.1.0.0";
-       sha256 = "1qb67zb7fh582ws1j1hi704dkzp7am0jjxjnab29kpm6i3xmzprk";
-       buildDepends = [ base ];
-       testDepends = [ base bytestring iconv ];
+       version = "0.1.1.0";
+       sha256 = "1l2s98y805mgxnwy2jvrab65gz1aq5zf48rqk88nclb97w04lnws";
+       buildDepends = [ base transformers ];
+       testDepends = [ base bytestring iconv transformers ];
        extraLibraries = [ pafe ];
        jailbreak = true;
        description = "Wrapper for libpafe";
···
     ({ mkDerivation, base, bytestring, cpu }:
      mkDerivation {
        pname = "libvorbis";
-       version = "0.1.0.0";
-       sha256 = "1rl8hqbidxj34j3m8nwy32a9fnbzand726zvyljkgpjfkg1mfb2c";
+       version = "0.1.0.1";
+       sha256 = "0ykv2jv559yalypadwnvpzv87rksn24b4h8qi9x1x6r2x4kbwvrl";
        buildDepends = [ base bytestring cpu ];
-       jailbreak = true;
        homepage = "https://github.com/the-real-blackh/libvorbis";
        description = "Haskell binding for libvorbis, for decoding Ogg Vorbis audio files";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "located-base" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "located-base";
+       version = "0.1.0.0";
+       sha256 = "0jb4ziagvbvgaihgw9ajsni0nylqbh5hw3q4dw561qmx2msjjfpj";
+       buildDepends = [ base ];
+       jailbreak = true;
+       homepage = "http://github.com/gridaphobe/located-base";
+       description = "Location-aware variants of partial functions";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "locators" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, cryptohash
      , hspec, hspec-expectations, HUnit, QuickCheck
···
      }:
      mkDerivation {
        pname = "log-domain";
-       version = "0.10.1.1";
-       sha256 = "084mzaha7g00yxxy4hgl2dia73hzch91961gjvrb20wv6zxf8f7g";
+       version = "0.10.2";
+       sha256 = "0v91xilbgw0cym43fn5abz5ljrxz8anfj1w5x6nzp1qcqcwgwcg4";
        buildDepends = [
-         base binary bytes cereal comonad deepseq distributive
-         generic-deriving hashable hashable-extras safecopy semigroupoids
-         semigroups vector
+         base binary bytes cereal comonad deepseq distributive hashable
+         hashable-extras safecopy semigroupoids semigroups vector
        ];
        testDepends = [
          base directory doctest filepath generic-deriving semigroups
          simple-reflect
        ];
-       jailbreak = true;
        homepage = "http://github.com/analytics/log-domain/";
        description = "Log-domain arithmetic";
        license = stdenv.lib.licenses.bsd3;
···
          base Cabal containers filepath ghc glib gtk3 mtl parsec pretty text
          transformers
        ];
+       jailbreak = true;
        homepage = "http://www.leksah.org";
        description = "Leksah tool kit";
        license = "GPL";
···
        license = stdenv.lib.licenses.bsd3;
      }) { inherit (pkgs) lzma;};
 
+  "lzma-streams" = callPackage
+    ({ mkDerivation, base, bytestring, HUnit, io-streams, lzma
+     , QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "lzma-streams";
+       version = "0.0.0.0";
+       sha256 = "0klgi097b8mky989hfzn3kk3r25yq1p0sjna4r68k7z9y143yzm2";
+       buildDepends = [ base bytestring io-streams ];
+       testDepends = [
+         base bytestring HUnit io-streams QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2
+       ];
+       extraLibraries = [ lzma ];
+       homepage = "https://github.com/hvr/lzma-streams";
+       description = "IO-Streams interface for lzma/xz compression";
+       license = stdenv.lib.licenses.bsd3;
+     }) { inherit (pkgs) lzma;};
+
   "maam" = callPackage
     ({ mkDerivation, base, Cabal, containers, directory, ghc
      , template-haskell, text
···
     ({ mkDerivation, base, containers, srcloc, text }:
      mkDerivation {
        pname = "mainland-pretty";
-       version = "0.4.0.0";
-       sha256 = "1nym3qiyjgag6jpra1cfm8b722h8ghi0f2dv74y6migzqh768myl";
+       version = "0.4.1.0";
+       sha256 = "0r8xhlbpws6wq305dv3z074d7492jif9dsscz4sjbwvh5dk4x1zl";
        buildDepends = [ base containers srcloc text ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "Pretty printing designed for printing source code";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "microformats2-parser" = callPackage
+    ({ mkDerivation, base, blaze-html, blaze-markup, containers
+     , data-default, either, hspec, html-conduit, microformats2-types
+     , network, options, pcre-heavy, raw-strings-qq, safe, scotty
+     , streaming-commons, stringable, template-haskell, text, time
+     , wai-extra, warp, xml-lens, xss-sanitize
+     }:
+     mkDerivation {
+       pname = "microformats2-parser";
+       version = "0.1.1";
+       sha256 = "0n4clyzaw2a9vi0qcf6f2pdp7wckl3z84sfjqdj8k4dbp1qnwl55";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         base blaze-html blaze-markup containers data-default either
+         html-conduit microformats2-types network options pcre-heavy safe
+         scotty streaming-commons stringable text time wai-extra warp
+         xml-lens xss-sanitize
+       ];
+       testDepends = [
+         base data-default hspec html-conduit microformats2-types
+         raw-strings-qq template-haskell time xml-lens
+       ];
+       homepage = "https://github.com/myfreeweb/microformats2-parser";
+       description = "A Microformats 2 parser";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "microformats2-types" = callPackage
     ({ mkDerivation, aeson, base, data-default-class, pandoc-types
      , setters, text, time
      }:
      mkDerivation {
        pname = "microformats2-types";
-       version = "0.4.0";
-       sha256 = "020193sbvg5arha9pvbc88wqrqyvshy19kz02knkh5kv0dzqngf6";
+       version = "0.4.1";
+       sha256 = "1p2s2g78bnqbcf0www0x11pz5nyxjfac7q7sbd2qfn1v777ylv7b";
        buildDepends = [
          aeson base data-default-class pandoc-types setters text time
        ];
        homepage = "https://github.com/myfreeweb/microformats2-types";
        description = "Microformats 2 types (with Aeson instances)";
-       license = "unknown";
+       license = stdenv.lib.licenses.publicDomain;
      }) {};
 
   "microlens" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "microlens";
-       version = "0.1.0.0";
-       sha256 = "173ak9flxdpck7q5b3r38bpgbiv9mzmiz89y3f1wn0wz3q957p44";
+       version = "0.1.3.0";
+       sha256 = "1ryjxc3qa583ryp9sig3rjjr3dpv9sx2ybag4qrlkwja1dz8r2dm";
        buildDepends = [ base ];
        homepage = "http://github.com/aelve/microlens";
-       description = "A tiny part of the ‘lens’ library which you can depend upon";
+       description = "A tiny part of the lens library which you can depend upon";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }) {};
 
   "microlens-mtl" = callPackage
-    ({ mkDerivation, base, microlens, mtl }:
+    ({ mkDerivation, base, microlens, mtl, transformers
+     , transformers-compat
+     }:
      mkDerivation {
        pname = "microlens-mtl";
-       version = "0.1.0.0";
-       sha256 = "0wz61g71c0w12apwziww2b6snbmyhfhm2f1304rw4gasify9q5s8";
-       buildDepends = [ base microlens mtl ];
+       version = "0.1.2.0";
+       sha256 = "1jvw9pspnr24rh7bvl6q7hv7x0g6vwy2a5xl19pxf36rl8wlfm9v";
+       buildDepends = [
+         base microlens mtl transformers transformers-compat
+       ];
        homepage = "http://github.com/aelve/microlens";
        description = "microlens support for Reader/Writer/State from mtl";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, containers, microlens, template-haskell }:
      mkDerivation {
        pname = "microlens-th";
-       version = "0.1.0.0";
-       sha256 = "0balhqdlj8ighzda5g9qz8s634jlf4pjxs3hvgaqp2rw56jc4i12";
+       version = "0.2.0.0";
+       sha256 = "048q6ridxvg7zi272q01k6ds0f411kg27p5whgj63qgg3k9w72sp";
        buildDepends = [ base containers microlens template-haskell ];
        homepage = "http://github.com/aelve/microlens";
-       description = "Automatic generation of record lenses for 'microlens'";
+       description = "Automatic generation of record lenses for microlens";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "moesocks" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
+     , containers, cryptohash, hslogger, HsOpenSSL, lens, mtl, network
+     , optparse-applicative, random, safe, text, transformers, unix
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "moesocks";
+       version = "0.1.0.8";
+       sha256 = "1f09sf41kbza3mci2yps0b38xi2j5gakjqx9hmi7lfzga4dkqgg0";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         aeson attoparsec base binary bytestring containers cryptohash
+         hslogger HsOpenSSL lens mtl network optparse-applicative random
+         safe text transformers unix unordered-containers
+       ];
+       homepage = "https://github.com/nfjinjing/moesocks";
+       description = "moe for all";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "mohws" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-accessor
      , directory, explicit-exception, filepath, html, HTTP, network
···
      }:
      mkDerivation {
        pname = "monad-extras";
-       version = "0.5.9";
-       sha256 = "1y24yz635brllfygia1mbln4d8xiwb0pq0izh5pil7511gijhs0s";
+       version = "0.5.11";
+       sha256 = "0rq44dk1fvfqkhng2yczyyz7jh6d6m0kjy58k02ady28f7j2r5vn";
        buildDepends = [
          base mmorph monad-control stm transformers transformers-base
        ];
···
      }:
      mkDerivation {
        pname = "monoidal-containers";
-       version = "0.1.2.1";
-       sha256 = "1n76vjh785yzirfkh63nlrpi9y1bb9z1r3v514150wfxjn3n723j";
+       version = "0.1.2.2";
+       sha256 = "06yam4ljp4lm2rjaccykg8zx4hnmn0ly3fs24xjm4q45ldz7gwyb";
        buildDepends = [
          base containers deepseq hashable lens newtype unordered-containers
        ];
-       jailbreak = true;
        homepage = "http://github.com/bgamari/monoidal-containers";
        description = "Containers with monoidal accumulation";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "morte";
-       version = "1.2.0";
-       sha256 = "0mr2aaf4r15ysmymqixd592z5w56973qv8ww1d7vkyvj851gfm01";
+       version = "1.2.1";
+       sha256 = "15zvk50qpp3ywkwqgpm4phdcspfszzwipxcf07lnxpk98i7ybc4g";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        description = "Monad transformer library using type families";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "mtl-unleashed" = callPackage
+    ({ mkDerivation, base, mtl }:
+     mkDerivation {
+       pname = "mtl-unleashed";
+       version = "0.2.2";
+       sha256 = "0ih03zznq8mf8c76ic43j3vana6127bh6hxfz549g5kv9h54y83h";
+       buildDepends = [ base mtl ];
+       homepage = "https://github.com/seereason/mtl-unleashed";
+       description = "MTL classes without the functional dependency";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "mtlparse" = callPackage
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "myo" = callPackage
+    ({ mkDerivation, aeson, base, containers, inline-c, lens-family
+     , lens-family-th, scientific, tasty, tasty-hunit, template-haskell
+     , text, vector, websockets
+     }:
+     mkDerivation {
+       pname = "myo";
+       version = "0.1.0.0";
+       sha256 = "0sn3ic3h94ff57igs61l2cq82y6xxz87qflm8dykwwy721swq1qn";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         aeson base containers inline-c lens-family lens-family-th
+         scientific template-haskell text vector websockets
+       ];
+       testDepends = [ base tasty tasty-hunit ];
+       homepage = "http://github.com/adinapoli/myo";
+       description = "Haskell binding to the Myo armband";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "mysnapsession" = callPackage
     ({ mkDerivation, base, bytestring, cereal, clientsession
      , containers, mtl, random, regex-posix, snap, snap-core, time
···
      }:
      mkDerivation {
        pname = "nationstates";
-       version = "0.1.0.2";
-       sha256 = "0h01dxf8f2h18cx6ag67370l492jvyqh15ijipxzr1gwmkmnymrl";
+       version = "0.2.0.0";
+       sha256 = "07rs7c5pvq6x8icg5pzk613vazcnnl3rfrcsf3zw6i8gaxh0dq48";
        buildDepends = [
          base bytestring clock containers http-client http-client-tls
          http-types multiset transformers xml
···
      }:
      mkDerivation {
        pname = "nested-routes";
-       version = "3.1.0";
-       sha256 = "128i669x31c4jagnamzlsv3z584rpijpmc832hr96004qkwr692n";
+       version = "3.2.0";
+       sha256 = "02mj54a797h9ywa0985xw8pspl953xgn813r6mz2apx0mk6gp1xg";
        buildDepends = [
          aeson attoparsec base blaze-html bytestring clay composition
          constraints containers http-media http-types lucid mtl poly-arity
···
     ({ mkDerivation, base, bytestring, network, text, time, vector }:
      mkDerivation {
        pname = "network-carbon";
-       version = "1.0.3";
-       revision = "1";
-       sha256 = "0wk3rds1d2c6nr9gdz9qgpqhmkqkdkk0rqxzj3rznv0n9m9sylcr";
-       editedCabalFile = "6500f60c0b037a1e680ef3356ce43e27f145efe2cf85f63cb2e670cb344a926d";
+       version = "1.0.5";
+       sha256 = "0kb3gz8545dgi93ys9pk240vap7zjnl2npn1xryng2ijl7ssn9li";
        buildDepends = [ base bytestring network text time vector ];
        homepage = "http://github.com/ocharles/network-carbon";
        description = "A Haskell implementation of the Carbon protocol (part of the Graphite monitoring tools)";
···
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "0.0.1";
-       sha256 = "1zma19lb4kzzfiabkx55ffgvdqrycijpm2yz3jszm1m6m58khif5";
+       version = "0.0.2";
+       sha256 = "0f551qr7dgn6p4slr0yyfw7v2c6j6w1haqzgc7n7phrgmnhvrhzp";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "opaleye-sqlite" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring
+     , case-insensitive, containers, contravariant, direct-sqlite
+     , pretty, product-profunctors, profunctors, QuickCheck, semigroups
+     , sqlite-simple, text, time, time-locale-compat, transformers, uuid
+     , void
+     }:
+     mkDerivation {
+       pname = "opaleye-sqlite";
+       version = "0.0.1.0";
+       sha256 = "0r3ij02wkxq50hl70wn53fdr1qi5gigg4x3y0vabm53gabgxdbxq";
+       buildDepends = [
+         base base16-bytestring bytestring case-insensitive contravariant
+         direct-sqlite pretty product-profunctors profunctors semigroups
+         sqlite-simple text time time-locale-compat transformers uuid void
+       ];
+       testDepends = [
+         base containers contravariant product-profunctors profunctors
+         QuickCheck semigroups sqlite-simple time
+       ];
+       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
+       description = "An SQL-generating DSL targeting SQLite";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "open-browser" = callPackage
+    ({ mkDerivation, base, process }:
+     mkDerivation {
+       pname = "open-browser";
+       version = "0.2.0.0";
+       sha256 = "093i475l9gyb5jyk2m6fdz1dw2jm545rlrbmwqz3vfdfy2ikcks3";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [ base process ];
+       description = "Open a web browser from Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "open-pandoc" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory
      , extensible-exceptions, filepath, HTTP, mtl, network, old-time
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "openflow" = callPackage
+    ({ mkDerivation, aeson, base, bimap, binary, bytestring, containers
+     , deepseq-generics, hashable, network
+     }:
+     mkDerivation {
+       pname = "openflow";
+       version = "0.3.0";
+       sha256 = "0dhg34s4imr1v6wlc567qg5929wa82my7jbhxm9hqq0882vb0sb2";
+       buildDepends = [
+         aeson base bimap binary bytestring containers deepseq-generics
+         hashable network
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/AndreasVoellmy/openflow";
+       description = "OpenFlow";
+       license = "unknown";
+     }) {};
+
   "opengles" = callPackage
     ({ mkDerivation, base, bytestring, distributive, EGL
      , future-resource, ghc-prim, GLESv2, lens, linear, packer, vector
···
     ({ mkDerivation, base, opentheory-primitive, QuickCheck }:
      mkDerivation {
        pname = "opentheory";
-       version = "1.199";
-       sha256 = "1il1lyjmv7ij7clnbc57ajpfwlg5a5ld3m619hxylpafyrbr4v5y";
+       version = "1.200";
+       sha256 = "0fdxrpsw3c4p1y80xfab0cl5zhkjcp9dlylgxywzq5kcpqv07ifh";
        buildDepends = [ base opentheory-primitive QuickCheck ];
        testDepends = [ base opentheory-primitive QuickCheck ];
        homepage = "http://opentheory.gilith.com/?pkg=base";
···
          base opentheory opentheory-primitive opentheory-probability
          QuickCheck
        ];
+       jailbreak = true;
        homepage = "http://opentheory.gilith.com/?pkg=natural-bits";
        description = "Natural number to bit-list conversions";
        license = stdenv.lib.licenses.mit;
···
          base opentheory opentheory-bits opentheory-primitive
          opentheory-probability QuickCheck
        ];
+       jailbreak = true;
        homepage = "http://opentheory.gilith.com/?pkg=byte";
        description = "Bytes";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "opentheory-divides";
-       version = "1.62";
-       sha256 = "182c14c1j9m82pnx6crxgrry02yvixziap9ikhavx7krr52vdwbv";
+       version = "1.63";
+       sha256 = "1jax8103yhgmbwfzbpnis4nj6f90n3wizb2znvafd4pw2afs5mkv";
        buildDepends = [ base opentheory opentheory-primitive QuickCheck ];
        testDepends = [ base opentheory opentheory-primitive QuickCheck ];
        homepage = "http://opentheory.gilith.com/?pkg=natural-divides";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "opentheory-fibonacci" = callPackage
+    ({ mkDerivation, base, opentheory, opentheory-primitive
+     , opentheory-stream, QuickCheck
+     }:
+     mkDerivation {
+       pname = "opentheory-fibonacci";
+       version = "1.69";
+       sha256 = "09rqz7fixh1k4ya1aci7v0wy0sz2m7j5cj66plcbvpv6p03yq1vv";
+       buildDepends = [
+         base opentheory opentheory-primitive opentheory-stream QuickCheck
+       ];
+       testDepends = [
+         base opentheory opentheory-primitive opentheory-stream QuickCheck
+       ];
+       description = "Fibonacci numbers";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "opentheory-parser" = callPackage
     ({ mkDerivation, base, opentheory, opentheory-primitive, QuickCheck
      }:
···
        sha256 = "0325g7m5z64dg8sihmcgi9rmkms6r76hf1d7927v08dl5xh4dlhi";
        buildDepends = [ base opentheory opentheory-primitive QuickCheck ];
        testDepends = [ base opentheory opentheory-primitive QuickCheck ];
+       jailbreak = true;
        homepage = "http://opentheory.gilith.com/?pkg=parser";
        description = "Stream parsers";
        license = stdenv.lib.licenses.mit;
···
          base opentheory opentheory-divides opentheory-primitive
          opentheory-stream QuickCheck
        ];
+       jailbreak = true;
        homepage = "http://opentheory.gilith.com/?pkg=natural-prime";
        description = "Prime natural numbers";
        license = stdenv.lib.licenses.mit;
···
        version = "1.49";
        sha256 = "0dszjszjdabgafpvxiailpgzm7y96f4a8zhjfhin3m36f3lb0dmy";
        buildDepends = [ base opentheory opentheory-primitive QuickCheck ];
+       jailbreak = true;
        homepage = "http://opentheory.gilith.com/?pkg=probability";
        description = "Probability";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "opentheory-stream";
-       version = "1.45";
-       sha256 = "0gl7svhyrvi6bznfmc3jfar6hzlrywni6f7pvaykjzkf80xzljbr";
+       version = "1.46";
+       sha256 = "0p27hvxxxl6x6g97llls8kry5vlmpi5b02x9x96v24m4clxj55wa";
        buildDepends = [ base opentheory opentheory-primitive QuickCheck ];
        homepage = "http://opentheory.gilith.com/?pkg=stream";
        description = "Infinite stream types";
···
          base opentheory opentheory-bits opentheory-byte opentheory-parser
          opentheory-primitive opentheory-probability QuickCheck
        ];
+       jailbreak = true;
        homepage = "http://opentheory.gilith.com/?pkg=char";
        description = "Unicode characters";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "pandoc-placetable" = callPackage
-    ({ mkDerivation, base, explicit-exception, pandoc-types
-     , spreadsheet
+    ({ mkDerivation, base, bytestring, explicit-exception, http-conduit
+     , pandoc-types, spreadsheet
      }:
      mkDerivation {
        pname = "pandoc-placetable";
-       version = "0.1.1";
-       sha256 = "196x22f76mvd072yzj6vcynrp459zmlg84l42rwx4syhnvn1ca8d";
+       version = "0.1.2";
+       sha256 = "0vq94j5jsq60p0wbml50hwqa2zpidbzx92cbb7d2ialqj7816zwb";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
-         base explicit-exception pandoc-types spreadsheet
+         base bytestring explicit-exception http-conduit pandoc-types
+         spreadsheet
        ];
        homepage = "https://github.com/mb21/pandoc-placetable";
        description = "Pandoc filter to include CSV files";
···
      }:
      mkDerivation {
        pname = "pgdl";
-       version = "8.2";
-       sha256 = "04yydjvwnjilyxwqwrbwg5c2mph58728bacz2q8pbd0084lp77nd";
+       version = "8.3";
+       revision = "2";
+       sha256 = "0kbx9dgmy9pvcgcpsjplrpnqlk8x3icfpr0flincmzqkzxxzcaq5";
+       editedCabalFile = "9d6e976e130869b6761d870380b867c2501c43a1318a5f385687608c13a0ef72";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
          array base bytestring Cabal configurator directory filepath HTTP
          network-uri process tagsoup text vty vty-ui
        ];
-       description = "simply download a video from webpage and play it";
+       description = "simply download a video (or a file) from a webpage and xdg-open it";
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "pipes";
-       version = "4.1.5";
-       revision = "1";
-       sha256 = "1c19am4dr6na9xpx4h7yngvbml0ghc1dbym8988hjhw84gq4lhfx";
-       editedCabalFile = "c23c260bff1178965d87e6fc9f7263877b5f2adc4c0e4c1bd59c55971fff9eb4";
+       version = "4.1.6";
+       sha256 = "0dbl9sa0ryclyxwm0zfmqvpx7ljmpnfccmnihxia35q471h50sid";
        buildDepends = [ base mmorph mtl transformers ];
        testDepends = [
          base mtl QuickCheck test-framework test-framework-quickcheck2
···
        jailbreak = true;
        homepage = "https://github.com/k0001/pipes-aeson";
        description = "Encode and decode JSON streams using Aeson and Pipes";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "pipes-async" = callPackage
+    ({ mkDerivation, base, hspec, lifted-async, lifted-base
+     , monad-control, pipes, pipes-safe, stm, transformers-base
+     }:
+     mkDerivation {
+       pname = "pipes-async";
+       version = "0.1.1";
+       sha256 = "1b0l3fnblfgwgcbd5brs5iwix4wix1ijx10ppwb8yb1wbqbmh8z2";
+       buildDepends = [
+         base lifted-async lifted-base monad-control pipes pipes-safe stm
+         transformers-base
+       ];
+       testDepends = [
+         base hspec lifted-async lifted-base monad-control pipes pipes-safe
+         stm transformers-base
+       ];
+       homepage = "https://github.com/jwiegley/pipes-async";
+       description = "A higher-level interface to using concurrency with pipes";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }) {};
 
   "pipes-safe" = callPackage
-    ({ mkDerivation, base, containers, exceptions, pipes, transformers
+    ({ mkDerivation, base, containers, exceptions, monad-control, mtl
+     , pipes, transformers, transformers-base
      }:
      mkDerivation {
        pname = "pipes-safe";
-       version = "2.2.2";
-       sha256 = "1sp0fw5w4kcf5llxx2qqzx8n5ps8qw1jx5asqg7al89mqr38am05";
-       buildDepends = [ base containers exceptions pipes transformers ];
+       version = "2.2.3";
+       sha256 = "19wr3q6skwdyd68k1r33w2mipfsgsg2982027faq7rnfw9lq2yyi";
+       buildDepends = [
+         base containers exceptions monad-control mtl pipes transformers
+         transformers-base
+       ];
        description = "Safety for the pipes ecosystem";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, glib, gtk3, hmatrix, mtl, plot, process }:
      mkDerivation {
        pname = "plot-gtk3";
-       version = "0.1";
-       sha256 = "0dw6ypnwr3xnjl1cvr55x3j182vchjhinc9fxsnd5z7ciraqvnv0";
+       version = "0.1.0.1";
+       sha256 = "0x7s9wb8r2sds25q9k6h8mvpfzgi90v497ccxskvb3qd0a1jv24f";
        buildDepends = [ base glib gtk3 hmatrix mtl plot process ];
        homepage = "http://code.haskell.org/plot";
        description = "GTK3 plots and interaction with GHCi";
···
      }:
      mkDerivation {
        pname = "pontarius-xmpp";
-       version = "0.4.2.1";
-       sha256 = "14jhxmccj9ywhxz2rkd4vdwhzz6ciq070ml8vl282hz8k3dr1va9";
+       version = "0.4.2.2";
+       sha256 = "1krbr0vdza3s6w4sa119x591i5ryq9bmqfnacy665xr5si4bkzcv";
        buildDepends = [
          attoparsec base base64-bytestring binary bytestring conduit
          containers crypto-api crypto-random cryptohash cryptohash-cryptoapi
···
      }:
      mkDerivation {
        pname = "posix-paths";
-       version = "0.2.0.5";
-       sha256 = "046y5i4hw4a326r3145yrfd1p6sn3b9xsn6rdk73nv74ks4wrn5v";
+       version = "0.2.1.0";
+       sha256 = "187sq0rcdg06h64kkjdgqg32s8s51hd4cgf6hvajj1pgd9pyd1i0";
        buildDepends = [ base bytestring unix ];
        testDepends = [ base bytestring doctest HUnit QuickCheck unix ];
        description = "POSIX filepath/directory functionality";
···
      }:
      mkDerivation {
        pname = "postgresql-config";
-       version = "0.0.2";
-       sha256 = "1b7rppzarnmndmgwkcahcrcnxzigfldm50iqd81vj0zkii6w0i43";
+       version = "0.1.0";
+       sha256 = "1p5kzj2wsd3kigi9qavsqkxv9kfk4qbl809wqbdk4pd7y34ajab4";
        buildDepends = [
          aeson base bytestring monad-control mtl postgresql-simple
          resource-pool time
···
     ({ mkDerivation, base, bytestring, postgresql }:
      mkDerivation {
        pname = "postgresql-libpq";
-       version = "0.9.0.2";
-       sha256 = "1x1nmzl1j6vc3vy746ch6ps4wy6hwqm78yl9cq9fvkpllh0a2dnw";
+       version = "0.9.1.1";
+       sha256 = "0waqg245ly017j1qml4sc24896ax645bv8a2fghwwa46zvbsx0z4";
        buildDepends = [ base bytestring ];
        extraLibraries = [ postgresql ];
        homepage = "http://github.com/lpsmith/postgresql-libpq";
···
      }:
      mkDerivation {
        pname = "probable";
-       version = "0.1.0.0";
-       sha256 = "1269cajfjnfrqacs874v6zczrb497474hqhid5wmm8f9fmhiy0wz";
+       version = "0.1.1";
+       sha256 = "1n6p7pharcq2cmfabh2ngfsy9mfqqs6qh57m0kygq13lbzwyy8wr";
        buildDepends = [
          base mtl mwc-random primitive statistics transformers vector
        ];
-       jailbreak = true;
        homepage = "http://github.com/alpmestan/probable";
        description = "Easy and reasonably efficient probabilistic programming and random generation";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "propellor";
-       version = "2.6.0";
-       sha256 = "1q9l5bp7sg9lciz8c5qzxmwnfb7b195f8zgdcvzfcx50i3hpxxad";
+       version = "2.7.0";
+       sha256 = "12pfrv6n61bsg4cyylfr0kw82x36mwvnyvzdkr2lrka79i5l9a5w";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "protocol-buffers";
-       version = "2.1.3";
-       sha256 = "1ys0291js4mdfxqjk09lrmf33g7dh4rzq562f471ac98zwc5q588";
+       version = "2.1.4";
+       sha256 = "0sn92mf0dl7w6cg25rhm492sl58pssshjyipadis4w4ww0kyp4md";
        buildDepends = [
          array base binary bytestring containers directory filepath mtl
          parsec syb utf8-string
···
     ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
      mkDerivation {
        pname = "protocol-buffers-descriptor";
-       version = "2.1.3";
-       sha256 = "04iw8bfq9i89xvx2dn16cwv4w9zv3ljgngm6aac6imp7za4mvjzf";
+       version = "2.1.4";
+       sha256 = "1m07l890465ks53acmk9g3fzbm2h5l2pdfhp16hcmvvzxlaz2zvy";
        buildDepends = [ 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";
···
      }) {};
 
   "publicsuffix" = callPackage
-    ({ mkDerivation, base, bytestring, filepath, hspec
-     , template-haskell, text
-     }:
+    ({ mkDerivation, base, filepath, hspec, template-haskell }:
      mkDerivation {
        pname = "publicsuffix";
-       version = "0.20150507";
-       sha256 = "1n1wns0n48rqva5zz4kyj84rw0lf7ih612cp0dhsdk9jgc1kapsj";
-       buildDepends = [ base bytestring filepath template-haskell text ];
-       testDepends = [ base hspec text ];
+       version = "0.20150804";
+       sha256 = "06b311vdwihqhdwf2zr0akndgyaxycli7lymzzyfbn0rhhx1g2kn";
+       buildDepends = [ base filepath template-haskell ];
+       testDepends = [ base hspec ];
        homepage = "https://github.com/wereHamster/publicsuffix-haskell/";
        description = "The publicsuffix list exposed as proper Haskell types";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.7.1.0";
-       sha256 = "1hnrqs1dkcrwa1xrnrikcymm65inxfh9jznfb2xqczd9vyn8j518";
+       version = "0.7.2.0";
+       sha256 = "0drx0n1ac0sjnma7c15hsld1n6rwwl7r8fzcdibk73k5pfyz9a6k";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) { inherit (pkgs) nodejs;};
+
+  "purescript-bundle-fast" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath
+     , optparse-applicative, text, vector
+     }:
+     mkDerivation {
+       pname = "purescript-bundle-fast";
+       version = "0.1.0.1";
+       sha256 = "0s9db4nb5ppr3yznay7jlgydq68hcdn525cwnxkj41h8fv9sflfw";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         base containers directory filepath optparse-applicative text vector
+       ];
+       homepage = "https://github.com/bitc/purescript-bundle-fast";
+       description = "A fast alternative to Purescript's `psc-bundle` to be used during development";
+       license = stdenv.lib.licenses.mit;
+     }) {};
 
   "push-notify" = callPackage
     ({ mkDerivation, aeson, async, attoparsec-conduit, base
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "quiver";
-       version = "0.0.0.6";
-       sha256 = "0g9qfspzamxxn8zvl698g9f8y3alm4js7i7k9wa737pgv47lzqbz";
+       version = "0.0.0.11";
+       sha256 = "1pxnxdm84fqmxvv0l312q8nynpaiyf43jksa2qg1wkl53n0mm2fa";
        buildDepends = [ base ];
        homepage = "https://github.com/zadarnowski/quiver";
        description = "Quiver finite stream processing library";
···
     ({ mkDerivation, base, bytestring, quiver }:
      mkDerivation {
        pname = "quiver-bytestring";
-       version = "0.0.0.1";
-       sha256 = "03lw2yi4a3d5nd7xqlcs4pmf0rcbfw3n4s36wgaxy4wn3bhh3300";
+       version = "0.0.0.2";
+       sha256 = "17wjj1fg60g3km9d4kxfz7lk9bf4sfz0brsg8pb0h2xlw0zvm3wl";
        buildDepends = [ base bytestring quiver ];
        homepage = "https://github.com/zadarnowski/quiver-bytestring";
        description = "Quiver combinators for bytestring streaming";
···
     ({ mkDerivation, base, data-cell, quiver }:
      mkDerivation {
        pname = "quiver-cell";
-       version = "0.0.0.1";
-       sha256 = "1bz74xigj99v9hh4i6m6z4h9f0l09rnbs108npnl953v0bqi44qi";
+       version = "0.0.0.2";
+       sha256 = "10p11ljmwp7szw46saxa972xpjiyr5r19kia6ivaq98jqwcvi5af";
        buildDepends = [ base data-cell quiver ];
        homepage = "https://github.com/zadarnowski/quiver-cell";
        description = "Quiver combinators for cellular data processing";
···
      }:
      mkDerivation {
        pname = "quiver-csv";
-       version = "0.0.0.1";
-       sha256 = "0s5m6qhpir5i1n3ifrcr4if4ysk52cwi9pxm354mdw1859h5lmx9";
+       version = "0.0.0.3";
+       sha256 = "19wb16lbv0wr7w2qba6g2cdmzdhpyyjx1bjvrnz0cqbb4di9yscj";
        buildDepends = [
          base bytestring data-cell quiver quiver-bytestring
        ];
···
        description = "Quiver combinators for cellular CSV data processing";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "quiver-enumerator" = callPackage
+    ({ mkDerivation, base, enumerator, quiver }:
+     mkDerivation {
+       pname = "quiver-enumerator";
+       version = "0.0.0.1";
+       sha256 = "0k0822yzlxkb6b46834hm3bad3x1gma1gqcjl9ryxpqsl73nc4mp";
+       buildDepends = [ base enumerator quiver ];
+       homepage = "https://github.com/zadarnowski/quiver-enumerator";
+       description = "Bridge between Quiver and Iteratee paradigms";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "quoridor-hs" = callPackage
···
      }:
      mkDerivation {
        pname = "react-haskell";
-       version = "2.0.0";
-       sha256 = "016bpbci89b6grkwnq1yqjm5y50di1hmjlf2mkxjc0wyi82c7say";
+       version = "2.0.1";
+       sha256 = "0kjbicrvriliy50gy82b7rsrfk5p3iv20wwnhiaq9i16mbh2zj8j";
        buildDepends = [
          aeson base deepseq lens-family monads-tf text transformers
          unordered-containers void
···
      }:
      mkDerivation {
        pname = "reddit";
-       version = "0.1.0.0";
-       revision = "1";
-       sha256 = "1g18lfl9hvz13f3i5h819pfh724i5lhgqfvyy2r06ni7hjfylzj4";
-       editedCabalFile = "84c6e65809dcd5c4fed83d64c71c6465a6ee1fe6e913c637dc2db608c6cc5870";
+       version = "0.1.1.0";
+       sha256 = "1flsawdld5a4bs5crs352zc1r9ag3yn1indbzw7vgs2mmyiavg7k";
        buildDepends = [
          aeson api-builder base bytestring data-default http-conduit
          http-types network stm text time transformers unordered-containers
···
          api-builder base bytestring Cabal hspec http-conduit text time
          transformers
        ];
+       jailbreak = true;
        homepage = "https://github.com/intolerable/reddit";
        description = "Library for interfacing with Reddit's API";
        license = stdenv.lib.licenses.bsd2;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "refact";
-       version = "0.2.0.0";
-       sha256 = "1ixbji328bxdz4rblb0s7hp6vbckj4yj03a8a8sa756igj988v8f";
+       version = "0.3.0.1";
+       sha256 = "0nmlhx35g3kb5if6qnkmabgi5dj4b446vkd1n5df1vsiyaf65w11";
        buildDepends = [ base ];
        description = "Specify refactorings to perform with apply-refact";
        license = stdenv.lib.licenses.bsd3;
···
 
   "reflex" = callPackage
     ({ mkDerivation, base, containers, dependent-map, dependent-sum
-     , mtl, primitive, ref-tf, semigroups, template-haskell, these
+     , exception-transformers, MemoTrie, mtl, primitive, ref-tf
+     , semigroups, template-haskell, these, transformers
+     , transformers-compat
      }:
      mkDerivation {
        pname = "reflex";
-       version = "0.2";
-       revision = "1";
-       sha256 = "0mq5249dhx26z02jzjr5bxxsgyhg7npd3q7v3l4ipxxxgixg1vdv";
-       editedCabalFile = "4454a0c57f83e4490729fe4b1ce95197be989aa2a0f8b384afddcb1ad71817de";
+       version = "0.3";
+       sha256 = "1aw4pz0y0rpf7klsb232q0zi4zqcpkwrw0s3zrkq5iyhzaswfnyd";
        buildDepends = [
-         base containers dependent-map dependent-sum mtl primitive ref-tf
-         semigroups template-haskell these
+         base containers dependent-map dependent-sum exception-transformers
+         mtl primitive ref-tf semigroups template-haskell these transformers
+         transformers-compat
+       ];
+       testDepends = [
+         base containers dependent-map MemoTrie mtl ref-tf
        ];
        homepage = "https://github.com/ryantrinkle/reflex";
        description = "Higher-order Functional Reactive Programming";
···
      }) {};
 
   "reflex-dom" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, data-default
-     , dependent-map, dependent-sum, ghcjs-dom, glib, gtk3, lens, mtl
-     , ref-tf, reflex, safe, semigroups, text, these, time, transformers
-     , webkitgtk3, webkitgtk3-javascriptcore
+    ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
+     , data-default, dependent-map, dependent-sum
+     , dependent-sum-template, directory, exception-transformers
+     , ghcjs-dom, glib, gtk3, lens, mtl, ref-tf, reflex, safe
+     , semigroups, text, these, time, transformers, webkitgtk3
+     , webkitgtk3-javascriptcore
      }:
      mkDerivation {
        pname = "reflex-dom";
-       version = "0.1.1";
-       sha256 = "1fzk7x0iwgdsb4fmhx399xvq200pz4sh2g1n0n8a76q9sy6j82hs";
+       version = "0.2";
+       sha256 = "1pc6mz9c6nr4s5b2mhlyxjzzffh85cv1bgvyycmq04s6dmg0ndgx";
        buildDepends = [
-         aeson base bytestring containers data-default dependent-map
-         dependent-sum ghcjs-dom glib gtk3 lens mtl ref-tf reflex safe
-         semigroups text these time transformers webkitgtk3
+         aeson base bifunctors bytestring containers data-default
+         dependent-map dependent-sum dependent-sum-template directory
+         exception-transformers ghcjs-dom glib gtk3 lens mtl ref-tf reflex
+         safe semigroups text these time transformers webkitgtk3
          webkitgtk3-javascriptcore
        ];
        jailbreak = true;
-       description = "Glitch-free Functional Reactive Web Apps";
+       description = "Functional Reactive Web Apps with Reflex";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "rei";
-       version = "0.1.0.1";
-       sha256 = "15xq2aj77y7l4frxkariw1z0c3y324iz697im8ynlzm88z2iixs6";
+       version = "0.2.0.0";
+       sha256 = "17ldmx351b54fxmiw3z89v7cs6p33x09k2aav7jphqgv2520phyv";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }) {};
 
   "reroute" = callPackage
-    ({ mkDerivation, base, deepseq, graph-core, hashable, hspec, mtl
-     , path-pieces, regex-compat, text, transformers
+    ({ mkDerivation, base, deepseq, graph-core, hashable, hspec, hvect
+     , mtl, path-pieces, regex-compat, text, transformers
      , unordered-containers, vector
      }:
      mkDerivation {
        pname = "reroute";
-       version = "0.2.3.0";
-       sha256 = "1wyr54kllh3cfwl9i291ymmpmmk8vv8y4i3k1kwa8b0zv5kky1px";
+       version = "0.3.0.2";
+       sha256 = "14xkkcgqbg7bddln849h2k0xrrj9hfvw2ikai81snz7dsf3mcnb8";
        buildDepends = [
-         base deepseq graph-core hashable mtl path-pieces regex-compat text
-         transformers unordered-containers vector
+         base deepseq graph-core hashable hvect mtl path-pieces regex-compat
+         text transformers unordered-containers vector
        ];
-       testDepends = [ base hspec mtl text unordered-containers vector ];
+       testDepends = [
+         base hspec hvect mtl text unordered-containers vector
+       ];
        homepage = "http://github.com/agrafix/reroute";
        description = "abstract implementation of typed and untyped web routing";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "resourcet";
-       version = "1.1.5";
-       sha256 = "063v7xfhwqgf1yvdiidg4anx38nfvgcwb0sqim5rcbqhz0fmkypy";
+       version = "1.1.6";
+       sha256 = "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y";
        buildDepends = [
          base containers exceptions lifted-base mmorph monad-control mtl
          transformers transformers-base transformers-compat
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "roundtrip-aeson" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, lens
+     , lens-aeson, roundtrip, scientific, text, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "roundtrip-aeson";
+       version = "0.2.0.0";
+       sha256 = "0m96447l2m0y4aapil077xpnzlkjla0yp2bzajfijik9gkjbiih4";
+       buildDepends = [
+         aeson base bytestring containers lens lens-aeson roundtrip
+         scientific text unordered-containers vector
+       ];
+       testDepends = [
+         aeson base bytestring lens-aeson roundtrip text vector
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/anchor/roundtrip-aeson";
+       description = "Un-/parse JSON with roundtrip invertible syntax definitions";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "roundtrip-string" = callPackage
     ({ mkDerivation, base, mtl, parsec, roundtrip }:
      mkDerivation {
···
        license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) { inherit (pkgs) rubberband;};
+
+  "ruby-marshal" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, containers, hspec, mtl
+     , string-conv, vector
+     }:
+     mkDerivation {
+       pname = "ruby-marshal";
+       version = "0.1.0";
+       sha256 = "1dmlgks7wfs82k9dxkgi35q4sa0a7ljpcw86j25k85vbclzpyp7j";
+       buildDepends = [
+         base bytestring cereal containers mtl string-conv vector
+       ];
+       testDepends = [
+         base bytestring cereal containers hspec mtl string-conv vector
+       ];
+       homepage = "https://github.com/filib/ruby-marshal";
+       description = "Parse a subset of Ruby objects serialised with Marshal.dump.";
+       license = stdenv.lib.licenses.mit;
+     }) {};
 
   "ruby-qq" = callPackage
     ({ mkDerivation, base, bytestring, haskell-src-exts
···
      }:
      mkDerivation {
        pname = "saltine";
-       version = "0.0.0.3";
-       sha256 = "1xjpjblxlpziyyz74ldaqh04shvy2qi34sc6b3232wpc0kyl5s8y";
+       version = "0.0.0.4";
+       sha256 = "1n74qk8yb0ylj6gns68rak5g030yjsaycn96x0hvk1cx7qwym887";
        buildDepends = [ base bytestring profunctors ];
        testDepends = [
          base bytestring QuickCheck test-framework
          test-framework-quickcheck2 vector
        ];
        extraLibraries = [ libsodium ];
-       jailbreak = true;
        description = "Cryptography that's easy to digest (NaCl/libsodium bindings)";
        license = stdenv.lib.licenses.mit;
      }) { inherit (pkgs) libsodium;};
···
      }:
      mkDerivation {
        pname = "servant";
-       version = "0.4.3.1";
-       sha256 = "1lbnd4mmn7q0bb091il18g1y8ixsi81s64q8lpfpm5sq4dsn1x6l";
+       version = "0.4.4";
+       sha256 = "1v0n194gj2cy16scfgs94q2vcb2baryp0rl1s21zwww1kfgmpffj";
        buildDepends = [
          aeson attoparsec base bytestring bytestring-conversion
          case-insensitive http-media http-types network-uri
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "servant-JuicyPixels" = callPackage
+    ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant
+     , servant-server, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-JuicyPixels";
+       version = "0.1.0.0";
+       sha256 = "1fnlyk6848nzby0nxdrvm4d0vvisdx6pmlzjnh6y1q5q8wq4m48j";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         base bytestring http-media JuicyPixels servant servant-server wai
+         warp
+       ];
+       homepage = "https://github.com/tvh/servant-JuicyPixels";
+       description = "servant-JuicyPixels";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "servant-blaze" = callPackage
     ({ mkDerivation, base, blaze-html, http-media, servant }:
      mkDerivation {
        pname = "servant-blaze";
-       version = "0.4.3.1";
-       sha256 = "017y41z82smy848y6a73232rlidiimdxawb048lnrs9z53ai46cn";
+       version = "0.4.4";
+       sha256 = "140sgy7hcp6pxjrh7zk5i59sq79swqgg76gakgdnvkg7zz0a150s";
        buildDepends = [ base blaze-html http-media servant ];
        homepage = "http://haskell-servant.github.io/";
        description = "Blaze-html support for servant";
···
      }:
      mkDerivation {
        pname = "servant-client";
-       version = "0.4.3.1";
-       sha256 = "15b6aww76bw87zps3n3sv5zl4q1h9l9ds72r9g8kn0r53r3vw6ig";
+       version = "0.4.4";
+       sha256 = "0m5aw8pb6iga2rf8m3mnx58xh6jnh33rvvkdzbmb3s6vplsqh6vz";
        buildDepends = [
          aeson attoparsec base bytestring either exceptions http-client
          http-client-tls http-media http-types network-uri safe servant
···
      }:
      mkDerivation {
        pname = "servant-docs";
-       version = "0.4.3.1";
-       sha256 = "0kzk4089xnr22gw929babknc9rnjq3wp1rk9fq881l49z8pvvl4r";
+       version = "0.4.4";
+       sha256 = "0kp5346jxakjz8x92wvayz7c3f2xcvnpsgg9dxgb41imvww2pyfc";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "servant-examples";
-       version = "0.4.3.1";
-       sha256 = "1ypsdpmp8rx6qcwvbw5scc0y41c1jnpn96wxy6wcik1rkc2zjxfq";
+       version = "0.4.4";
+       sha256 = "1qzrlkqwfv4w7d3sjbvz3s4kgx0x6zn0hh07hm955vvlfksgwjym";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "servant-jquery";
-       version = "0.4.3.1";
-       sha256 = "13ngnbpip7nps3c8i2r9220i9i9kgf5s5w8s0wjkhb25xfbmnwwx";
+       version = "0.4.4";
+       sha256 = "04j2cnxrx2hljxnha94nbmql61zw3apz7n32mf23vf749svjcmvd";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
     ({ mkDerivation, base, http-media, lucid, servant }:
      mkDerivation {
        pname = "servant-lucid";
-       version = "0.4.3.1";
-       sha256 = "1pgvd3khap4gnnpsi2rrp64rz0182xyy9bqglsvg7f7nfmyprgpq";
+       version = "0.4.4";
+       sha256 = "1vy9vdd1jkvx7nzcw6a83az4p351ds98x7wasn496h3bwk23bbhr";
        buildDepends = [ base http-media lucid servant ];
        homepage = "http://haskell-servant.github.io/";
        description = "Servant support for lucid";
···
 
   "servant-pandoc" = callPackage
     ({ mkDerivation, base, bytestring, http-media, lens, pandoc-types
-     , semigroupoids, servant-docs, text, unordered-containers
+     , servant-docs, text, unordered-containers
      }:
      mkDerivation {
        pname = "servant-pandoc";
-       version = "0.4.1";
-       sha256 = "1kfs45z6pja2v4dambivc5cxx8dfr7vrjx38w0cfpmhyi5xz5jdp";
+       version = "0.4.1.1";
+       revision = "1";
+       sha256 = "00clyv651fyz0dx9b4g5c0z5z3bgybgg93x4s1b1lciwsin8i6nk";
+       editedCabalFile = "ee2eff37865c8a5c246021f6d05aae5f075ba5910cac6d650312aafb2f4bf091";
        buildDepends = [
-         base bytestring http-media lens pandoc-types semigroupoids
-         servant-docs text unordered-containers
+         base bytestring http-media lens pandoc-types servant-docs text
+         unordered-containers
        ];
-       jailbreak = true;
        description = "Use Pandoc to render servant API documentation";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "servant-server";
-       version = "0.4.3.1";
-       sha256 = "1qdsv7zr9byjrm7yir8alm1zv0ckb81r6akwdvqfa88a581yz7jx";
+       version = "0.4.4";
+       sha256 = "0byxply71jv558bs33i1j9whrfgfa1iygdjsxap7wiq9f27iyaa9";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          network parsec QuickCheck servant string-conversions temporary text
          transformers wai wai-extra warp
        ];
-       jailbreak = true;
        homepage = "http://haskell-servant.github.io/";
        description = "A family of combinators for defining webservices APIs and serving them";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "set-with" = callPackage
+    ({ mkDerivation, base, containers, invariant, QuickCheck
+     , quickcheck-instances, tasty, tasty-hunit, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "set-with";
+       version = "0.0.1";
+       sha256 = "0mkc44gkhjibq3zhxgiw3c7nfy03jmjmrafdr8x9f5ak4l9ns0h4";
+       buildDepends = [ base containers invariant ];
+       testDepends = [
+         base QuickCheck quickcheck-instances tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "Set of elements sorted by a different data type";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "setdown" = callPackage
     ({ mkDerivation, alex, array, base, bytestring, cmdargs, containers
      , directory, filepath, happy, mtl, split, text, uuid
···
      }:
      mkDerivation {
        pname = "shake";
-       version = "0.15.4";
-       sha256 = "189qyxvy6rxlkgmssy2v66f7anp4q9xjmwqcpwxq86h0pj7vr3i9";
+       version = "0.15.5";
+       sha256 = "18vkyc8h7dpz5d3snfdssfqd1cfp22wnpv63ckrik9p8r4j6i01c";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
     ({ mkDerivation, base, bytestring, css-text, hjsmin, shake, text }:
      mkDerivation {
        pname = "shake-minify";
-       version = "0.1.3";
-       sha256 = "1634dm4rzpp5bkxczj5bbnzcn1mcaxkqbvg08x9gib1nyi2m6zzb";
+       version = "0.1.4";
+       sha256 = "17q0xzjj6xl9h3s6dlxgkxxz2dd4ycbh918ali1lrq2dq9gig3ir";
        buildDepends = [ base bytestring css-text hjsmin shake text ];
        homepage = "https://github.com/LukeHoersten/shake-minify";
        description = "Shake Minify Rules";
···
      }:
      mkDerivation {
        pname = "shelly";
-       version = "1.6.3.1";
-       sha256 = "1yd54i4ac1h23b4l4mz9ixpkhj0zxnb8gamk5jdhzgsd809cqy9q";
+       version = "1.6.3.3";
+       sha256 = "173aypf9dcrkhnaz5gfcpicw9ha6cgs7javds3s7m2qr2vdj8rhs";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
     ({ mkDerivation, base, text }:
      mkDerivation {
        pname = "shortcut-links";
-       version = "0.3.0.0";
-       sha256 = "14g1s2gb1jc52zifn00n1w35qckv7p620rqhpn7rfhymlz6b07rz";
+       version = "0.4.0.0";
+       sha256 = "1i9a5hgzw9w9fqg7vjixc90ck49ag0ikm9bjl2xc30gvjslpy3r8";
        buildDepends = [ base text ];
        homepage = "http://github.com/aelve/shortcut-links";
        description = "Link shortcuts for use in text markup";
···
        isExecutable = true;
        buildDepends = [ base deepseq parallel random ];
        jailbreak = true;
+       homepage = "http://eax.me/haskell-genetic-algorithm/";
+       description = "Simple parallel genetic algorithm implementation";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "simple-genetic-algorithm-mr" = callPackage
+    ({ mkDerivation, base, deepseq, MonadRandom, parallel, random
+     , transformers
+     }:
+     mkDerivation {
+       pname = "simple-genetic-algorithm-mr";
+       version = "0.4.0.0";
+       sha256 = "193n24n5dpmdha85h4vn0kx846hppyzbc9f75wgndc7y7vm1qagy";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         base deepseq MonadRandom parallel random transformers
+       ];
        homepage = "http://eax.me/haskell-genetic-algorithm/";
        description = "Simple parallel genetic algorithm implementation";
        license = stdenv.lib.licenses.bsd3;
···
      }) {};
 
   "simpleirc" = callPackage
-    ({ mkDerivation, base, bytestring, containers, hspec, HUnit, knob
-     , network, old-locale, time
+    ({ mkDerivation, base, bytestring, connection, containers, hspec
+     , HUnit, knob, network, old-locale, time
      }:
      mkDerivation {
        pname = "simpleirc";
-       version = "0.3.0";
-       sha256 = "045rbiz06zpqvkfh4hxsxz7fr338zmr3mgk2xpaqhh8pp2v14h59";
+       version = "0.3.1";
+       sha256 = "1mwhqa5gby38hlbq0shjbff4whhblw00x8wksqbh47jd6i6ihww5";
        buildDepends = [
-         base bytestring containers network old-locale time
+         base bytestring connection containers network old-locale time
        ];
        testDepends = [ base bytestring hspec HUnit knob ];
        homepage = "http://github.com/dom96/SimpleIRC";
···
     ({ mkDerivation, aeson, base, linear, text, vector }:
      mkDerivation {
        pname = "smoothie";
-       version = "0.4.0.1";
-       sha256 = "1h501mcgfwak586gakqsjhmrdkq2mmfi8gwalb7wbsp57bchfg67";
+       version = "0.4.0.2";
+       sha256 = "1g2lk58p8rbhi45j6q3r0w4103bxi6pn9i3c5i3525s8brl4y8ni";
        buildDepends = [ aeson base linear text vector ];
        homepage = "https://github.com/phaazon/smoothie";
        description = "Smooth curves via several interpolation modes";
···
     ({ mkDerivation, aeson, base, blaze-builder, blaze-html, bytestring
      , case-insensitive, configurator, containers, data-default
      , digestive-functors, digestive-functors-heist
-     , digestive-functors-snap, directory-tree, errors, filepath, heist
-     , jmacro, lens, mtl, pcre-light, QuickCheck, readable, safe, snap
+     , digestive-functors-snap, directory-tree, filepath, heist, jmacro
+     , lens, mtl, pcre-light, QuickCheck, readable, safe, snap
      , snap-core, tasty, tasty-hunit, tasty-quickcheck, text, time
      , transformers, wl-pprint-text, xmlhtml
      }:
      mkDerivation {
        pname = "snap-extras";
-       version = "0.11";
-       revision = "1";
-       sha256 = "1s6qdl149x22six61kgm7xnqfyys8z7zh0waajmzip1q4ivxqnij";
-       editedCabalFile = "b0332fedd9b65e483e28c08dc1e76473dc4ab7cee457c69195069aca91d24c46";
+       version = "0.11.0.1";
+       sha256 = "1747qvwbn1rlrjk085rj1780nrsqw4ps78c13si3kkk697k4wcbm";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
          aeson base blaze-builder blaze-html bytestring case-insensitive
          configurator containers data-default digestive-functors
          digestive-functors-heist digestive-functors-snap directory-tree
-         errors filepath heist jmacro lens mtl pcre-light readable safe snap
+         filepath heist jmacro lens mtl pcre-light readable safe snap
          snap-core text time transformers wl-pprint-text xmlhtml
        ];
        testDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "sneathlane-haste" = callPackage
+    ({ mkDerivation, base, haste-compiler }:
+     mkDerivation {
+       pname = "sneathlane-haste";
+       version = "1";
+       sha256 = "0m6281a1hvwbhv02vpdd01vm0jvccvq1kvy26dfncv0a8158y6wj";
+       buildDepends = [ base haste-compiler ];
+       jailbreak = true;
+       homepage = "http://sneathlane.com";
+       description = "A compositional web UI library, which draws to a Canvas element";
+       license = stdenv.lib.licenses.bsd2;
+     }) {};
+
   "snippet-extractor" = callPackage
     ({ mkDerivation, base, parsec }:
      mkDerivation {
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "srcloc";
-       version = "0.5.0.2";
-       sha256 = "0r7fgplyys8335bjrdmcx4m0z0xark0f174lrh2hsmzyii37x6jc";
+       version = "0.5.1.0";
+       sha256 = "1zssd6jxdhzl5wcygbmzq1s82i7m7rav6nm1m6kl5b68g77gc7g6";
        buildDepends = [ base ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "Data types for managing source code locations";
···
        pname = "Phsu";
      mkDerivation {
        pname = "Phsu";
-       version = "1.0.1";
-       pname = "Phsu";
+       version = "1.1.0";
+       sha256 = "0dg2za2p7h9wb9lbs2yb07pdhq9sn4mdxxfmq179d9kinq94009m";
        pname = "Phsu";
        pname = "Phsu";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "Phsu";
-       version = "0.0.3";
-       pname = "Phsu";
+       version = "0.1.0";
+       sha256 = "1qzr5fkffs96clxkvm7lf7kfafijv8fsri6k0j85wrarx3qdgapa";
        buildDepends = [
        pname = "Phsu";
        ];
···
      }:
      mkDerivation {
        pname = "Phsu";
-       version = "0.0.1";
-       pname = "Phsu";
+       version = "0.1.0";
+       sha256 = "0rdk9h7blj7j5kiwy7zq2kb4wxxs19xk3lg73c0srrvbclb0qgbw";
        buildDepends = [
        pname = "Phsu";
        ];
···
      }:
      mkDerivation {
        pname = "Phsu";
-       version = "0.2.0";
-       pname = "Phsu";
+       version = "0.3.0";
+       sha256 = "1ip50w8f26362h1s3kb0qzv15dq264j0vbmqw5v0s40gbwmpv2aj";
        buildDepends = [
        pname = "Phsu";
        ];
···
      mkDerivation {
        pname = "Phsu";
        version = "0.2.4.1";
+       revision = "1";
        pname = "Phsu";
+       editedCabalFile = "e9b8d4599f2eae037bb3b6008284513dbb50af7d3ab42e617b76577bdea656a1";
        buildDepends = [ base deepseq ];
+       jailbreak = true;
        pname = "Phsu";
        pname = "Phsu";
        license = stdenv.lib.licenses.bsd3;
···
 
        pname = "Phsu";
        pname = "Phsu";
-       pname = "Phsu";
-       pname = "Phsu";
+     , bytestring, Cabal, cereal, containers, cryptohash, directory
+     , exceptions, filepath, io-streams, mtl, process, random
+     , regex-compat, temporary, text, time, transformers, unix, zlib
      }:
      mkDerivation {
        pname = "Phsu";
-       version = "0.2.1.0";
-       pname = "Phsu";
+       version = "0.3.5.0";
+       sha256 = "1mkrap2qhfhnisz28vb4hjl5fmfi8r48n1igvv4c0qf9nclhfbhd";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
-       pname = "Phsu";
-       pname = "Phsu";
-         transformers unix
+         array base base16-bytestring byteable bytestring Cabal cereal
+         containers cryptohash directory exceptions filepath io-streams mtl
+         process random regex-compat temporary text time transformers unix
+         zlib
+       ];
+       testDepends = [
+         array base base16-bytestring byteable bytestring Cabal cereal
+         containers cryptohash directory exceptions filepath io-streams mtl
+         process random regex-compat temporary text time transformers unix
+         zlib
        ];
        jailbreak = true;
-       pname = "Phsu";
+       homepage = "https://github.com/ekarayel/sync-mht";
+       description = "Fast incremental file transfer using Merkle-Hash-Trees";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-       pname = "Phsu";
+  "tar_0_4_1_0" = callPackage
        pname = "Phsu";
      mkDerivation {
        pname = "Phsu";
···
      }) {};
 
        pname = "Phsu";
     ({ mkDerivation, array, base, bytestring, directory, filepath
        pname = "Phsu";
      }:
      mkDerivation {
        pname = "Phsu";
-       version = "0.4.2.0";
-       pname = "Phsu";
+       version = "0.4.2.1";
+       sha256 = "102hjlrqfb9d0mvz2bdrj0wg7hvhvzbv4f8gsvxz0wfnq7k0mb9g";
        pname = "Phsu";
        testDepends = [
        pname = "Phsu";
···
      }:
      mkDerivation {
        pname = "text";
-       version = "1.2.1.1";
-       sha256 = "0l4lrpa216dblm1qk0qpykmx56a28h0hjgccq18sn1mr7n3wyhl8";
+       version = "1.2.1.3";
+       sha256 = "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq";
        buildDepends = [
          array base binary bytestring deepseq ghc-prim integer-gmp
        ];
···
 
   "th-context" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, data-default
-     , deepseq, ghc-prim, haskell-src-exts, hspec, hspec-core, mtl, syb
-     , template-haskell, text, th-desugar, th-orphans, th-reify-many
+     , deepseq, ghc-prim, haskell-src-exts, hspec, hspec-core, lens, mtl
+     , mtl-unleashed, syb, template-haskell, text, th-desugar
+     , th-orphans, th-reify-many, th-typegraph
      }:
      mkDerivation {
        pname = "th-context";
-       version = "0.13";
-       sha256 = "0i5392x1x06fk8ld7k6y8kj4hdi3s9gdf2lqj8f6vkwlcnj8cjwh";
+       version = "0.22";
+       sha256 = "0zzrb5dzxcn2dxhqniv3nx4kasgpx7mck730y9hgjink58wqsdx4";
        buildDepends = [
-         base containers data-default haskell-src-exts mtl syb
-         template-haskell th-desugar th-orphans
+         base containers data-default haskell-src-exts lens mtl
+         mtl-unleashed syb template-haskell th-desugar th-orphans
+         th-typegraph
        ];
        testDepends = [
          array base bytestring containers deepseq ghc-prim hspec hspec-core
-         mtl syb template-haskell text th-desugar th-orphans th-reify-many
+         lens mtl mtl-unleashed syb template-haskell text th-desugar
+         th-orphans th-reify-many th-typegraph
        ];
        homepage = "https://github.com/seereason/th-context";
        description = "Test instance context";
···
      }:
      mkDerivation {
        pname = "th-printf";
-       version = "0.3.0.0";
-       sha256 = "10kq1x8klgny6k5aq8h23fnrja3wfmva58j5kpjwzkz0xzr83biq";
+       version = "0.3.1";
+       sha256 = "089grlpavvqv90graa9rdwg9x1ph484g5bj7sfjklqy8mgwwqg7a";
        buildDepends = [
          attoparsec base bytestring template-haskell text transformers
        ];
        testDepends = [
          base bytestring hspec HUnit QuickCheck template-haskell text
        ];
-       jailbreak = true;
        homepage = "https://github.com/joelteon/th-printf";
        description = "Compile-time printf";
        license = stdenv.lib.licenses.mit;
···
   "th-typegraph" = callPackage
     ({ mkDerivation, array, base, base-compat, bytestring, containers
      , data-default, deepseq, ghc-prim, haskell-src-exts, hspec
-     , hspec-core, lens, mtl, set-extra, syb, template-haskell, text
-     , th-desugar, th-orphans, th-reify-many
+     , hspec-core, lens, mtl, mtl-unleashed, set-extra, syb
+     , template-haskell, text, th-desugar, th-orphans, th-reify-many
      }:
      mkDerivation {
        pname = "th-typegraph";
-       version = "0.21";
-       sha256 = "1w4k466snhkcdg30kzzc2vwiz2p46ybks1bbyf3nazc322zxryq0";
+       version = "0.27";
+       sha256 = "1v7vic9kfig9flcnqcpzazd1s4wgqiz3mj9gcyc1ijkrd4y83cdr";
        buildDepends = [
          base base-compat containers data-default haskell-src-exts lens mtl
-         set-extra syb template-haskell th-desugar th-orphans
+         mtl-unleashed set-extra syb template-haskell th-desugar th-orphans
        ];
        testDepends = [
          array base bytestring containers data-default deepseq ghc-prim
-         hspec hspec-core lens mtl syb template-haskell text th-desugar
-         th-orphans th-reify-many
+         hspec hspec-core lens mtl mtl-unleashed syb template-haskell text
+         th-desugar th-orphans th-reify-many
        ];
        homepage = "https://github.com/seereason/th-typegraph";
        description = "Graph of the subtype relation";
···
      }:
      mkDerivation {
        pname = "threepenny-gui";
-       version = "0.6.0.2";
-       sha256 = "0ghcf6p7i39ss63snmk6hn20cw4hyi3agr05rdh7n60fyf9afs4c";
+       version = "0.6.0.3";
+       sha256 = "04qrwvzz705s8aqb8f5vgakh78rv1w64ldv2mvm6fg3llfl5nlfd";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "0.5.2";
-       sha256 = "0ll65q5fi8qfi50q9lqxdq9nsr7gizbh2xrsxgvj09nacdnwfwv0";
+       version = "0.5.3";
+       sha256 = "09bq5ng0wvl1rcaaaw0p2b84f9sddpmabaf9c72ifw3z9k35cfyw";
        buildDepends = [
          base binary bytestring colour containers hashable hmt hosc
          mersenne-random-pure64 mtl parsec process text time transformers
···
      }) {};
 
   "tidal-midi" = callPackage
-    ({ mkDerivation, alsa-core, alsa-seq, base, containers, hashable
-     , hosc, process, tidal
+    ({ mkDerivation, base, bytestring, containers, hashable, hosc
+     , PortMidi, process, tidal, time
      }:
      mkDerivation {
        pname = "tidal-midi";
-       version = "0.0.1";
-       sha256 = "0j2smcjbnsa6ksrgfmcjbm6sjq9ps0l8fqzaib60pgi34b6dnzv8";
+       version = "0.0.2";
+       sha256 = "0q3g4qgzpd8p4z3l1npcs0gy14967l3yn4xqingdbcq22xasim6q";
        buildDepends = [
-         alsa-core alsa-seq base containers hashable hosc process tidal
+         base bytestring containers hashable hosc PortMidi process tidal
+         time
        ];
        homepage = "http://tidal.lurk.org/";
        description = "MIDI support for tidal";
···
     ({ mkDerivation, base, old-locale, time }:
      mkDerivation {
        pname = "timestamper";
-       version = "1.0";
-       sha256 = "14b9zg2lyd8lja9agy73vpscjbkv5nwk6h780wl0xk6m4md9vyj3";
+       version = "1.0.3";
+       sha256 = "1qpzk3047ky0lx5riivv9fa418qhwsa5iyy1fb9l7az6ri094qys";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [ base old-locale time ];
-       jailbreak = true;
        homepage = "https://github.com/kisom/timestamper";
        description = "Read standard input and prepend each line with a timestamp";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "twitter-feed";
-       version = "0.2.0.1";
-       sha256 = "19j10mbvmmdni136b0sdyr0isdhslxcvgabvdqrd3if6cizpmndn";
+       version = "0.2.0.2";
+       sha256 = "19kwhk0bvwnyhychvfzc09w00ix7z9fmvrb4vv56vxdg20rni3fk";
        buildDepends = [
          aeson authenticate-oauth base bytestring http-conduit
        ];
        testDepends = [
          base containers HUnit test-framework test-framework-hunit
        ];
-       jailbreak = true;
        homepage = "https://github.com/stackbuilders/twitter-feed";
        description = "Client for fetching Twitter timeline via Oauth";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, io-streams, unagi-chan }:
      mkDerivation {
        pname = "unagi-streams";
-       version = "0.1.2";
-       sha256 = "0fhs55bap2dkp9lismq4df4sy8878f52xawr4an4cl0v1yj12cq0";
+       version = "0.1.3";
+       sha256 = "0m8x1sw925xwj2yd2ji0nk54gw1gqqz1zy0bk9z3c3sgbcy364m6";
        buildDepends = [ base io-streams unagi-chan ];
-       jailbreak = true;
        description = "Unagi Chan IO-Streams";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }) {};
 
   "unbound-generics" = callPackage
-    ({ mkDerivation, base, containers, contravariant, mtl, profunctors
-     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
+    ({ mkDerivation, base, containers, contravariant, deepseq, mtl
+     , profunctors, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
      , template-haskell, transformers, transformers-compat
      }:
      mkDerivation {
        pname = "unbound-generics";
-       version = "0.1.2.1";
-       sha256 = "0vwqbq3xmacc9fa95wvy2l6r4h831a8g6w1pbxbip2bgqmybsfvk";
+       version = "0.2";
+       sha256 = "0wmr7ylczkaqyf1yrcp9d9gmw8hv7v2yip9v96zlqx02m9j57s99";
        buildDepends = [
-         base containers contravariant mtl profunctors template-haskell
-         transformers transformers-compat
+         base containers contravariant deepseq mtl profunctors
+         template-haskell transformers transformers-compat
        ];
        testDepends = [
          base mtl QuickCheck tasty tasty-hunit tasty-quickcheck
···
      }) {};
 
   "uniform-io" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, data-default-class
-     , iproute, network, openssl, transformers, word8
+    ({ mkDerivation, attoparsec, base, bytestring, Cabal
+     , data-default-class, iproute, network, openssl, transformers
+     , word8
      }:
      mkDerivation {
        pname = "uniform-io";
-       version = "0.1.0.0";
-       sha256 = "1xb934jvj3gk6lw2xdm22p8yayybqk823pk0ssly7kz2dyzrqzz7";
+       version = "0.1.1.0";
+       revision = "1";
+       sha256 = "0i9sdf2nnaf099r79mdrqa1hbbqyb874fk8dsqqzb1582m6czikk";
+       editedCabalFile = "4f0651eff7cbdde40b49b5fcf90e8adf5c403a7c150ac318f0f5280b454b19f9";
        buildDepends = [
          attoparsec base bytestring data-default-class iproute network
          transformers word8
        ];
+       testDepends = [ base Cabal ];
        extraLibraries = [ openssl ];
        homepage = "https://sealgram.com/git/haskell/uniform-io";
        description = "Uniform IO over files, network, watever";
···
   "uuid" = callPackage
     ({ mkDerivation, base, binary, bytestring, cryptohash, HUnit
      , network-info, QuickCheck, random, tasty, tasty-hunit
-     , tasty-quickcheck, time, uuid-types
+     , tasty-quickcheck, text, time, uuid-types
      }:
      mkDerivation {
        pname = "uuid";
-       version = "1.3.10";
-       sha256 = "0csq2y8rzdy8cnag4piqvxa742jasxqcq07qgrp4kmdkbnbqvyvy";
+       version = "1.3.11";
+       sha256 = "1m8lk12ls4c5xx1y3wm2n2spm2c5slwb27k6zrdibja8z397c637";
        buildDepends = [
-         base binary bytestring cryptohash network-info random time
+         base binary bytestring cryptohash network-info random text time
          uuid-types
        ];
        testDepends = [
···
 
   "uuid-types" = callPackage
     ({ mkDerivation, base, binary, bytestring, deepseq, hashable, HUnit
-     , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck
+     , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck, text
      }:
      mkDerivation {
        pname = "uuid-types";
-       version = "1.0.1";
-       sha256 = "1brws1nq3pmd3sq786kig2raaxdcx2s8anwsn9f1jj92i5r7y7jb";
-       buildDepends = [ base binary bytestring deepseq hashable random ];
+       version = "1.0.2";
+       sha256 = "019f9w1jvqacbxmq828wsn6zpwp5yw7bkhyj34a4cc2zq3bfkijn";
+       buildDepends = [
+         base binary bytestring deepseq hashable random text
+       ];
        testDepends = [
          base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "varying" = callPackage
+    ({ mkDerivation, base, time }:
+     mkDerivation {
+       pname = "varying";
+       version = "0.1.0.3";
+       sha256 = "1y7mf2q1lawx3f8hdd9b70fa3hrmabm9lmi2rhxvr1dq5r5yh5q7";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [ base time ];
+       homepage = "https://github.com/schell/varying";
+       description = "Automaton based varying values, event streams and tweening";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "vault" = callPackage
     ({ mkDerivation, base, containers, hashable, unordered-containers
      }:
···
      }) {};
 
   "vcsgui" = callPackage
-    ({ mkDerivation, base, directory, filepath, gtk3, mtl, process
-     , text, vcswrapper
+    ({ mkDerivation, base, directory, filepath, gtk, mtl, process, text
+     , vcswrapper
      }:
      mkDerivation {
        pname = "vcsgui";
···
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
-         base directory filepath gtk3 mtl process text vcswrapper
+         base directory filepath gtk mtl process text vcswrapper
        ];
        homepage = "https://github.com/forste/haskellVCSGUI";
        description = "GUI library for source code management systems";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "verbosity" = callPackage
+    ({ mkDerivation, base, binary, data-default-class, deepseq }:
+     mkDerivation {
+       pname = "verbosity";
+       version = "0.2.0.0";
+       sha256 = "0vwv4f5ni6dzvj3jbgxcy8b2hmal6c8xbdin16pifqrn55d52pa9";
+       buildDepends = [ base binary data-default-class deepseq ];
+       homepage = "https://github.com/trskop/verbosity";
+       description = "Simple enum that encodes application verbosity";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "verilog" = callPackage
     ({ mkDerivation, alex, array, base, happy }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "vimeta";
-       version = "0.2.0.0";
-       sha256 = "14xzqhykw963ja6wsnrbq8dh9wbk63aramzj4n210srwxy6yqc05";
+       version = "0.2.1.0";
+       sha256 = "0sc5mlv4d9srgv6rj43ddn27rindpyrz2mwz2i5rmm8y4ixn7jrq";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
        buildDepends = [ base glib gtk3 pango ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ vte ];
+       jailbreak = true;
        homepage = "http://projects.haskell.org/gtk2hs/";
        description = "Binding to the VTE library";
        license = stdenv.lib.licenses.lgpl21;
···
      }:
      mkDerivation {
        pname = "vty";
-       version = "5.2.9";
-       sha256 = "013bha8b30q7ax2qyv315hmdxhzfqgc2bw2wyz1q53qw0mxyhbjr";
+       version = "5.2.10";
+       sha256 = "0wl4qfag8hkhsbm66cgxs55nq3fgmxdxzcvjvcbcm42pcyikvx9y";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
      }:
      mkDerivation {
        pname = "wai-extra";
-       version = "3.0.9";
-       sha256 = "19rnkqg4x6n2w2313naxbkcp2hyj4bj6d6kx3rwakk8wmdy70r04";
+       version = "3.0.10";
+       sha256 = "0dqvfwqzkr3g030s24lzy9l9vaws27m0cs0aq771p7f22w9g6fjh";
        buildDepends = [
          ansi-terminal base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie data-default-class deepseq
···
 
   "wai-routes" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
-     , http-types, mtl, path-pieces, random, template-haskell, text, wai
+     , http-types, monad-loops, mtl, path-pieces, random
+     , template-haskell, text, wai
      }:
      mkDerivation {
        pname = "wai-routes";
-       version = "0.7.1";
-       sha256 = "053bgiw2abwjlc6ap9ka4kdg410gxxmyqdfzsxiva94sp3w816xx";
+       version = "0.7.2";
+       sha256 = "05f8524q9rb5y4d8fryhv4jjkcgqygbckg4pkklvs86s5zlg9nsa";
        buildDepends = [
-         aeson base blaze-builder bytestring containers http-types mtl
-         path-pieces random template-haskell text wai
+         aeson base blaze-builder bytestring containers http-types
+         monad-loops mtl path-pieces random template-haskell text wai
        ];
-       homepage = "https://github.com/ajnsit/wai-routes";
+       homepage = "https://ajnsit.github.io/wai-routes/";
        description = "Typesafe URLs for Wai applications";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.1.0";
-       sha256 = "1lx1fbcf8bkr5g6j0flk6mplnvs289lkyds5hv31naa450wbca62";
+       version = "3.1.2";
+       sha256 = "1ya8mfvb18p9d5bj0ijnlbd7m04mj7f1z9ld82a8vry37sdifidq";
        buildDepends = [
          array auto-update base blaze-builder bytestring case-insensitive
          containers ghc-prim hashable http-date http-types http2 iproute
···
      mkDerivation {
        pname = "webcrank-dispatch";
        version = "0.1";
+       revision = "1";
        sha256 = "1w4kfcm2d6iw4d45ywg2g6iysxl2iywk3nbk5ac6p6500y6hh97k";
+       editedCabalFile = "50b6b56e1fccc20a2986ea93b04410b8131ea5f2f4df94df538c6b2369400fa8";
        buildDepends = [
          base bytestring mtl path-pieces reroute text unordered-containers
        ];
+       jailbreak = true;
        homepage = "https://github.com/webcrank/webcrank-dispatch.hs";
        description = "A simple request dispatcher";
        license = stdenv.lib.licenses.bsd3;
···
        buildDepends = [ base bytestring cairo glib gtk3 mtl pango text ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ webkit ];
+       jailbreak = true;
        homepage = "http://projects.haskell.org/gtk2hs/";
        description = "Binding to the Webkit library";
        license = stdenv.lib.licenses.lgpl21;
···
        buildDepends = [ base glib gtk3 webkitgtk3 ];
        buildTools = [ gtk2hs-buildtools ];
        pkgconfigDepends = [ webkit ];
+       jailbreak = true;
        description = "JavaScriptCore FFI from webkitgtk";
        license = stdenv.lib.licenses.bsd3;
      }) { inherit (pkgs) webkit;};
···
      }:
      mkDerivation {
        pname = "xhb";
-       version = "0.5.2014.4.10";
-       sha256 = "1r5z92p98jn8pdcqmdiv0hriq7y8743q4sxfjfds602rr4qf97gz";
+       version = "0.6.2015.8.1";
+       sha256 = "1rq6g96v1fs66kdmnkvlkcxrv614ha77czclm3sfw274f7q2r2kb";
        buildDepends = [
          base binary byteorder bytestring containers network parsec stm
          Xauth
···
      }:
      mkDerivation {
        pname = "xlsx";
-       version = "0.1.0.4";
-       sha256 = "1zri5wan5h3nyizfrfmnw9mz2cwapi4wrc3srxqns5w12v866p3a";
+       version = "0.1.0.5";
+       sha256 = "0zd3p0dkb4v9gcd3mvp6g64z1gr1m5x0pf2zyj3w7ab0dgz4gzsz";
        isLibrary = true;
        isExecutable = true;
        buildDepends = [
···
          base containers HUnit old-time smallcheck tasty tasty-hunit
          tasty-smallcheck time
        ];
-       jailbreak = true;
        homepage = "https://github.com/qrilka/xlsx";
        description = "Simple and incomplete Excel file parser/writer";
        license = stdenv.lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "xss-sanitize";
-       version = "0.3.5.5";
-       sha256 = "05qmhd50bdy5z0nvqvrm25ax4i642gv6gkdn678flg6sckshr4s2";
+       version = "0.3.5.6";
+       sha256 = "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0";
        buildDepends = [
          attoparsec base containers css-text network-uri tagsoup text
          utf8-string
···
      }:
      mkDerivation {
        pname = "yesod-bin";
-       version = "1.4.13";
-       sha256 = "0rqwmvl2pl05fp7xyfcpmpjkki8ww47rhifcclasaxvj109hvj1k";
+       version = "1.4.13.1";
+       sha256 = "1vnqiibdjvkja80b8i352afrhphx8v6nihylgxaywch20b2fbkrc";
        isLibrary = false;
        isExecutable = true;
        buildDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-bootstrap" = callPackage
+    ({ mkDerivation, base, blaze-html, blaze-markup, conduit
+     , conduit-extra, containers, either, email-validate
+     , lens-family-core, lens-family-th, MonadRandom, mtl, persistent
+     , shakespeare, text, time, transformers, yesod-core, yesod-form
+     , yesod-markdown
+     }:
+     mkDerivation {
+       pname = "yesod-bootstrap";
+       version = "0.1.0.0";
+       sha256 = "19hzc1k0ssmsi9k4r5bxmngr1h8a42qhaxcl5y99fbf6khpndxzg";
+       buildDepends = [
+         base blaze-html blaze-markup conduit conduit-extra containers
+         either email-validate lens-family-core lens-family-th MonadRandom
+         mtl persistent shakespeare text time transformers yesod-core
+         yesod-form yesod-markdown
+       ];
+       description = "Bootstrap widgets for yesod";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "yesod-comments" = callPackage
     ({ mkDerivation, base, bytestring, directory, friendly-time
      , gravatar, old-locale, persistent, template-haskell, text, time
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "yesod-lucid" = callPackage
+    ({ mkDerivation, base, lucid, monads-tf, text, yesod-core }:
+     mkDerivation {
+       pname = "yesod-lucid";
+       version = "0.1";
+       sha256 = "1ymmpi9g3pjl23ymdjwiv748lnq1hyjq24la2ffgwrm4b6f41xip";
+       buildDepends = [ base lucid monads-tf text yesod-core ];
+       description = "Lucid support for Yesod";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "yesod-mangopay" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
      , containers, country-codes, data-default, directory, fast-logger
···
 
   "yesod-markdown" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
-     , directory, pandoc, persistent, shakespeare, texmath, text
+     , directory, hspec, pandoc, persistent, shakespeare, texmath, text
      , xss-sanitize, yesod-core, yesod-form
      }:
      mkDerivation {
        pname = "yesod-markdown";
-       version = "0.9.4";
-       sha256 = "1mam4ibbnzvi1ljlj8kzz24s8jxk3f3xvvicmcygklz0n9pmaw66";
+       version = "0.10.0";
+       sha256 = "0n9rcpf8s89swj0pz86xddl5zjbkkw1fa1h292wvs15y77lrl0zi";
        buildDepends = [
          base blaze-html blaze-markup bytestring directory pandoc persistent
          shakespeare texmath text xss-sanitize yesod-core yesod-form
        ];
-       jailbreak = true;
+       testDepends = [ base blaze-html hspec text ];
        homepage = "http://github.com/pbrisbin/yesod-markdown";
        description = "Tools for using markdown in a yesod application";
        license = stdenv.lib.licenses.gpl2;
···
      }:
      mkDerivation {
        pname = "yesod-table";
-       version = "1.0.2";
-       sha256 = "0rrc9cfjl1g8if0ncs2xzpb1hnaa4hi3w62q16gwir0l79vfj7b9";
+       version = "1.0.3";
+       sha256 = "02w7ddyi0zzcvhlj1b01p3zjii2g7bn2f7wcgrdidk8dlg9hrgj5";
        buildDepends = [ base containers contravariant text yesod-core ];
        homepage = "https://github.com/andrewthad/yesod-table";
        description = "HTML tables for Yesod";

pkgs/development/libraries/libcouchbase/default.nix

···
-{ stdenv, fetchgit, autoconf, automake, libtool,
-pkgconfig, perl, git, libevent, openssl}:
+{ stdenv, fetchurl, cmake, pkgconfig, libevent, openssl}:
 
 stdenv.mkDerivation {
-  name = "libcouchbase-2.4.4";
-  src = fetchgit {
-    url = "https://github.com/couchbase/libcouchbase.git";
-    rev = "4410eebcd813844b6cd6f9c7eeb4ab3dfa2ab8ac";
-    sha256 = "02lzv5l6fvnqr2l9bqfha0pzkzlzjfddn3w5zcbjz36kw4p2p4h9";
-    leaveDotGit = true;
+  name = "libcouchbase-2.5.2";
+  src = fetchurl {
+    url = "https://github.com/couchbase/libcouchbase/archive/2.5.2.tar.gz";
+    sha256 = "0ka1hix38a2kdhxz6n8frssyznf78ra0irga9d8lr5683y73xw24";
   };
 
-  preConfigure = ''
-    patchShebangs ./config/
-    ./config/autorun.sh
-  '';
+  cmakeFlags = "-DLCB_NO_MOCK=ON";
 
-  configureFlags = "--disable-couchbasemock";
-
-  buildInputs = [ autoconf automake libtool pkgconfig perl git libevent openssl];
+  nativeBuildInputs = [ cmake pkgconfig ];
+  buildInputs = [ libevent openssl];
 
   meta = {
     description = "C client library for Couchbase";

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

···
     six
   ];
 
-  # Tests are in <nixos/tests/blivet.nix>.
+  # Tests are in <nixpkgs/nixos/tests/blivet.nix>.
   doCheck = false;
 
   meta = with stdenv.lib; {

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

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "6.8.1";
+  version = "6.8.2";
   name = "checkstyle-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/checkstyle/${name}-bin.tar.gz";
-    sha256 = "12da8msz5459ra0g5smr8daqh88mfa653nn475acjp1ycsm395hv";
+    sha256 = "1r0wb8iqvmhvgxk1ya39x8b4ayd549bfxmnw26i84870hnqr179c";
   };
 
   installPhase = ''

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

···
 { stdenv, fetchurl, makeWrapper, jdk }:
 
 stdenv.mkDerivation rec {
-  version = "2.0.0";
+  version = "2.2.0";
   name = "boot-${version}";
 
   src = fetchurl {
     url = "https://github.com/boot-clj/boot/releases/download/${version}/boot.sh";
-    sha256 = "0hvznr0z5ck32wpaqhjv2fr9365b8h0h8brnsmwijpv699l0rf1c";
+    sha256 = "0czavpdhmpgp20vywf326ix1f94dky51mqiwyblrmrd33d89qz9f";
   };
 
   inherit jdk;

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

···
 
 stdenv.mkDerivation rec {
   name = "fswatch-${version}";
-  version = "1.4.7";
+  version = "1.5.0";
 
   src = fetchFromGitHub {
     owner = "emcrisostomo";
     repo = "fswatch";
     rev = version;
-    sha256 = "0f6aa14v31gy3j7qx563ml37r8mylpbqfjrz2v5g44zrrg6086w7";
+    sha256 = "09np75m9df2nk7lc5y9wgq467ca6jsd2p5666d5rkzjvy6s0a51n";
   };
 
   buildInputs = [ autoreconfHook gettext libtool makeWrapper texinfo ];

pkgs/development/tools/phantomjs2/default.nix

···
+{ stdenv, fetchurl,
+  bison2, flex, fontconfig, freetype, gperf, icu, openssl, libjpeg, libpng, perl, python, ruby, sqlite
+}:
+
+stdenv.mkDerivation rec {
+  name = "phantomjs-${version}";
+  version = "2.0.0-20150528";
+
+  src = fetchurl {
+    url = "https://github.com/bprodoehl/phantomjs/archive/v2.0.0-20150528.tar.gz";
+    sha256 = "18h37bxxg25lacry9k3vb5yim057bqcxmsifw97jrjp7gzfx56v5";
+  };
+
+  buildInputs = [ bison2 flex fontconfig freetype gperf icu openssl libjpeg libpng perl python ruby sqlite ];
+
+  patchPhase = ''
+    patchShebangs .
+    sed -i -e 's|/bin/pwd|pwd|' src/qt/qtbase/configure 
+  '';
+
+  buildPhase = "./build.sh --confirm";
+
+  installPhase = ''
+    mkdir -p $out/share/doc/phantomjs
+    cp -a bin $out
+    cp -a ChangeLog examples LICENSE.BSD README.md third-party.txt $out/share/doc/phantomjs
+  '';
+
+  meta = {
+    description = "Headless WebKit with JavaScript API";
+    longDescription = ''
+      PhantomJS2 is a headless WebKit with JavaScript API.
+      It has fast and native support for various web standards:
+      DOM handling, CSS selector, JSON, Canvas, and SVG.
+
+      PhantomJS is an optimal solution for:
+      - Headless Website Testing
+      - Screen Capture
+      - Page Automation
+      - Network Monitoring
+    '';
+
+    homepage = http://phantomjs.org/;
+    license = stdenv.lib.licenses.bsd3;
+
+    maintainers = [ stdenv.lib.maintainers.aflatter ];
+    platforms = with stdenv.lib.platforms; darwin ++ linux;
+  };
+}

pkgs/development/web/iojs/default.nix

···
 { stdenv, fetchurl, python, utillinux, openssl_1_0_2, http-parser, zlib, libuv }:
 
 let
-  version = "2.5.0";
+  version = "3.0.0";
   inherit (stdenv.lib) optional maintainers licenses platforms;
 in stdenv.mkDerivation {
   name = "iojs-${version}";
 
   src = fetchurl {
     url = "https://iojs.org/dist/v${version}/iojs-v${version}.tar.gz";
-    sha256 = "0jj0xqwpq7s45bycs406ml12xyknxgad4vyw9k84al3551m5y2wd";
+    sha256 = "0maxxmr6y7z3y3r88nhcnfzmpvbhs5p8knyz886bh2shgzd6nzqf";
   };
 
   prePatch = ''

pkgs/servers/http/yaws/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "yaws-${version}";
-  version = "1.99";
+  version = "2.0";
 
   src = fetchurl {
     url = "http://yaws.hyber.org/download/${name}.tar.gz";
-    sha256 = "057ymg84ji4pfi3xai6kis3mk8zks2ynbiam0x68cb4cb1yfzwcl";
+    sha256 = "1gwk44a07n7yvg900yrlfc6qpvjl64k2h2hddd1jaaay8lgpcch6";
   };
 
   # The tarball includes a symlink yaws -> yaws-1.95, which seems to be

pkgs/shells/ipython/default.nix

···
 assert pylabQtSupport == true -> pyqt4 != null;
 
 buildPythonPackage rec {
-  name = "ipython-3.1.0";
+  name = "ipython-${version}";
+  version = "3.2.1";
   namePrefix = "";
 
   src = fetchurl {
     url = "https://pypi.python.org/packages/source/i/ipython/${name}.tar.gz";
-    sha256 = "092nilrkr76l1mklnslgbw1cz7z1xabp1hz5s7cb30kgy39r482k";
+    sha256 = "c913adee7ae5b338055274c51a7d2b3cea468b5b316046fa520cd8a434b09177";
   };
 
   propagatedBuildInputs = [

pkgs/tools/filesystems/ceph/0.94-pre.nix

···
+{ callPackage, fetchgit, ... } @ args:
+
+callPackage ./generic.nix (args // rec {
+  version = "0.94.3";
+
+  src = fetchgit {
+    url = "https://github.com/ceph/ceph.git";
+    rev = "c19b0fc1aa2834ae3027b07a02aebe9639fc2ca7";
+    sha256 = "1h1y5jh2bszia622rmwdblb3cpkpd0mijahkaiasr30jwpkmzh0i";
+  };
+
+  patches = [ ./fix-pgrefdebugging.patch ];
+})

pkgs/tools/misc/gparted/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gparted-0.22.0";
+  name = "gparted-0.23.0";
 
   src = fetchurl {
-    sha256 = "09vg5lxvh81x54ps5ayfjd4jl84wprn42i1wifnfmj44dqd5wxda";
+    sha256 = "0m57bni3nkbbqq920ydzvasy2qc5j6w6bdssyn12jk4157gxvlbz";
     url = "mirror://sourceforge/gparted/${name}.tar.bz2";
   };
 
···
       partitions. GParted enables you to change the partition organization
       while preserving the partition contents.
     '';
-    homepage = http://gparted.sourceforge.net;
+    homepage = http://gparted.org;
     license = licenses.gpl2Plus;
-    platforms = with platforms; linux;
+    platforms = platforms.linux;
     maintainers = with maintainers; [ nckx ];
   };
 }

pkgs/tools/misc/screenfetch/default.nix

···
 { stdenv, fetchgit, makeWrapper
-, coreutils, gawk, procps, gnused, findutils, xdpyinfo, xprop
+, coreutils, gawk, procps, gnused, findutils, xdpyinfo, xprop, gnugrep
 }:
 
 stdenv.mkDerivation {
···
       --prefix PATH : "${findutils}/bin" \
       --prefix PATH : "${xdpyinfo}/bin" \
       --prefix PATH : "${xprop}/bin" \
+      --prefix PATH : "${gnugrep}/bin"
   '';
 
   meta = {

pkgs/tools/networking/netsniff-ng/default.nix

···
 , libnetfilter_conntrack, libnl, libpcap, libsodium, liburcu, ncurses, perl
 , pkgconfig, zlib }:
 
-let version = "0.5.9-34-g95c4582"; in
+let version = "0.5.9-71-g77445f8"; in
 stdenv.mkDerivation {
   name = "netsniff-ng-${version}";
 
···
   src = fetchFromGitHub rec {
     repo = "netsniff-ng";
     owner = repo;
-    rev = "95c4582b742fd4fa58e5f14971164b941b0f730d";
-    sha256 = "0anai392n8zx8vcjbjg776lbiwrv95x2dbd8rypbqfzmj8nhzric";
+    rev = "77445f81d451eef6b78b79a2bcc24d21d4be4178";
+    sha256 = "0ny9bph070mny6i9r0i3wsx2bsl53135n439ab6r9qk710xjz91j";
   };
 
   buildInputs = [ bison flex geoip geolite-legacy libcli libnet libnl

pkgs/tools/networking/strongswan/default.nix

···
 { stdenv, fetchurl, gmp, pkgconfig, python, autoreconfHook
-, curl, trousers, sqlite
+, curl, trousers, sqlite, iptables, libxml2, openresolv
 , enableTNC ? false }:
 
 stdenv.mkDerivation rec {
···
   dontPatchELF = true;
 
   buildInputs =
-    [ gmp pkgconfig python autoreconfHook ]
-    ++ stdenv.lib.optionals enableTNC [ curl trousers sqlite ];
+    [ gmp pkgconfig python autoreconfHook iptables ]
+    ++ stdenv.lib.optionals enableTNC [ curl trousers sqlite libxml2 ];
 
   patches = [
     ./ext_auth-path.patch
···
     ./updown-path.patch
   ];
 
+  postPatch = ''
+    substituteInPlace src/libcharon/plugins/resolve/resolve_handler.c --replace "/sbin/resolvconf" "${openresolv}/sbin/resolvconf"
+    '';
+
   configureFlags =
-    [ "--enable-swanctl" "--enable-cmd" ]
+    [ "--enable-swanctl" "--enable-cmd"
+      "--enable-farp" "--enable-dhcp"
+      "--enable-eap-sim" "--enable-eap-sim-file" "--enable-eap-simaka-pseudonym"
+      "--enable-eap-simaka-reauth" "--enable-eap-identity" "--enable-eap-md5"
+      "--enable-eap-gtc" "--enable-eap-aka" "--enable-eap-aka-3gpp2"
+      "--enable-eap-mschapv2" "--enable-xauth-eap" "--enable-ext-auth"
+      "--enable-forecast" "--enable-connmark" "--enable-acert"
+      "--enable-aesni" "--enable-af-alg" "--enable-rdrand" ]
+    ++ stdenv.lib.optional (stdenv.system == "i686-linux") "--enable-padlock" 
     ++ stdenv.lib.optionals enableTNC [
          "--disable-gmp" "--disable-aes" "--disable-md5" "--disable-sha1" "--disable-sha2" "--disable-fips-prf"
-         "--enable-curl" "--enable-openssl" "--enable-eap-identity" "--enable-eap-md5" "--enable-eap-mschapv2"
+         "--enable-curl" "--enable-openssl"
          "--enable-eap-tnc" "--enable-eap-ttls" "--enable-eap-dynamic" "--enable-tnccs-20"
          "--enable-tnc-imc" "--enable-imc-os" "--enable-imc-attestation"
          "--enable-tnc-imv" "--enable-imv-attestation"
+         "--enable-tnc-ifmap" "--enable-tnc-imc" "--enable-tnc-imv"
          "--with-tss=trousers"
          "--enable-aikgen"
          "--enable-sqlite" ];

pkgs/tools/networking/vpnc/default.nix

···
-{ stdenv, fetchurl, nettools, libgcrypt, perl, gawk, makeWrapper }:
+{ stdenv, fetchsvn, nettools, libgcrypt, openssl, openresolv, perl, gawk, makeWrapper }:
 
 stdenv.mkDerivation rec {
-  name = "vpnc-0.5.3";
-  src = fetchurl {
-    url = "http://www.unix-ag.uni-kl.de/~massar/vpnc/${name}.tar.gz";
-    sha256 = "1128860lis89g1s21hqxvap2nq426c9j4bvgghncc1zj0ays7kj6";
+  name = "vpnc-rev550";
+  src = fetchsvn {
+    url = "http://svn.unix-ag.uni-kl.de/vpnc";
+    rev = "550";
+    sha256 = "0x4ckfv9lpykwmh28v1kyzz91y1j2v48fi8q5nsawrba4q0wlrls";
   };
 
-  patches = [ ./makefile.patch ./vpnc-script.patch ];
+  postUnpack = ''
+    mv $sourceRoot/trunk/* $sourceRoot/.
+    rm -r $sourceRoot/{trunk,branches,tags}
+  '';
+
+  patches = [ ./makefile.patch ];
 
   # The `etc/vpnc/vpnc-script' script relies on `which' and on
   # `ifconfig' as found in net-tools (not GNU Inetutils).
   propagatedBuildInputs = [ nettools ];
 
-  buildInputs = [libgcrypt perl makeWrapper];
+  buildInputs = [libgcrypt perl makeWrapper openssl ];
 
   preConfigure = ''
-    substituteInPlace "vpnc-script.in" \
+    sed -i 's|^#OPENSSL|OPENSSL|g' Makefile
+
+    substituteInPlace "vpnc-script" \
       --replace "which" "type -P" \
-      --replace "awk" "${gawk}/bin/awk"
+      --replace "awk" "${gawk}/bin/awk" \
+      --replace "/sbin/resolvconf" "${openresolv}/bin/resolvconf"
 
     substituteInPlace "config.c" \
       --replace "/etc/vpnc/vpnc-script" "$out/etc/vpnc/vpnc-script"

pkgs/tools/networking/vpnc/vpnc-script.patch

···
-diff -ubr vpnc-0.5.3-orig/vpnc-script.in vpnc-0.5.3/vpnc-script.in
---- vpnc-0.5.3-orig/vpnc-script.in	2012-02-29 23:03:35.289636602 +0100
-+++ vpnc-0.5.3/vpnc-script.in	2012-02-29 23:03:59.597307445 +0100
-@@ -116,7 +116,7 @@
- 
- if [ -n "$IPROUTE" ]; then
- 	fix_ip_get_output () {
--		sed 's/cache//;s/metric \?[0-9]\+ [0-9]\+//g;s/hoplimit [0-9]\+//g'
-+		sed 's/cache//;s/metric \?[0-9]\+ [0-9]\+//g;s/hoplimit [0-9]\+//g;s/ipid 0x....//g'
- 	}
- 
- 	set_vpngateway_route() {

pkgs/tools/package-management/nixops/unstable.nix

···
 in
 
 pythonPackages.buildPythonPackage rec {
-  name = "nixops-1.3pre1486_7489764";
+  name = "nixops-1.3pre-cefcd9ba";
   namePrefix = "";
 
   src = fetchgit {
     url = https://github.com/NixOS/nixops;
-    rev = "5c7663dfe1e2af9c0396c5c86d995452ef2efc8a";
-    sha256 = "01n2ykszrnqr3kqqdg1n2l8wm38yhri7r3d7b0abklsslz9dlvmy";
+    rev = "cefcd9bae9a4d3bac83f188460619d18972321a8";
+    sha256 = "1jwkbnfwics2j0m6mr75rz914vg0z46d2xv0z1717c1ac5rki0l2";
   };
 
   buildInputs = [ /* libxslt */ pythonPackages.nose pythonPackages.coverage ];

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

···
 , profilePaths ? (config.nixui.profilePaths or ["/nix/var/nix/profiles"])
 , dataDir ? (config.nixui.dataDir or "/tmp")
 , configurations ? (config.nixui.configurations or ["/etc/nixos/configuration.nix"])
-, NIX_PATH ? (config.nixui.NIX_PATH or "/nix/var/nix/profiles/per-user/root/channels/nixos:nixpkgs=/etc/nixos/nixpkgs:nixos-config=/etc/nixos/configuration.nix") }:
+, NIX_PATH ? (config.nixui.NIX_PATH or "/nix/var/nix/profiles/per-user/root/channels/nixos:nixos-config=/etc/nixos/configuration.nix") }:
 let
   version = "0.1.2";
   src = fetchgit {

pkgs/top-level/all-packages.nix

···
   libceph = ceph.lib;
   ceph-0_80 = callPackage ../tools/filesystems/ceph/0.80.nix { };
   ceph-0_94 = callPackage ../tools/filesystems/ceph/0.94.nix { };
+  ceph-0_94-pre = callPackage ../tools/filesystems/ceph/0.94-pre.nix { };
   ceph = callPackage ../tools/filesystems/ceph { };
   ceph-dev = lowPrio (callPackage ../tools/filesystems/ceph/dev.nix { });
   ceph-git = lowPrio (callPackage ../tools/filesystems/ceph/git.nix { });
···
 
   haskell = callPackage ./haskell-packages.nix { };
 
-  haskellPackages = haskell.packages.ghc7101.override {
+  haskellPackages = haskell.packages.ghc7102.override {
     overrides = config.haskellPackageOverrides or (self: super: {});
   };
 
···
   peg = callPackage ../development/tools/parsing/peg { };
 
   phantomjs = callPackage ../development/tools/phantomjs { };
+
+  phantomjs2 = callPackage ../development/tools/phantomjs2 { };
 
   pmccabe = callPackage ../development/tools/misc/pmccabe { };
 
···
   gitAndTools = recurseIntoAttrs (import ../applications/version-management/git-and-tools {
     inherit pkgs;
   });
-  git = gitAndTools.git;
-  gitFull = gitAndTools.gitFull;
+
+  inherit (gitAndTools) git gitFull gitSVN git-cola svn2git;
+
   gitMinimal = git.override {
     withManual = false;
     pythonSupport = false;
   };
-  gitSVN = gitAndTools.gitSVN;
-  git-cola = gitAndTools.git-cola;
 
   gitRepo = callPackage ../applications/version-management/git-repo {
     python = python27;

pkgs/top-level/make-tarball.nix

···
     mkdir -p $out/tarballs
     mkdir ../$releaseName
     cp -prd . ../$releaseName
-    echo nixpkgs > ../$releaseName/channel-name
     (cd .. && tar cfa $out/tarballs/$releaseName.tar.xz $releaseName) || false
   '';
 

pkgs/top-level/python-packages.nix

···
 
   pgcli = buildPythonPackage rec {
     name = "pgcli-${version}";
-    version = "0.18.0";
+    version = "0.19.1";
 
     src = pkgs.fetchFromGitHub {
-      sha256 = "1ydi1725ryz9by770kyx06cwrvyvixbg3502brkf5hvbjd8ddzrl";
+      sha256 = "1r34bbqbd4h72cl0cxi9w6q2nwx806wpxq220mzyiy8g45xv0ghj";
       rev = "v${version}";
       repo = "pgcli";
       owner = "amjith";
···
     propagatedBuildInputs = with self; [
       click configobj prompt_toolkit psycopg2 pygments sqlparse
     ];
-
-    postPatch = ''
-      substituteInPlace setup.py --replace "==" ">="
-    '';
 
     meta = {
       inherit version;
···
 
   prompt_toolkit = buildPythonPackage rec {
     name = "prompt_toolkit-${version}";
-    version = "0.43";
+    version = "0.45";
 
     src = pkgs.fetchurl {
-      sha256 = "1z5fap8c7q27p0s82jn11i6fwg0g9zm2zy5na8is53kgbhl10fdr";
+      sha256 = "19lp15rc0rq4jqaacg2a38cdgfy2avhf5v97yanasx4n2swx4gsm";
       url = "https://pypi.python.org/packages/source/p/prompt_toolkit/${name}.tar.gz";
     };
 
···
   };
 
   repocheck = buildPythonPackage rec {
-    name = "repocheck-2015-06-27";
+    name = "repocheck-2015-08-05";
     disabled = isPy26 || isPy27;
 
     src = pkgs.fetchFromGitHub {
-      sha256 = "0psihwph10sx07xc2gfch739laz7x1kwl5c991cci8cfn5jzy8bp";
-      rev = "231e05b4fa55955ef8492581a15f508ffa0037d4";
+      sha256 = "1jc4v5zy7z7xlfmbfzvyzkyz893f5x2k6kvb3ni3rn2df7jqhc81";
+      rev = "ee48d0e88d3f5814d24a8d1f22d5d83732824688";
       repo = "repocheck";
       owner = "kynikos";
     };
 
     meta = {
+      inherit (src.meta) homepage;
       description = "Check the status of code repositories under a root directory";
-      homepage = https://github.com/kynikos/repocheck;
       license = licenses.gpl3Plus;
       maintainers = with maintainers; [ nckx ];
     };