Merge branch 'master' into dbus-update

20 files changed, 4364 insertions, 142 deletions

diff --git a/gnu/packages/bioinformatics.scm b/gnu/packages/bioinformatics.scm
index 51e3df6d81..48edd56854 100644
--- a/gnu/packages/bioinformatics.scm
+++ b/gnu/packages/bioinformatics.scm
@@ -2149,6 +2149,52 @@ viewer.")
                                    (string-append bin "/samtools")))))
            (delete 'patch-tests)))))))
 
+(define-public mosaik
+  (let ((commit "5c25216d"))
+    (package
+      (name "mosaik")
+      (version "2.2.30")
+      (source (origin
+                ;; There are no release tarballs nor tags.
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/wanpinglee/MOSAIK.git")
+                      (commit commit)))
+                (file-name (string-append name "-" version))
+                (sha256
+                 (base32
+                  "17gj3s07cm77r41z92awh0bim7w7q7fbn0sf5nkqmcm1vw052qgw"))))
+      (build-system gnu-build-system)
+      (arguments
+       `(#:tests? #f ; no tests
+         #:make-flags (list "CC=gcc")
+         #:phases
+         (modify-phases %standard-phases
+           (replace 'configure
+                    (lambda _ (chdir "src") #t))
+           (replace 'install
+                    (lambda* (#:key outputs #:allow-other-keys)
+                      (let ((bin (string-append (assoc-ref outputs "out")
+                                                "/bin")))
+                        (mkdir-p bin)
+                        (copy-recursively "../bin" bin)
+                        #t))))))
+      (inputs
+       `(("perl" ,perl)
+         ("zlib" ,zlib)))
+      (home-page "https://code.google.com/p/mosaik-aligner/")
+      (synopsis "Map nucleotide sequence reads to reference genomes")
+      (description
+       "MOSAIK is a program for mapping second and third-generation sequencing
+reads to a reference genome.  MOSAIK can align reads generated by all the
+major sequencing technologies, including Illumina, Applied Biosystems SOLiD,
+Roche 454, Ion Torrent and Pacific BioSciences SMRT.")
+      ;; MOSAIK is released under the GPLv2+ with the exception of third-party
+      ;; code released into the public domain:
+      ;; 1. fastlz by Ariya Hidayat - http://www.fastlz.org/
+      ;; 2. MD5 implementation - RSA Data Security, RFC 1321
+      (license (list license:gpl2+ license:public-domain)))))
+
 (define-public ngs-sdk
   (package
     (name "ngs-sdk")
diff --git a/gnu/packages/cdrom.scm b/gnu/packages/cdrom.scm
index 62a6040280..884ba8bfa6 100644
--- a/gnu/packages/cdrom.scm
+++ b/gnu/packages/cdrom.scm
@@ -2,6 +2,7 @@
 ;;; Copyright © 2013, 2014, 2015 Ludovic Courtès <ludo@gnu.org>
 ;;; Copyright © 2013, 2014 Andreas Enge <andreas@enge.fr>
 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -231,6 +232,25 @@ depend on the file system of the medium.  The maximum error correction
 capacity is user-selectable.")
     (license gpl2+)))
 
+(define-public libcue
+  (package
+    (name "libcue")
+    (version "1.4.0")
+    (source (origin
+             (method url-fetch)
+             (uri (string-append "mirror://sourceforge/libcue/libcue-"
+                                 version ".tar.bz2"))
+             (sha256
+              (base32
+               "17kjd7rjz1bvfn44n3n2bjb7a1ywd0yc0g4sqp5ihf9b5bn7cwlb"))))
+    (build-system gnu-build-system)
+    (home-page "http://libcue.sourceforge.net/")
+    (synopsis "C library to parse cue sheets")
+    (description "Libcue is a C library to parse so-called @dfn{cue sheets}
+which contain meta-data for CD/DVD tracks.  It provides an API to manipulate
+the data.")
+    (license gpl2+)))
+
 (define-public cd-discid
   (package
     (name "cd-discid")
diff --git a/gnu/packages/compression.scm b/gnu/packages/compression.scm
index 941844b870..a9e942efd5 100644
--- a/gnu/packages/compression.scm
+++ b/gnu/packages/compression.scm
@@ -7,6 +7,7 @@
 ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net>
 ;;; Copyright © 2015 Leo Famulari <leo@famulari.name>
 ;;; Copyright © 2015 Jeff Mickey <j@codemac.net>
+;;; Copyright © 2015 Efraim Flashner <efraim@flashner.co.il>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -25,6 +26,7 @@
 
 (define-module (gnu packages compression)
   #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (guix utils)
   #:use-module (guix packages)
   #:use-module (guix download)
   #:use-module (guix git-download)
@@ -225,6 +227,36 @@ decompression.")
                                   "See LICENSE in the distribution."))
       (home-page "http://www.bzip.org/"))))
 
+(define-public pbzip2
+  (package
+    (name "pbzip2")
+    (version "1.1.12")
+    (source (origin
+             (method url-fetch)
+             (uri (string-append "https://launchpad.net/pbzip2/"
+                                 (version-major+minor version) "/" version
+                                 "/+download/" name "-" version ".tar.gz"))
+             (sha256
+              (base32
+               "1vk6065dv3a47p86vmp8hv3n1ygd9hraz0gq89gvzlx7lmcb6fsp"))))
+    (build-system gnu-build-system)
+    (inputs
+     `(("bzip2", bzip2)))
+    (arguments
+     `(#:tests? #f ; no tests
+       #:phases (modify-phases %standard-phases
+                  (delete 'configure))
+       #:make-flags (list (string-append "PREFIX=" %output))))
+    (home-page "http://compression.ca/pbzip2/")
+    (synopsis "Parallel bzip2 implementation")
+    (description
+     "Pbzip2 is a parallel implementation of the bzip2 block-sorting file
+compressor that uses pthreads and achieves near-linear speedup on SMP machines.
+The output of this version is fully compatible with bzip2 v1.0.2 (i.e. anything
+compressed with pbzip2 can be decompressed with bzip2).")
+    (license (license:non-copyleft "file://COPYING"
+                                   "See COPYING in the distribution."))))
+
 (define-public xz
   (package
    (name "xz")
diff --git a/gnu/packages/conkeror.scm b/gnu/packages/conkeror.scm
index 51bb1a260a..d91fe9e78b 100644
--- a/gnu/packages/conkeror.scm
+++ b/gnu/packages/conkeror.scm
@@ -1,6 +1,6 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2014 Cyrill Schenkel <cyrill.schenkel@gmail.com>
-;;; Copyright © 2014 Eric Bavier <bavier@member.fsf.org>
+;;; Copyright © 2014, 2015 Eric Bavier <bavier@member.fsf.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -28,46 +28,42 @@
 (define-public conkeror
   (package
     (name "conkeror")
-    (version "1.0pre1")
+    (version "1.0pre1.20150730")
     (source (origin
               (method url-fetch)
               (uri
                (string-append "http://repo.or.cz/w/conkeror.git/snapshot/"
-                              "8a26fff5896a3360549e2adfbf06b1d57e909266"
-                              ".tar.gz")) ; tag: debian-1.0--pre-1+git140616-1
+                              "a1f7e879b129df5cf14ea4ce80a9c1407380ed58"
+                              ".tar.gz")) ; tag: debian-1.0--pre-1+git150730-1
               (sha256
                (base32
-                "1cgjzi7g3g22zcx6bpfnid4i12sb45w6icmxdzjn8d3c0m8qsyp1"))))
+                "1q45hc30733gz3ca2ixvw0rzzcbi7rlay7gx7kvzjv17a030nyk0"))))
     (build-system gnu-build-system)
     (inputs `(("icecat" ,icecat)))
     (arguments
      `(#:tests? #f                      ;no tests
-       #:make-flags '("CC=gcc")
+       #:make-flags `("CC=gcc"
+                      ,(string-append "PREFIX=" (assoc-ref %outputs "out")))
        #:phases
-       (alist-delete
-        'configure
-        (alist-replace
-         'install
-         (lambda _
-           (begin
-             (use-modules (guix build utils))
-             (let* ((datadir  (string-append %output "/share/conkeror"))
-                    (bindir   (string-append %output "/bin"))
-                    (launcher (string-append bindir  "/conkeror"))
-                    (spawn    (string-append bindir  "/conkeror-spawn-helper")))
-               (copy-recursively "." datadir)
-               (mkdir-p bindir)
-               (copy-file "conkeror-spawn-helper" spawn)
-               (call-with-output-file launcher
-                 (lambda (p)
-                   (format p "#!~a/bin/bash
+       (modify-phases %standard-phases
+         (delete 'configure)
+         (add-after
+          'install 'install-app-launcher
+          (lambda* (#:key inputs outputs #:allow-other-keys)
+            ;; This overwrites the installed launcher, which execs xulrunner,
+            ;; with one that execs 'icecat --app'
+            (let* ((out      (assoc-ref outputs "out"))
+                   (datadir  (string-append out "/share/conkeror"))
+                   (launcher (string-append out "/bin/conkeror")))
+              (call-with-output-file launcher
+                (lambda (p)
+                  (format p "#!~a/bin/bash
 exec ~a/bin/icecat --app ~a \"$@\"~%"
-                           (assoc-ref %build-inputs "bash") ;implicit input
-                           (assoc-ref %build-inputs "icecat")
-                           (string-append datadir
-                                          "/application.ini"))))
-               (chmod launcher #o555))))
-         %standard-phases))))
+                          (assoc-ref inputs "bash") ;implicit input
+                          (assoc-ref inputs "icecat")
+                          (string-append datadir
+                                         "/application.ini"))))
+              (chmod launcher #o555)))))))
     (synopsis "Keyboard focused web browser with Emacs look and feel")
     (description "Conkeror is a highly-programmable web browser based on
 Mozilla XULRunner which is the base of all Mozilla products including Firefox.
diff --git a/gnu/packages/freeipmi.scm b/gnu/packages/freeipmi.scm
index e25d113dd2..badecc60ba 100644
--- a/gnu/packages/freeipmi.scm
+++ b/gnu/packages/freeipmi.scm
@@ -27,14 +27,14 @@
 (define-public freeipmi
   (package
     (name "freeipmi")
-    (version "1.4.9")
+    (version "1.4.10")
     (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/freeipmi/freeipmi-"
                                  version ".tar.gz"))
              (sha256
               (base32
-               "0v2xfwik2mv6z8066raiypc4xymjvr8pb0mv3mc3g4ym4km132qp"))))
+               "1l98l8g8lha85q1d288wr7dyx00x36smh9g5wza15n4wm35c9wqs"))))
     (build-system gnu-build-system)
     (inputs
      `(("readline" ,readline) ("libgcrypt" ,libgcrypt)))
diff --git a/gnu/packages/games.scm b/gnu/packages/games.scm
index 3023794218..546944ad25 100644
--- a/gnu/packages/games.scm
+++ b/gnu/packages/games.scm
@@ -6,12 +6,13 @@
 ;;; Copyright © 2014 Sylvain Beucler <beuc@beuc.net>
 ;;; Copyright © 2014, 2015 Ludovic Courtès <ludo@gnu.org>
 ;;; Copyright © 2014, 2015 Sou Bunnbu <iyzsong@gmail.com>
-;;; Copyright © 2014 Mark H Weaver <mhw@netris.org>
+;;; Copyright © 2014, 2015 Mark H Weaver <mhw@netris.org>
 ;;; Copyright © 2015 Andreas Enge <andreas@enge.fr>
 ;;; Copyright © 2015 David Hashe <david.hashe@dhashe.com>
 ;;; Copyright © 2015 Christopher Allan Webber <cwebber@dustycloud.org>
 ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net>
 ;;; Copyright © 2015 Alex Kost <alezost@gmail.com>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -34,7 +35,9 @@
   #:use-module (guix packages)
   #:use-module (guix download)
   #:use-module (guix git-download)
+  #:use-module (guix svn-download)
   #:use-module (gnu packages)
+  #:use-module (gnu packages autotools)
   #:use-module (gnu packages base)
   #:use-module (gnu packages admin)
   #:use-module (gnu packages audio)
@@ -49,6 +52,7 @@
   #:use-module (gnu packages guile)
   #:use-module (gnu packages libcanberra)
   #:use-module (gnu packages libunwind)
+  #:use-module (gnu packages haskell)
   #:use-module (gnu packages mp3)
   #:use-module (gnu packages image)
   #:use-module (gnu packages ncurses)
@@ -78,6 +82,7 @@
   #:use-module (gnu packages fribidi)
   #:use-module (guix build-system trivial)
   #:use-module (guix build-system gnu)
+  #:use-module (guix build-system haskell)
   #:use-module (guix build-system cmake)
   #:use-module (guix build-system trivial))
 
@@ -1048,6 +1053,48 @@ experience and advance levels, and are carried over from one scenario to the
 next campaign.")
     (license license:gpl2+)))
 
+(define-public dosbox
+  (package
+    (name "dosbox")
+    (version "0.74.svn3947")
+    (source (origin
+              (method svn-fetch)
+              (uri (svn-reference
+                    (url "http://svn.code.sf.net/p/dosbox/code-0/dosbox/trunk/")
+                    (revision 3947)))
+              (file-name (string-append name "-" version "-checkout"))
+              ;; Use SVN head, since the last release (2010) is incompatible
+              ;; with GCC 4.8+ (see
+              ;; <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=624976>).
+              (sha256
+               (base32
+                "1p918j6090d1nkvgq7ifvmn506zrdmyi32y7p3ms40d5ssqjg8fj"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:phases (modify-phases %standard-phases
+                  (add-after
+                   'unpack 'autogen.sh
+                   (lambda _
+                     (zero? (system* "sh" "autogen.sh")))))))
+    (native-inputs
+     `(("autoconf" ,autoconf)
+       ("automake" ,automake)))
+    (inputs
+     `(("sdl" ,sdl)
+       ("libpng" ,libpng)
+       ("zlib" ,zlib)
+       ("alsa-lib" ,alsa-lib)
+       ("glu" ,glu)
+       ("mesa" ,mesa)))
+    (home-page "http://www.dosbox.com")
+    (synopsis "x86 emulator with CGA/EGA/VGA/etc. graphics and sound")
+    (description "DOSBox is a DOS-emulator that uses the SDL library.  DOSBox
+also emulates CPU:286/386 realmode/protected mode, Directory
+FileSystem/XMS/EMS, Tandy/Hercules/CGA/EGA/VGA/VESA graphics, a
+SoundBlaster/Gravis Ultra Sound card for excellent sound compatibility with
+older games.")
+    (license license:gpl2+)))
+
 (define-public gamine
   (package
     (name "gamine")
@@ -1094,6 +1141,39 @@ on the screen and keyboard to display letters.")
     ;; Most files under gpl2+ or gpl3+, but eat.wav under gpl3
     (license license:gpl3)))
 
+(define-public raincat
+  (package
+    (name "raincat")
+    (version "1.1.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/Raincat/Raincat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1aalh68h6799mv4vyg30zpskl5jkn6x2j1jza7p4lrflyifxzar8"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-random" ,ghc-random)
+       ("ghc-glut" ,ghc-glut)
+       ("ghc-opengl" ,ghc-opengl)
+       ("ghc-sdl" ,ghc-sdl)
+       ("ghc-sdl-image" ,ghc-sdl-image)
+       ("ghc-sdl-mixer" ,ghc-sdl-mixer)))
+    (home-page "http://raincat.bysusanlin.com/")
+    (synopsis "Puzzle game with a cat in lead role")
+    (description "Project Raincat is a game developed by Carnegie Mellon
+students through GCS during the Fall 2008 semester.  Raincat features game
+play inspired from classics Lemmings and The Incredible Machine.  The project
+proved to be an excellent learning experience for the programmers.  Everything
+is programmed in Haskell.")
+    (license license:bsd-3)))
+
 (define-public manaplus
   (package
     (name "manaplus")
diff --git a/gnu/packages/gnu-pw-mgr.scm b/gnu/packages/gnu-pw-mgr.scm
index e7b93f024e..76329e8084 100644
--- a/gnu/packages/gnu-pw-mgr.scm
+++ b/gnu/packages/gnu-pw-mgr.scm
@@ -29,7 +29,7 @@
 (define-public gnu-pw-mgr
   (package
     (name "gnu-pw-mgr")
-    (version "1.5")
+    (version "1.6")
     (source
      (origin
       (method url-fetch)
@@ -37,7 +37,7 @@
                           version ".tar.xz"))
       (sha256
        (base32
-        "1winmckl4h8lypg57hd3nd7jscpdr7f1v8zi432k5h648izkf2dg"))))
+        "141wfm4w420ygrl7qvrc84drzv34jym0d2bxqcgi7n1vimql0slp"))))
     (build-system gnu-build-system)
     (native-inputs
      `(("which" ,which)
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 34cad87b4b..83ec3f9ca3 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -1,6 +1,7 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
 ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -19,7 +20,7 @@
 
 (define-module (gnu packages haskell)
   #:use-module (ice-9 regex)
-  #:use-module ((guix licenses) #:select (bsd-3 lgpl2.1))
+  #:use-module ((guix licenses) #:select (bsd-3 lgpl2.1 lgpl2.1+ gpl3+ expat))
   #:use-module (guix packages)
   #:use-module (guix download)
   #:use-module (guix utils)
@@ -29,13 +30,18 @@
   #:use-module (gnu packages perl)
   #:use-module (gnu packages compression)
   #:use-module (gnu packages elf)
+  #:use-module (gnu packages gl)
+  #:use-module (gnu packages sdl)
   #:use-module (gnu packages bootstrap)
+  #:use-module (gnu packages zip)
+  #:use-module (gnu packages gcc)
   #:use-module (gnu packages ghostscript)
   #:use-module (gnu packages libffi)
   #:use-module (gnu packages libedit)
   #:use-module (gnu packages multiprecision)
   #:use-module (gnu packages ncurses)
   #:use-module (gnu packages python)
+  #:use-module (gnu packages pcre)
   #:use-module (gnu packages xorg))
 
 (define ghc-bootstrap-x86_64-7.8.4
@@ -73,7 +79,7 @@
 (define-public ghc
   (package
     (name "ghc")
-    (version "7.8.4")
+    (version "7.10.2")
     (source
      (origin
       (method url-fetch)
@@ -81,7 +87,7 @@
                           version "/" name "-" version "-src.tar.xz"))
       (sha256
        (base32
-        "1i4254akbb4ym437rf469gc0m40bxm31blp6s1z1g15jmnacs6f3"))))
+        "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal"))))
     (build-system gnu-build-system)
     (supported-systems '("i686-linux" "x86_64-linux"))
     (outputs '("out" "doc"))
@@ -98,7 +104,7 @@
                  version "/" name "-" version "-testsuite.tar.xz"))
            (sha256
             (base32
-             "0q95whf87y4mxjzwzy899g7z7l9pazq4si6iciyhxkcdhqq2ycyh"))))))
+             "0qp9da9ar87zbyn6wjgacd2ic1vgzbi3cklxnhsmjqyafv9qaj4b"))))))
     (native-inputs
      `(("perl" ,perl)
        ("python" ,python-2)                ; for tests (fails with python-3)
@@ -203,7 +209,7 @@
                       (string-append ghc-bootstrap-prefix
                                      "/lib/ghc-7.8.4/terminfo-0.4.0.0")))
                 (with-directory-excursion
-                    (string-append ghc-bootstrap-path "/" ,name "-" ,version)
+                    (string-append ghc-bootstrap-path "/ghc-7.8.4")
                   (setenv "CONFIG_SHELL" (which "bash"))
                   (setenv "LD_LIBRARY_PATH" gmp-lib)
                   ;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded.
@@ -231,7 +237,7 @@
              'configure 'install-bin
              (lambda* (#:key inputs outputs #:allow-other-keys)
                (with-directory-excursion
-                   (string-append ghc-bootstrap-path "/" ,name "-" ,version)
+                   (string-append ghc-bootstrap-path "/ghc-7.8.4")
                  (zero? (system* "make" "install"))))
              %standard-phases)))))))
     (home-page "https://www.haskell.org/ghc")
@@ -241,6 +247,28 @@
 interactive environment for the functional language Haskell.")
     (license bsd-3)))
 
+(define-public ghc-prelude-extras
+  (package
+    (name "ghc-prelude-extras")
+    (version "0.4.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/prelude-extras/prelude-extras-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1q7mj9hysy747vimnlyrwsk1wb2axymxixa76fwcbcnmz3fi4llp"))))
+    (build-system haskell-build-system)
+    (home-page "http://github.com/ekmett/prelude-extras")
+    (synopsis "Higher order versions of Prelude classes")
+    (description "This library provides higher order versions of
+@code{Prelude} classes to ease programming with polymorphic recursion and
+reduce @code{UndecidableInstances}.")
+    (license bsd-3)))
+
 (define-public ghc-data-default
   (package
     (name "ghc-data-default")
@@ -361,6 +389,848 @@ package.")
 package.")
     (license bsd-3)))
 
+(define-public ghc-haddock-library
+  (package
+    (name "ghc-haddock-library")
+    (version "1.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/haddock-library/haddock-library-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "http://www.haskell.org/haddock/")
+    (synopsis
+     "Library exposing some functionality of Haddock")
+    (description
+     "Haddock is a documentation-generation tool for Haskell libraries.  These
+modules expose some functionality of it without pulling in the GHC dependency.
+Please note that the API is likely to change so specify upper bounds in your
+project if you can't release often.  For interacting with Haddock itself, see
+the ‘haddock’ package.")
+    (license bsd-3)))
+
+(define-public ghc-haddock-api
+  (package
+    (name "ghc-haddock-api")
+    (version "2.16.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/haddock-api/haddock-api-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-paths" ,ghc-paths)
+       ("ghc-haddock-library" ,ghc-haddock-library)))
+    (home-page "http://www.haskell.org/haddock/")
+    (synopsis "API for documentation-generation tool Haddock")
+    (description "This package provides an API to Haddock, the
+documentation-generation tool for Haskell libraries.")
+    (license bsd-3)))
+
+(define-public ghc-haddock
+  (package
+    (name "ghc-haddock")
+    (version "2.16.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/haddock/haddock-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed
+                               ; upstream.  See
+                               ; <https://github.com/haskell/haddock/issues/427>
+    (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
+    (home-page "http://www.haskell.org/haddock/")
+    (synopsis
+     "Documentation-generation tool for Haskell libraries")
+    (description
+     "Haddock is a documentation-generation tool for Haskell libraries.")
+    (license bsd-3)))
+
+(define-public ghc-simple-reflect
+  (package
+    (name "ghc-simple-reflect")
+    (version "0.3.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/simple-reflect/simple-reflect-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
+    (synopsis
+     "Simple reflection of expressions containing variables")
+    (description
+     "This package allows simple reflection of expressions containing
+variables.  Reflection here means that a Haskell expression is turned into a
+string.  The primary aim of this package is teaching and understanding; there
+are no options for manipulating the reflected expressions beyond showing
+them.")
+    (license bsd-3)))
+
+(define-public ghc-multipart
+  (package
+    (name "ghc-multipart")
+    (version "0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/multipart/multipart-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-parsec" ,ghc-parsec)))
+    (home-page
+     "http://www.github.com/silkapp/multipart")
+    (synopsis
+     "HTTP multipart library")
+    (description
+     "HTTP multipart split out of the cgi package, for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-html
+  (package
+    (name "ghc-html")
+    (version "1.0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/html/html-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://hackage.haskell.org/package/html")
+    (synopsis "HTML combinator library")
+    (description
+     "This package contains a combinator library for constructing HTML
+documents.")
+    (license bsd-3)))
+
+(define-public ghc-xhtml
+  (package
+    (name "ghc-xhtml")
+    (version "3000.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/xhtml/xhtml-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/haskell/xhtml")
+    (synopsis "XHTML combinator library")
+    (description
+     "This package provides combinators for producing XHTML 1.0, including the
+Strict, Transitional and Frameset variants.")
+    (license bsd-3)))
+
+(define-public ghc-haskell-src
+  (package
+    (name "ghc-haskell-src")
+    (version "1.0.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/haskell-src/haskell-src-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-happy" ,ghc-happy)
+       ("ghc-syb" ,ghc-syb)))
+    (home-page
+     "http://hackage.haskell.org/package/haskell-src")
+    (synopsis
+     "Support for manipulating Haskell source code")
+    (description
+     "The 'haskell-src' package provides support for manipulating Haskell
+source code.  The package provides a lexer, parser and pretty-printer, and a
+definition of a Haskell abstract syntax tree (AST).  Common uses of this
+package are to parse or generate Haskell 98 code.")
+    (license bsd-3)))
+
+(define-public ghc-alex
+  (package
+    (name "ghc-alex")
+    (version "3.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/alex/alex-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10.  Fixed
+                               ; upstream, see
+                               ; <https://github.com/simonmar/alex/issues/62>
+    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "http://www.haskell.org/alex/")
+    (synopsis
+     "Tool for generating lexical analysers in Haskell")
+    (description
+     "Alex is a tool for generating lexical analysers in Haskell.  It takes a
+description of tokens based on regular expressions and generates a Haskell
+module containing code for scanning text efficiently.  It is similar to the
+tool lex or flex for C/C++.")
+    (license bsd-3)))
+
+(define-public ghc-cgi
+  (package
+    (name "ghc-cgi")
+    (version "3001.2.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/cgi/cgi-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-parsec" ,ghc-parsec)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-old-time" ,ghc-old-time)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-multipart" ,ghc-multipart)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-network" ,ghc-network)
+       ("ghc-mtl" ,ghc-mtl)))
+    (home-page
+     "https://github.com/cheecheeo/haskell-cgi")
+    (synopsis "Library for writing CGI programs")
+    (description
+     "This is a Haskell library for writing CGI programs.")
+    (license bsd-3)))
+
+(define-public ghc-cmdargs
+  (package
+    (name "ghc-cmdargs")
+    (version "0.10.13")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/cmdargs/cmdargs-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://community.haskell.org/~ndm/cmdargs/")
+    (synopsis "Command line argument processing")
+    (description
+     "This library provides an easy way to define command line parsers.")
+    (license bsd-3)))
+
+(define-public ghc-happy
+  (package
+    (name "ghc-happy")
+    (version "1.19.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/happy/happy-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ;; cannot satisfy -package mtl.  Possible Cabal
+                               ;; issue.
+    (propagated-inputs
+     `(("ghc-mtl" ,ghc-mtl)))
+    (home-page "https://hackage.haskell.org/package/happy")
+    (synopsis "Parser generator for Haskell")
+    (description "Happy is a parser generator for Haskell.  Given a grammar
+specification in BNF, Happy generates Haskell code to parse the grammar.
+Happy works in a similar way to the yacc tool for C.")
+    (license bsd-3)))
+
+(define-public ghc-haskell-src-exts
+  (package
+    (name "ghc-haskell-src-exts")
+    (version "1.16.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("cpphs" ,cpphs)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-happy" ,ghc-happy)
+       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)
+       ("ghc-syb" ,ghc-syb)))
+    (home-page "https://github.com/haskell-suite/haskell-src-exts")
+    (synopsis "Library for manipulating Haskell source")
+    (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
+extension of the standard @code{haskell-src} package, and handles most
+registered syntactic extensions to Haskell.  All extensions implemented in GHC
+are supported.  Apart from these standard extensions, it also handles regular
+patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
+    (license bsd-3)))
+
+(define-public hlint
+  (package
+    (name "hlint")
+    (version "1.9.21")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/" name
+             "/" name "-" version ".tar.gz"))
+       (sha256
+        (base32
+         "14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("cpphs" ,cpphs)
+       ("ghc-cmdargs" ,ghc-cmdargs)
+       ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+       ("ghc-uniplate" ,ghc-uniplate)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-extra" ,ghc-extra)
+       ("hscolour" ,hscolour)))
+    (home-page "http://community.haskell.org/~ndm/hlint/")
+    (synopsis "Suggest improvements for Haskell source code")
+    (description "HLint reads Haskell programs and suggests changes that
+hopefully make them easier to read.  HLint also makes it easy to disable
+unwanted suggestions, and to add your own custom suggestions.")
+    (license bsd-3)))
+
+(define-public ghc-resourcet
+  (package
+    (name "ghc-resourcet")
+    (version "1.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/resourcet/resourcet-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-mmorph" ,ghc-mmorph)
+       ("ghc-exceptions" ,ghc-exceptions)))
+    (inputs
+     `(("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "http://github.com/snoyberg/conduit")
+    (synopsis "Deterministic allocation and freeing of scarce resources")
+    (description "ResourceT is a monad transformer which creates a region of
+code where you can safely allocate resources.")
+    (license bsd-3)))
+
+(define-public ghc-xss-sanitize
+  (package
+    (name "ghc-xss-sanitize")
+    (version "0.3.5.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-tagsoup" ,ghc-tagsoup)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-css-text" ,ghc-css-text)
+       ("ghc-network-uri" ,ghc-network-uri)))
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "http://github.com/yesodweb/haskell-xss-sanitize")
+    (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
+    (description "This library provides @code{sanitizeXSS}.  Run untrusted
+HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
+attacks.")
+    (license bsd-3)))
+
+(define-public ghc-objectname
+  (package
+    (name "ghc-objectname")
+    (version "1.1.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/ObjectName/ObjectName-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/ObjectName")
+    (synopsis "Helper library for Haskell OpenGL")
+    (description "This tiny package contains the class ObjectName, which
+corresponds to the general notion of explicitly handled identifiers for API
+objects, e.g. a texture object name in OpenGL or a buffer object name in
+OpenAL.")
+    (license bsd-3)))
+
+(define-public ghc-sdl
+  (package
+    (name "ghc-sdl")
+    (version "0.6.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/SDL/SDL-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after
+          'unpack 'fix-/bin/sh
+          (lambda _
+            ;; Use `sh', not `/bin/sh'.
+            (setenv "CONFIG_SHELL" "sh"))))))
+    (inputs
+     `(("sdl" ,sdl)))
+    (home-page "https://hackage.haskell.org/package/SDL")
+    (synopsis "LibSDL for Haskell")
+    (description "Simple DirectMedia Layer (libSDL) is a cross-platform
+multimedia library designed to provide low level access to audio, keyboard,
+mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer.  It is used
+by MPEG playback software, emulators, and many popular games, including the
+award winning Linux port of \"Civilization: Call To Power.\"")
+    (license bsd-3)))
+
+(define-public ghc-sdl-mixer
+  (package
+    (name "ghc-sdl-mixer")
+    (version "0.6.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:configure-flags
+       (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
+              (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
+         (list (string-append "--extra-include-dirs=" sdl-mixer-include)))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after
+          'unpack 'fix-/bin/sh
+          (lambda _
+            ;; Use `sh', not `/bin/sh'.
+            (setenv "CONFIG_SHELL" "sh"))))))
+    (propagated-inputs
+     `(("ghc-sdl" ,ghc-sdl)))
+    (inputs
+     `(("sdl-mixer" ,sdl-mixer)))
+    (home-page "http://hackage.haskell.org/package/SDL-mixer")
+    (synopsis "Haskell bindings to libSDL_mixer")
+    (description "SDL_mixer is a sample multi-channel audio mixer library.  It
+supports any number of simultaneously playing channels of 16 bit stereo audio,
+plus a single channel of music, mixed by the popular MikMod MOD, Timidity
+MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
+    (license bsd-3)))
+
+(define-public ghc-sdl-image
+  (package
+    (name "ghc-sdl-image")
+    (version "0.6.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/SDL-image/SDL-image-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:configure-flags
+       (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
+              (sdl-image-include (string-append sdl-image "/include/SDL")))
+         (list (string-append "--extra-include-dirs=" sdl-image-include)))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after
+          'unpack 'fix-/bin/sh
+          (lambda _
+            ;; Use `sh', not `/bin/sh'.
+            (setenv "CONFIG_SHELL" "sh"))))))
+    (propagated-inputs
+     `(("ghc-sdl" ,ghc-sdl)))
+    (inputs
+     `(("sdl-image" ,sdl-image)))
+    (home-page "http://hackage.haskell.org/package/SDL-image")
+    (synopsis "Haskell bindings to libSDL_image")
+    (description "SDL_image is an image file loading library.  It loads images
+as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
+PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
+    (license bsd-3)))
+
+(define-public ghc-half
+  (package
+    (name "ghc-half")
+    (version "0.2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/half/half-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1"))))
+    (build-system haskell-build-system)
+    (home-page "http://github.com/ekmett/half")
+    (synopsis "Half-precision floating-point computations")
+    (description "This library provides a half-precision floating-point
+computation library for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-openglraw
+  (package
+    (name "ghc-openglraw")
+    (version "2.5.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-half" ,ghc-half)
+       ("glu" ,glu)
+       ("ghc-text" ,ghc-text)))
+    (home-page "http://www.haskell.org/haskellwiki/Opengl")
+    (synopsis "Raw Haskell bindings for the OpenGL graphics system")
+    (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
+graphics system and lots of OpenGL extensions.  It is basically a 1:1 mapping
+of OpenGL's C API, intended as a basis for a nicer interface.  OpenGLRaw
+offers access to all necessary functions, tokens and types plus a general
+facility for loading extension entries.  The module hierarchy closely mirrors
+the naming structure of the OpenGL extensions, making it easy to find the
+right module to import.  All API entries are loaded dynamically, so no special
+C header files are needed for building this package.  If an API entry is not
+found at runtime, a userError is thrown.")
+    (license bsd-3)))
+
+(define-public ghc-glut
+  (package
+    (name "ghc-glut")
+    (version "2.7.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/GLUT/GLUT-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-statevar" ,ghc-statevar)
+       ("ghc-openglraw" ,ghc-openglraw)))
+    (inputs
+     `(("ghc-opengl" ,ghc-opengl)
+       ("freeglut" ,freeglut)))
+    (home-page "http://www.haskell.org/haskellwiki/Opengl")
+    (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
+    (description "This library provides Haskell bindings for the OpenGL
+Utility Toolkit, a window system-independent toolkit for writing OpenGL
+programs.")
+    (license bsd-3)))
+
+(define-public ghc-gluraw
+  (package
+    (name "ghc-gluraw")
+    (version "1.5.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/GLURaw/GLURaw-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-openglraw" ,ghc-openglraw)))
+    (home-page "http://www.haskell.org/haskellwiki/Opengl")
+    (synopsis "Raw Haskell bindings GLU")
+    (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
+utility library.  It is basically a 1:1 mapping of GLU's C API, intended as a
+basis for a nicer interface.")
+    (license bsd-3)))
+
+(define-public ghc-opengl
+  (package
+    (name "ghc-opengl")
+    (version "2.12.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/OpenGL/OpenGL-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-objectname" ,ghc-objectname)
+       ("ghc-gluraw" ,ghc-gluraw)
+       ("ghc-statevar" ,ghc-statevar)
+       ("ghc-openglraw" ,ghc-openglraw)))
+    (home-page "http://www.haskell.org/haskellwiki/Opengl")
+    (synopsis "Haskell bindings for the OpenGL graphics system")
+    (description "This package provides Haskell bindings for the OpenGL
+graphics system (GL, version 4.5) and its accompanying utility library (GLU,
+version 1.3).")
+    (license bsd-3)))
+
+(define-public ghc-streaming-commons
+  (package
+    (name "ghc-streaming-commons")
+    (version "0.1.14.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/streaming-commons/streaming-commons-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-random" ,ghc-random)))
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-async" ,ghc-async)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-stm" ,ghc-stm)
+       ("ghc-text" ,ghc-text)
+       ("ghc-network" ,ghc-network)
+       ("ghc-zlib" ,ghc-zlib)))
+    (home-page "https://hackage.haskell.org/package/streaming-commons")
+    (synopsis "Conduit and pipes needed by some streaming data libraries")
+    (description "Provides low-dependency functionality commonly needed by
+various Haskell streaming data libraries, such as @code{conduit} and
+@code{pipe}s.")
+    (license bsd-3)))
+
+(define-public cpphs
+  (package
+    (name "cpphs")
+    (version "1.19.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/" name "/"
+             name "-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-polyparse" ,ghc-polyparse)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-old-time" ,ghc-old-time)))
+    (home-page "http://projects.haskell.org/cpphs/")
+    (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
+    (description "Cpphs is a re-implementation of the C pre-processor that is
+both more compatible with Haskell, and itself written in Haskell so that it
+can be distributed with compilers.  This version of the C pre-processor is
+pretty-much feature-complete and compatible with traditional (K&R)
+pre-processors.  Additional features include: a plain-text mode; an option to
+unlit literate code files; and an option to turn off macro-expansion.")
+    (license (list lgpl2.1+ gpl3+))))
+
+(define-public ghc-reflection
+  (package
+    (name "ghc-reflection")
+    (version "2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/reflection/reflection-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-tagged" ,ghc-tagged)))
+    (home-page "http://github.com/ekmett/reflection")
+    (synopsis "Reify arbitrary terms into types that can be reflected back
+into terms")
+    (description "This package addresses the 'configuration problem' which is
+propogating configurations that are available at run-time, allowing multiple
+configurations to coexist without resorting to mutable global variables or
+@code{System.IO.Unsafe.unsafePerformIO}.")
+    (license bsd-3)))
+
+(define-public ghc-old-locale
+  (package
+    (name "ghc-old-locale")
+    (version "1.0.0.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/old-locale/old-locale-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/old-locale")
+    (synopsis "Adapt to locale conventions")
+    (description
+     "This package provides the ability to adapt to locale conventions such as
+date and time formats.")
+    (license bsd-3)))
+
+(define-public ghc-old-time
+  (package
+    (name "ghc-old-time")
+    (version "1.1.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/old-time/old-time-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'fix-/bin/sh
+                    (lambda _
+                      (setenv "CONFIG_SHELL" "sh"))))))
+    (propagated-inputs
+     `(("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "http://hackage.haskell.org/package/old-time")
+    (synopsis "Time compatibility library for Haskell")
+    (description "Old-time is a package for backwards compatibility with the
+old @code{time} library.  For new projects, the newer
+@uref{http://hackage.haskell.org/package/time, time library} is recommended.")
+    (license bsd-3)))
+
 (define-public ghc-data-default-instances-old-locale
   (package
     (name "ghc-data-default-instances-old-locale")
@@ -376,7 +1246,8 @@ package.")
           (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
     (build-system haskell-build-system)
     (propagated-inputs
-      `(("ghc-data-default-class" ,ghc-data-default-class)))
+     `(("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-old-locale" ,ghc-old-locale)))
     (home-page
       "http://hackage.haskell.org/package/data-default-instances-old-locale")
     (synopsis "Default instances for types in old-locale")
@@ -387,7 +1258,7 @@ package.")
 (define-public ghc-dlist
   (package
     (name "ghc-dlist")
-    (version "0.7.1.1")
+    (version "0.7.1.2")
     (source
      (origin
        (method url-fetch)
@@ -396,9 +1267,10 @@ package.")
              version
              ".tar.gz"))
        (sha256
-        (base32 "1zayvxvkan2s2ixajdr3f5rn1gzhprzv6cww4cbpwjhzw0l7zc08"))))
-    (arguments `(#:tests? #f))
+        (base32 "10rp96rryij7d8gz5kv8ygc6chm1624ck5mbnqs2a3fkdzqj2b9k"))))
     (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "https://github.com/spl/dlist")
     (synopsis "Difference lists")
     (description
@@ -430,7 +1302,7 @@ versions of GHC (i.e., < 6.10).")
 (define-public cabal-install
  (package
   (name "cabal-install")
-   (version "1.18.1.0")
+   (version "1.22.6.0")
    (source
     (origin
      (method url-fetch)
@@ -439,7 +1311,7 @@ versions of GHC (i.e., < 6.10).")
             version
             ".tar.gz"))
       (sha256
-       (base32 "1r1shhvnpgxf91rmbv3wa1rkd24plbgr6bpz3aj80ir0z3zbdayn"))))
+       (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx"))))
    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
    (build-system haskell-build-system)
    (propagated-inputs
@@ -461,7 +1333,7 @@ installation of Haskell libraries and programs.")
 (define-public ghc-mtl
   (package
     (name "ghc-mtl")
-    (version "2.1.3.1")
+    (version "2.2.1")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -472,18 +1344,17 @@ installation of Haskell libraries and programs.")
              ".tar.gz"))
        (sha256
         (base32
-         "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp"))))
+         "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
     (build-system haskell-build-system)
     (home-page "http://github.com/ekmett/mtl")
     (synopsis
      "Monad classes, using functional dependencies")
-    (description
-     "Monad classes using functional dependencies, with instances
-for various monad transformers, inspired by the paper
-'Functional Programming with Overloading and Higher-Order Polymorphism',
-by Mark P Jones, in 'Advanced School of Functional Programming', 1995
-http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.")
-  (license bsd-3)))
+    (description "Monad classes using functional dependencies, with instances
+for various monad transformers, inspired by the paper 'Functional Programming
+with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced
+School of Functional Programming', 1995.  See
+@uref{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
+    (license bsd-3)))
 
 (define-public ghc-paths
   (package
@@ -511,7 +1382,7 @@ http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.")
 (define-public ghc-utf8-string
   (package
     (name "ghc-utf8-string")
-    (version "0.3.8")
+    (version "1.0.1.1")
     (source
      (origin
        (method url-fetch)
@@ -520,16 +1391,37 @@ http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.")
              version
              ".tar.gz"))
        (sha256
-        (base32 "1h29dn0scsfkhmkg14ywq9178lw40ah1r36w249zfzqr02y7qxc0"))))
+        (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
     (build-system haskell-build-system)
     (home-page "http://github.com/glguy/utf8-string/")
     (synopsis "Support for reading and writing UTF8 Strings")
     (description
-     "A UTF8 layer for Strings. The utf8-string package provides operations
+     "A UTF8 layer for Strings.  The utf8-string package provides operations
 for encoding UTF8 strings to Word8 lists and back, and for reading and writing
 UTF8 without truncation.")
     (license bsd-3)))
 
+(define-public ghc-setenv
+  (package
+    (name "ghc-setenv")
+    (version "0.1.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/setenv/setenv-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/setenv")
+    (synopsis "Library for setting environment variables")
+    (description "This package provides a Haskell library for setting
+environment variables.")
+    (license expat)))
+
 (define-public ghc-x11
   (package
     (name "ghc-x11")
@@ -590,6 +1482,29 @@ bindings are a direct translation of the C bindings.")
 parts.")
     (license lgpl2.1)))
 
+(define-public ghc-stringbuilder
+  (package
+    (name "ghc-stringbuilder")
+    (version "0.5.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/stringbuilder/stringbuilder-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
+                               ; enabled
+    (home-page "http://hackage.haskell.org/package/stringbuilder")
+    (synopsis "Writer monad for multi-line string literals")
+    (description "This package provides a writer monad for multi-line string
+literals.")
+    (license expat)))
+
 (define-public ghc-zlib
   (package
     (name "ghc-zlib")
@@ -666,7 +1581,7 @@ access to the full zlib feature set.")
 (define-public ghc-text
   (package
     (name "ghc-text")
-    (version "1.2.0.4")
+    (version "1.2.1.3")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -677,7 +1592,7 @@ access to the full zlib feature set.")
              ".tar.gz"))
        (sha256
         (base32
-         "004p1c74crs8wmjafwsmw3mmycspq1j8fpm1lvfpq6acha7bnpc6"))))
+         "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq"))))
     (build-system haskell-build-system)
     (arguments
      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
@@ -696,7 +1611,7 @@ in terms of large data quantities and high speed.")
 (define-public ghc-hashable
   (package
     (name "ghc-hashable")
-    (version "1.2.3.2")
+    (version "1.2.3.3")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -707,7 +1622,7 @@ in terms of large data quantities and high speed.")
              ".tar.gz"))
        (sha256
         (base32
-         "0h9295pv2sgbaqlwpwbx2bap6nngm0jcdhkqham1wpjwyxqgqrlc"))))
+         "0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw"))))
     (build-system haskell-build-system)
     (arguments
      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
@@ -771,7 +1686,7 @@ library, including the ability to split random number generators.")
 (define-public ghc-primitive
   (package
     (name "ghc-primitive")
-    (version "0.5.4.0")
+    (version "0.6.1.0")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -782,7 +1697,7 @@ library, including the ability to split random number generators.")
              ".tar.gz"))
        (sha256
         (base32
-         "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10"))))
+         "1j1q7l21rdm8kfs93vibr3xwkkhqis181w2k6klfhx5g5skiywwk"))))
     (build-system haskell-build-system)
     (home-page
      "https://github.com/haskell/primitive")
@@ -819,10 +1734,1048 @@ the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
 Hashing\" by Claessen, Pałka for details and the rationale of the design.")
     (license bsd-3)))
 
+(define-public ghc-transformers-base
+  (package
+    (name "ghc-transformers-base")
+    (version "0.4.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/transformers-base/transformers-base-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-stm" ,ghc-stm)))
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page
+     "http://hackage.haskell.org/package/transformers-compat")
+    (synopsis
+     "Backported transformer library")
+    (description
+     "Backported versions of types that were added to transformers in
+transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
+compatibility to run on old versions of the platform.")
+    (license bsd-3)))
+
+(define-public ghc-transformers-compat
+  (package
+    (name "ghc-transformers-compat")
+    (version "0.4.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/transformers-compat"
+             "/transformers-compat-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym"))))
+    (build-system haskell-build-system)
+    (home-page "http://github.com/ekmett/transformers-compat/")
+    (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
+    (description "This package includes backported versions of types that were
+added to transformers in transformers 0.3 and 0.4 for users who need strict
+transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
+but also need those types.")
+    (license bsd-3)))
+
+(define-public ghc-unix-time
+  (package
+    (name "ghc-unix-time")
+    (version "0.3.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/unix-time/unix-time-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f ; FIXME: Test fails with "System.Time not found".  This is
+                   ; weird, that should be provided by GHC 7.10.2.
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'fix-/bin/sh
+                    (lambda _
+                      (setenv "CONFIG_SHELL" "sh"))))))
+    (propagated-inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "http://hackage.haskell.org/package/unix-time")
+    (synopsis "Unix time parser/formatter and utilities")
+    (description "This library provides fast parsing and formatting utilities
+for Unix time in Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-unix-compat
+  (package
+    (name "ghc-unix-compat")
+    (version "0.4.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/unix-compat/unix-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://github.com/jystic/unix-compat")
+    (synopsis "Portable POSIX-compatibility layer")
+    (description
+     "This package provides portable implementations of parts of the unix
+package.  This package re-exports the unix package when available.  When it
+isn't available, portable implementations are used.")
+    (license bsd-3)))
+
+(define-public ghc-http-types
+  (package
+    (name "ghc-http-types")
+    (version "0.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/http-types/http-types-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find
+                               ; Blaze.Bytestring.Builder, which should be
+                               ; provided by ghc-blaze-builder.
+    (propagated-inputs
+     `(("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)))
+    (inputs
+     `(("ghc-text" ,ghc-text)))
+    (home-page "https://github.com/aristidb/http-types")
+    (synopsis "Generic HTTP types for Haskell")
+    (description "This package provides generic HTTP types for Haskell (for
+both client and server code).")
+    (license bsd-3)))
+
+(define-public ghc-iproute
+  (package
+    (name "ghc-iproute")
+    (version "1.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/iproute/iproute-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ply0i110c2sppjbfyysgw48jfjnsbam5zwil8xws0hp20rh1pb5"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
+                               ; exported by ghc-byteorder.  Doctest issue.
+    (propagated-inputs
+     `(("ghc-appar" ,ghc-appar)
+       ("ghc-byteorder" ,ghc-byteorder)))
+    (inputs
+     `(("ghc-network" ,ghc-network)
+       ("ghc-safe" ,ghc-safe)))
+    (home-page "http://www.mew.org/~kazu/proj/iproute/")
+    (synopsis "IP routing table")
+    (description "IP Routing Table is a tree of IP ranges to search one of
+them on the longest match base.  It is a kind of TRIE with one way branching
+removed.  Both IPv4 and IPv6 are supported.")
+    (license bsd-3)))
+
+(define-public ghc-regex-base
+  (package
+    (name "ghc-regex-base")
+    (version "0.93.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/regex-base/regex-base-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-mtl" ,ghc-mtl)))
+    (home-page
+     "http://sourceforge.net/projects/lazy-regex")
+    (synopsis "Replaces/Enhances Text.Regex")
+    (description "@code{Text.Regex.Base} provides the interface API for
+regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
+    (license bsd-3)))
+
+(define-public ghc-regex-posix
+  (package
+    (name "ghc-regex-posix")
+    (version "0.95.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/regex-posix/regex-posix-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-regex-base" ,ghc-regex-base)))
+    (home-page "http://sourceforge.net/projects/lazy-regex")
+    (synopsis "POSIX regular expressions for Haskell")
+    (description "This library provides the POSIX regex backend used by the
+Haskell library @code{regex-base}.")
+    (license bsd-3)))
+
+(define-public ghc-regex-compat
+  (package
+    (name "ghc-regex-compat")
+    (version "0.95.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/regex-compat/regex-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-base" ,ghc-regex-base)
+       ("ghc-regex-posix" ,ghc-regex-posix)))
+    (home-page "http://sourceforge.net/projects/lazy-regex")
+    (synopsis "Replaces/Enhances Text.Regex")
+    (description "This library provides one module layer over
+@code{regex-posix} to replace @code{Text.Regex}.")
+    (license bsd-3)))
+
+(define-public ghc-regex-tdfa-rc
+  (package
+    (name "ghc-regex-tdfa-rc")
+    (version "1.1.8.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-regex-base" ,ghc-regex-base)
+       ("ghc-parsec" ,ghc-parsec)))
+    (inputs
+     `(("ghc-mtl" ,ghc-mtl)))
+    (home-page
+     "http://hackage.haskell.org/package/regex-tdfa")
+    (synopsis "Tagged DFA regex engine for Haskell")
+    (description "A new all-Haskell \"tagged\" DFA regex engine, inspired by
+@code{libtre} (fork by Roman Cheplyaka).")
+    (license bsd-3)))
+
+(define-public ghc-parsers
+  (package
+    (name "ghc-parsers")
+    (version "0.12.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/parsers/parsers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "18wzmp8y3py4qa8hdsxqm0jfzmwy744dw7xa48r5s8ynhpimi462"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
+                               ; -package attoparsec-0.13.0.1"
+    (propagated-inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-parsec" ,ghc-parsec)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-charset" ,ghc-charset)))
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "http://github.com/ekmett/parsers/")
+    (synopsis "Parsing combinators")
+    (description "This library provides convenient combinators for working
+with and building parsing combinator libraries.  Given a few simple instances,
+you get access to a large number of canned definitions.  Instances exist for
+the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
+@code{Text.Read}.")
+    (license bsd-3)))
+
+(define-public ghc-trifecta
+  (package
+    (name "ghc-trifecta")
+    (version "1.5.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/trifecta/trifecta-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0fjhnsbafl3yw34pyhcsvrqy6a2mnhyqys6gna3rrlygs8ck7hpb"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
+                               ; -package ansi-terminal-0.6.2.3"
+    (propagated-inputs
+     `(("ghc-charset" ,ghc-charset)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-reducers" ,ghc-reducers)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (inputs
+     `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)
+       ("ghc-fingertree" ,ghc-fingertree)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-parsers" ,ghc-parsers)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (home-page "http://github.com/ekmett/trifecta/")
+    (synopsis "Parser combinator library with convenient diagnostics")
+    (description "Trifecta is a modern parser combinator library for Haskell,
+with slicing and Clang-style colored diagnostics.")
+    (license bsd-3)))
+
+(define-public ghc-attoparsec
+  (package
+    (name "ghc-attoparsec")
+    (version "0.13.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/attoparsec/attoparsec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: ghc-test-framework unavailable
+    (propagated-inputs
+     `(("ghc-scientific" ,ghc-scientific)))
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/bos/attoparsec")
+    (synopsis "Fast combinator parsing for bytestrings and text")
+    (description "This library provides a fast parser combinator library,
+aimed particularly at dealing efficiently with network protocols and
+complicated text/binary file formats.")
+    (license bsd-3)))
+
+(define-public ghc-css-text
+  (package
+    (name "ghc-css-text")
+    (version "0.1.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/css-text/css-text-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "http://www.yesodweb.com/")
+    (synopsis "CSS parser and renderer")
+    (description "This package provides a CSS parser and renderer for
+Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-zip-archive
+  (package
+    (name "ghc-zip-archive")
+    (version "0.2.3.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/zip-archive/zip-archive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-digest" ,ghc-digest)))
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-mtl" ,ghc-mtl)
+       ("zip" ,zip)
+       ("ghc-text" ,ghc-text)
+       ("ghc-zlib" ,ghc-zlib)))
+    (home-page "https://hackage.haskell.org/package/zip-archive")
+    (synopsis "Zip archive library for Haskell")
+    (description "The zip-archive library provides functions for creating,
+modifying, and extracting files from zip archives in Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-distributive
+  (package
+    (name "ghc-distributive")
+    (version "0.4.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/distributive/distributive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: fails with "cannot satisfy -package
+                               ; tagged-0.8.1".  Suspected Cabal issue.
+    (propagated-inputs
+     `(("ghc-tagged" ,ghc-tagged)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "http://github.com/ekmett/distributive/")
+    (synopsis "Distributive functors for Haskell")
+    (description "This package provides distributive functors for Haskell.
+Dual to @code{Traversable}.")
+    (license bsd-3)))
+
+(define-public ghc-cereal
+  (package
+    (name "ghc-cereal")
+    (version "0.4.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/cereal/cereal-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/cereal")
+    (synopsis "Binary serialization library")
+    (description "This package provides a binary serialization library,
+similar to @code{binary}, that introduces an @code{isolate} primitive for
+parser isolation, and labeled blocks for better error messages.")
+    (license bsd-3)))
+
+(define-public ghc-comonad
+  (package
+    (name "ghc-comonad")
+    (version "4.2.7.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/comonad/comonad-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-distributive" ,ghc-distributive)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-contravariant" ,ghc-contravariant)))
+    (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
+                               ; -package contravariant-1.3.3"
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-contravariant" ,ghc-contravariant)))
+    (home-page "http://github.com/ekmett/comonad/")
+    (synopsis "Comonads for Haskell")
+    (description "This library provides @code{Comonad}s for Haskell.")
+    (license bsd-3)))
+
+(define-public hscolour
+  (package
+    (name "hscolour")
+    (version "1.23")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hscolour/hscolour-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/hscolour")
+    (synopsis "Script to colourise Haskell code")
+    (description "HSColour is a small Haskell script to colourise Haskell
+code.  It currently has six output formats: ANSI terminal codes (optionally
+XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01
+with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX,
+and mIRC chat codes.")
+    (license bsd-3)))
+
+(define-public ghc-polyparse
+  (package
+    (name "ghc-polyparse")
+    (version "1.11")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/polyparse/polyparse-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)))
+    (home-page
+     "http://code.haskell.org/~malcolm/polyparse/")
+    (synopsis
+     "Alternative parser combinator libraries")
+    (description
+     "This package provides a variety of alternative parser combinator
+libraries, including the original HuttonMeijer set.  The Poly sets have
+features like good error reporting, arbitrary token type, running state, lazy
+parsing, and so on.  Finally, Text.Parse is a proposed replacement for the
+standard Read class, for better deserialisation of Haskell values from
+Strings.")
+    (license lgpl2.1)))
+
+(define-public ghc-extra
+  (package
+    (name "ghc-extra")
+    (version "1.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/extra/extra-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1h9hxkrqrqscx420yz1lmivbrhi6jc3a5ap61vkxd2mhdgark9hf"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/ndmitchell/extra")
+    (synopsis "Extra Haskell functions")
+    (description "This library provides extra functions for the standard
+Haskell libraries.  Most functions are simple additions, filling out missing
+functionality.  A few functions are available in later versions of GHC, but
+this package makes them available back to GHC 7.2.")
+    (license bsd-3)))
+
+(define-public ghc-profunctors
+  (package
+    (name "ghc-profunctors")
+    (version "5.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/profunctors/profunctors-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-distributive" ,ghc-distributive)))
+    (inputs
+     `(("ghc-comonad" ,ghc-comonad)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page "http://github.com/ekmett/profunctors/")
+    (synopsis "Profunctors for Haskell")
+    (description "This library provides profunctors for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-reducers
+  (package
+    (name "ghc-reducers")
+    (version "3.12.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/reducers/reducers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0pkddg0s3cn759miq0nfrq7lnp3imk5sx784ihsilsbjh9kvffz4"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-semigroupoids" ,ghc-semigroupoids)))
+    (inputs
+     `(("ghc-fingertree" ,ghc-fingertree)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-text" ,ghc-text)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "http://github.com/ekmett/reducers/")
+    (synopsis "Semigroups, specialized containers and a general map/reduce framework")
+    (description "This library provides various semigroups, specialized
+containers and a general map/reduce framework for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-appar
+  (package
+    (name "ghc-appar")
+    (version "0.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/appar/appar-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://hackage.haskell.org/package/appar")
+    (synopsis "Simple applicative parser")
+    (description "This package provides a simple applicative parser in Parsec
+style.")
+    (license bsd-3)))
+
+(define-public ghc-safe
+  (package
+    (name "ghc-safe")
+    (version "0.3.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/safe/safe-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/ndmitchell/safe#readme")
+    (synopsis "Library of safe (exception free) functions")
+    (description "This library provides wrappers around @code{Prelude} and
+@code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
+exceptions.")
+    (license bsd-3)))
+
+(define-public ghc-generic-deriving
+  (package
+    (name "ghc-generic-deriving")
+    (version "1.8.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/generic-deriving/generic-deriving-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/generic-deriving")
+    (synopsis "Generalise the deriving mechanism to arbitrary classes")
+    (description "This package provides functionality for generalising the
+deriving mechanism in Haskell to arbitrary classes.")
+    (license bsd-3)))
+
+(define-public ghc-pcre-light
+  (package
+    (name "ghc-pcre-light")
+    (version "0.4.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/pcre-light/pcre-light-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("pcre" ,pcre)))
+    (home-page "https://github.com/Daniel-Diaz/pcre-light")
+    (synopsis "Haskell library for Perl 5 compatible regular expressions")
+    (description "This package provides a small, efficient, and portable regex
+library for Perl 5 compatible regular expressions.  The PCRE library is a set
+of functions that implement regular expression pattern matching using the same
+syntax and semantics as Perl 5.")
+    (license bsd-3)))
+
+(define-public ghc-logict
+  (package
+    (name "ghc-logict")
+    (version "0.6.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/logict/logict-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-mtl" ,ghc-mtl)))
+    (home-page "http://code.haskell.org/~dolio/")
+    (synopsis "Backtracking logic-programming monad")
+    (description "This library provides a continuation-based, backtracking,
+logic programming monad.  An adaptation of the two-continuation implementation
+found in the paper \"Backtracking, Interleaving, and Terminating Monad
+Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
+online}.")
+    (license bsd-3)))
+
+(define-public ghc-xml
+  (package
+    (name "ghc-xml")
+    (version "1.3.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/xml/xml-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)))
+    (home-page "http://code.galois.com")
+    (synopsis "Simple XML library for Haskell")
+    (description "This package provides a simple XML library for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-exceptions
+  (package
+    (name "ghc-exceptions")
+    (version "0.8.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/exceptions/exceptions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Missing test-framework package.
+    (propagated-inputs
+     `(("ghc-stm" ,ghc-stm)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "http://github.com/ekmett/exceptions/")
+    (synopsis "Extensible optionally-pure exceptions")
+    (description "This library provides extensible optionally-pure exceptions
+for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-temporary
+  (package
+    (name "ghc-temporary")
+    (version "1.2.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/temporary/temporary-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a"))))
+    (build-system haskell-build-system)
+    (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions)))
+    (home-page "http://www.github.com/batterseapower/temporary")
+    (synopsis "Temporary file and directory support")
+    (description "The functions for creating temporary files and directories
+in the Haskelll base library are quite limited.  This library just repackages
+the Cabal implementations of its own temporary file and folder functions so
+that you can use them without linking against Cabal or depending on it being
+installed.")
+    (license bsd-3)))
+
+(define-public ghc-temporary-rc
+  (package
+    (name "ghc-temporary-rc")
+    (version "1.2.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/temporary-rc/temporary-rc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
+    (build-system haskell-build-system)
+    (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions)))
+    (home-page
+     "http://www.github.com/feuerbach/temporary")
+    (synopsis
+     "Portable temporary file and directory support")
+    (description
+     "The functions for creating temporary files and directories in the base
+library are quite limited.  The unixutils package contains some good ones, but
+they aren't portable to Windows.  This library just repackages the Cabal
+implementations of its own temporary file and folder functions so that you can
+use them without linking against Cabal or depending on it being installed.
+This is a better maintained fork of the \"temporary\" package.")
+    (license bsd-3)))
+
+(define-public ghc-smallcheck
+  (package
+    (name "ghc-smallcheck")
+    (version "1.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/smallcheck/smallcheck-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-logict" ,ghc-logict)))
+    (inputs
+     `(("ghc-mtl" ,ghc-mtl)))
+    (home-page
+     "https://github.com/feuerbach/smallcheck")
+    (synopsis "Property-based testing library")
+    (description "SmallCheck is a testing library that allows to verify
+properties for all test cases up to some depth.  The test cases are generated
+automatically by SmallCheck.")
+    (license bsd-3)))
+
+(define-public ghc-tasty-ant-xml
+  (package
+    (name "ghc-tasty-ant-xml")
+    (version "1.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-generic-deriving" ,ghc-generic-deriving)
+       ("ghc-xml" ,ghc-xml)))
+    (inputs
+     `(("ghc-mtl" ,ghc-mtl)
+       ("ghc-stm" ,ghc-stm)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-tasty" ,ghc-tasty)))
+    (home-page
+     "http://github.com/ocharles/tasty-ant-xml")
+    (synopsis
+     "Render tasty output to XML for Jenkins")
+    (description
+     "A tasty ingredient to output test results in XML, using the Ant
+schema.  This XML can be consumed by the Jenkins continuous integration
+framework.")
+    (license bsd-3)))
+
+(define-public ghc-tasty-smallcheck
+  (package
+    (name "ghc-tasty-smallcheck")
+    (version "0.8.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-async" ,ghc-async)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "SmallCheck support for the Tasty test framework")
+    (description "This package provides SmallCheck support for the Tasty
+Haskell test framework.")
+    (license bsd-3)))
+
+(define-public ghc-silently
+  (package
+    (name "ghc-silently")
+    (version "1.2.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/silently/silently-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ;; circular dependency with nanospec
+    ;; (inputs
+    ;;  `(("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://github.com/hspec/silently")
+    (synopsis "Prevent writing to stdout")
+    (description "This package provides functions to prevent or capture
+writing to stdout and other handles.")
+    (license bsd-3)))
+
+(define-public ghc-quickcheck-instances
+  (package
+    (name "ghc-quickcheck-instances")
+    (version "0.3.11")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/"
+             "quickcheck-instances/quickcheck-instances-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-text" ,ghc-text)))
+    (home-page
+     "https://github.com/aslatter/qc-instances")
+    (synopsis "Common quickcheck instances")
+    (description "This package provides QuickCheck instances for types
+provided by the Haskell Platform.")
+    (license bsd-3)))
+
+(define-public ghc-quickcheck-unicode
+  (package
+    (name "ghc-quickcheck-unicode")
+    (version "1.0.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page
+     "https://github.com/bos/quickcheck-unicode")
+    (synopsis "Generator functions Unicode-related tests")
+    (description "This package provides generator and shrink functions for
+testing Unicode-related software.")
+    (license bsd-3)))
+
+(define-public ghc-quickcheck-io
+  (package
+    (name "ghc-quickcheck-io")
+    (version "0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page
+     "https://github.com/hspec/quickcheck-io#readme")
+    (synopsis "Use HUnit assertions as QuickCheck properties")
+    (description "This package provides an orphan instance that allows you to
+use HUnit assertions as QuickCheck properties.")
+    (license expat)))
+
 (define-public ghc-quickcheck
   (package
     (name "ghc-quickcheck")
-    (version "2.8")
+    (version "2.8.1")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -833,7 +2786,7 @@ Hashing\" by Claessen, Pałka for details and the rationale of the design.")
              ".tar.gz"))
        (sha256
         (base32
-         "04xs6mq22bcnkpi616qrbm7jlivh9csnhmvjgp1ifq52an1wr4rx"))))
+         "0fvnfl30fxmj5q920l13641ar896d53z0z6z66m7c1366lvalwvh"))))
     (build-system haskell-build-system)
     (arguments
      `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
@@ -886,7 +2839,7 @@ to cases.")
 (define-public ghc-syb
   (package
     (name "ghc-syb")
-    (version "0.4.4")
+    (version "0.6")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -897,7 +2850,7 @@ to cases.")
              ".tar.gz"))
        (sha256
         (base32
-         "11sc9kmfvcn9bfxf227fgmny502z2h9xs3z0m9ak66lk0dw6f406"))))
+         "1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-hunit" ,ghc-hunit)
@@ -905,43 +2858,12 @@ to cases.")
     (home-page
      "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
     (synopsis "Scrap Your Boilerplate")
-    (description
-     "This package contains the generics system described in the
+    (description "This package contains the generics system described in the
 /Scrap Your Boilerplate/ papers (see
-<http://www.cs.uu.nl/wiki/GenericProgramming/SYB>).
-It defines the 'Data' class of types permitting folding and unfolding
-of constructor applications, instances of this class for primitive
-types, and a variety of traversals.")
-    (license bsd-3)))
-
-(define-public ghc-containers
-  (package
-    (name "ghc-containers")
-    (version "0.5.6.3")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "http://hackage.haskell.org/package/containers/containers-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1kcd55nl0vzi99i8sr8fmc5j25fv7m0a9hd3nihnq1pd64pfciqn"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-hunit" ,ghc-hunit)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
-    (arguments
-     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
-    (home-page "http://hackage.haskell.org/package/containers")
-    (synopsis "Assorted concrete container types")
-    (description
-     "This package contains efficient general-purpose implementations of
-various basic immutable container types.  The declared cost of each operation
-is either worst-case or amortized, but remains valid even if structures are
-shared.")
+@uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}).  It
+defines the 'Data' class of types permitting folding and unfolding of
+constructor applications, instances of this class for primitive types, and a
+variety of traversals.")
     (license bsd-3)))
 
 (define-public ghc-fgl
@@ -979,9 +2901,8 @@ encourages inductive, recursive definitions of graph algorithms.")
      (origin
        (method url-fetch)
        (uri (string-append
-             "http://hackage.haskell.org/package/unordered-containers/unordered-containers-"
-             version
-             ".tar.gz"))
+             "http://hackage.haskell.org/package/unordered-containers"
+             "/unordered-containers-" version ".tar.gz"))
        (sha256
         (base32
          "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
@@ -1003,6 +2924,103 @@ optimized for performance critical use, both in terms of large data quantities
 and high speed.")
     (license bsd-3)))
 
+(define-public ghc-uniplate
+  (package
+    (name "ghc-uniplate")
+    (version "1.6.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/uniplate/uniplate-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-syb" ,ghc-syb)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "http://community.haskell.org/~ndm/uniplate/")
+    (synopsis "Simple, concise and fast generic operations")
+    (description "Uniplate is a library for writing simple and concise generic
+operations.  Uniplate has similar goals to the original Scrap Your Boilerplate
+work, but is substantially simpler and faster.")
+    (license bsd-3)))
+
+(define-public ghc-base64-bytestring
+  (package
+    (name "ghc-base64-bytestring")
+    (version "1.0.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))         ; FIXME: testing libraries are missing.
+    (home-page "https://github.com/bos/base64-bytestring")
+    (synopsis "Base64 encoding and decoding for ByteStrings")
+    (description "This library provides fast base64 encoding and decoding for
+Haskell @code{ByteString}s.")
+    (license bsd-3)))
+
+(define-public ghc-annotated-wl-pprint
+  (package
+    (name "ghc-annotated-wl-pprint")
+    (version "0.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/annotated-wl-pprint"
+             "/annotated-wl-pprint-" version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://github.com/david-christiansen/annotated-wl-pprint")
+    (synopsis
+     "The Wadler/Leijen Pretty Printer, with annotation support")
+    (description "This is a modified version of wl-pprint, which was based on
+Wadler's paper \"A Prettier Printer\".  This version allows the library user
+to annotate the text with semantic information, which can later be rendered in
+a variety of ways.")
+    (license bsd-3)))
+
+(define-public ghc-ansi-wl-pprint
+  (package
+    (name "ghc-ansi-wl-pprint")
+    (version "0.6.7.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/ansi-wl-pprint/ansi-wl-pprint-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "025pyphsjf0dnbrmj5nscbi6gzyigwgp3ifxb3psn7kji6mfr29p"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
+    (home-page "http://github.com/ekmett/ansi-wl-pprint")
+    (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
+    (description "This is a pretty printing library based on Wadler's paper
+\"A Prettier Printer\".  It has been enhanced with support for ANSI terminal
+colored output using the ansi-terminal package.")
+    (license bsd-3)))
+
 (define-public ghc-split
   (package
     (name "ghc-split")
@@ -1017,15 +3035,22 @@ and high speed.")
              ".tar.gz"))
        (sha256
         (base32
-         "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))))
+         "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))
+       (modules '((guix build utils)))
+       (snippet
+        ;; The Cabal file on Hackage is updated, but the tar.gz does not
+        ;; include it.  See
+        ;; <https://hackage.haskell.org/package/split-0.2.2/revisions/>.
+        '(substitute* "split.cabal"
+           (("base <4.8") "base <4.9")))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "http://hackage.haskell.org/package/split")
-    (synopsis
-     "Combinator library for splitting lists")
-    (description "A collection of various methods for splitting lists into
-parts, akin to the 'split' function found in several mainstream languages.")
+    (synopsis "Combinator library for splitting lists")
+    (description "This package provides a collection of Haskell functions for
+splitting lists into parts, akin to the @code{split} function found in several
+mainstream languages.")
     (license bsd-3)))
 
 (define-public ghc-parsec
@@ -1063,7 +3088,7 @@ is also parametric in the input stream type.")
 (define-public ghc-vector
   (package
     (name "ghc-vector")
-    (version "0.10.12.2")
+    (version "0.11.0.0")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -1074,7 +3099,7 @@ is also parametric in the input stream type.")
              ".tar.gz"))
        (sha256
         (base32
-         "01hc71k1z9m0g0dv4zsvq5d2dvbgyc5p01hryw5c53792yi2fm25"))))
+         "1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)))
@@ -1082,17 +3107,46 @@ is also parametric in the input stream type.")
     (propagated-inputs
      `(("ghc-primitive" ,ghc-primitive)))
     (arguments
-     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+     `(#:tests? #f))      ; FIXME: currently missing libraries used for tests.
     (home-page "https://github.com/haskell/vector")
     (synopsis "Efficient Arrays")
-    (description "An efficient implementation of Int-indexed arrays (both
-mutable and immutable), with a powerful loop optimisation framework.")
-  (license bsd-3)))
+    (description "This library provides an efficient implementation of
+Int-indexed arrays (both mutable and immutable), with a powerful loop
+optimisation framework.")
+    (license bsd-3)))
+
+(define-public ghc-vector-binary-instances
+  (package
+    (name "ghc-vector-binary-instances")
+    (version "0.2.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/"
+             "vector-binary-instances/vector-binary-instances-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-cereal" ,ghc-cereal)))
+    (inputs
+     `(("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/bos/vector-binary-instances")
+    (synopsis "Instances of Data.Binary and Data.Serialize for vector")
+    (description "This library provides instances of @code{Binary} for the
+types defined in the @code{vector} package, making it easy to serialize
+vectors to and from disk.  We use the generic interface to vectors, so all
+vector types are supported.  Specific instances are provided for unboxed,
+boxed and storable vectors.")
+    (license bsd-3)))
 
 (define-public ghc-network
   (package
     (name "ghc-network")
-    (version "2.6.0.2")
+    (version "2.6.2.1")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -1103,7 +3157,7 @@ mutable and immutable), with a powerful loop optimisation framework.")
              ".tar.gz"))
        (sha256
         (base32
-         "12b7saam5ga6l4cplgkad49xa4vkynz2ri9jxidx1cxiqjcl0vc4"))))
+         "1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-hunit" ,ghc-hunit)))
@@ -1122,7 +3176,7 @@ mutable and immutable), with a powerful loop optimisation framework.")
 (define-public ghc-network-uri
   (package
     (name "ghc-network-uri")
-    (version "2.6.0.1")
+    (version "2.6.0.3")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -1133,7 +3187,7 @@ mutable and immutable), with a powerful loop optimisation framework.")
              ".tar.gz"))
        (sha256
         (base32
-         "09ymamb128jgqghpda4nixncr73all8qc6q53976aricm6a27p37"))))
+         "1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-hunit" ,ghc-hunit)
@@ -1150,10 +3204,32 @@ mutable and immutable), with a powerful loop optimisation framework.")
 package into this package.")
     (license bsd-3)))
 
+(define-public ghc-ansi-terminal
+  (package
+    (name "ghc-ansi-terminal")
+    (version "0.6.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/feuerbach/ansi-terminal")
+    (synopsis "ANSI terminal support for Haskell")
+    (description "This package provides ANSI terminal support for Haskell.  It
+allows cursor movement, screen clearing, color output showing or hiding the
+cursor, and changing the title.")
+    (license bsd-3)))
+
 (define-public ghc-http
   (package
     (name "ghc-http")
-    (version "4000.2.19")
+    (version "4000.2.20")
     (outputs '("out" "doc"))
     (source
      (origin
@@ -1164,12 +3240,13 @@ package into this package.")
              ".tar.gz"))
        (sha256
         (base32
-         "1yzm8gimh8g0wwbixcbxg60v4l3vgi63w9v55ms0x9qnm6vrgysz"))))
+         "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-hunit" ,ghc-hunit)))
     (propagated-inputs
-     `(("ghc-parsec" ,ghc-parsec)
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-parsec" ,ghc-parsec)
        ("ghc-mtl" ,ghc-mtl)
        ("ghc-network" ,ghc-network)
        ("ghc-network-uri" ,ghc-network-uri)))
@@ -1183,4 +3260,1601 @@ lets you set up HTTP connections, transmitting requests and processing the
 responses coming back.")
     (license bsd-3)))
 
+(define-public ghc-hspec
+  (package
+    (name "ghc-hspec")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hspec/hspec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-hspec-core" ,ghc-hspec-core)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)))
+    (inputs
+     `(("ghc-stringbuilder" ,ghc-stringbuilder)
+       ("ghc-hspec-meta" ,ghc-hspec-meta)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Testing Framework for Haskell")
+    (description "This library provides the Hspec testing framework for
+Haskell, inspired by the Ruby library RSpec.")
+    (license expat)))
+
+(define-public ghc-hspec-expectations
+  (package
+    (name "ghc-hspec-expectations")
+    (version "0.7.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/sol/hspec-expectations")
+    (synopsis "Catchy combinators for HUnit")
+    (description "This library provides catchy combinators for HUnit, see
+@uref{https://github.com/sol/hspec-expectations#readme, the README}.")
+    (license expat)))
+
+(define-public hspec-discover
+  (package
+    (name "hspec-discover")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hspec-discover/hspec-discover-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
+    (build-system haskell-build-system)
+    (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
+                                 ; documentation files.
+    (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Automatically discover and run Hspec tests")
+    (description "hspec-discover is a tool which automatically discovers and
+runs Hspec tests.")
+    (license expat)))
+
+(define-public ghc-hspec-core
+  (package
+    (name "ghc-hspec-core")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hspec-core/hspec-core-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (propagated-inputs
+     `(("ghc-setenv" ,ghc-setenv)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-async" ,ghc-async)
+       ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-silently" ,ghc-silently)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Testing framework for Haskell")
+    (description "This library exposes internal types and functions that can
+be used to extend Hspec's functionality.")
+    (license expat)))
+
+(define-public ghc-hspec-meta
+  (package
+    (name "ghc-hspec-meta")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hspec-meta/hspec-meta-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-async" ,ghc-async)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-setenv" ,ghc-setenv)
+       ("ghc-random" ,ghc-random)
+       ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Version of Hspec to test Hspec itself")
+    (description "This library provides a stable version of Hspec which is
+used to test the in-development version of Hspec.")
+    (license expat)))
+
+(define-public ghc-vault
+  (package
+    (name "ghc-vault")
+    (version "0.3.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/vault/vault-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-hashable" ,ghc-hashable)))
+    (home-page
+     "https://github.com/HeinrichApfelmus/vault")
+    (synopsis "Persistent store for arbitrary values")
+    (description "This package provides vaults for Haskell.  A vault is a
+persistent store for values of arbitrary types.  It's like having first-class
+access to the storage space behind @code{IORefs}.  The data structure is
+analogous to a bank vault, where you can access different bank boxes with
+different keys; hence the name.  Also provided is a @code{locker} type,
+representing a store for a single element.")
+    (license bsd-3)))
+
+(define-public ghc-mmorph
+  (package
+    (name "ghc-mmorph")
+    (version "1.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/mmorph/mmorph-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://hackage.haskell.org/package/mmorph")
+    (synopsis "Monad morphisms")
+    (description
+     "This library provides monad morphism utilities, most commonly used for
+manipulating monad transformer stacks.")
+    (license bsd-3)))
+
+(define-public ghc-monad-control
+  (package
+    (name "ghc-monad-control")
+    (version "1.0.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/monad-control"
+             "/monad-control-" version ".tar.gz"))
+       (sha256
+        (base32
+         "07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-stm" ,ghc-stm)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://github.com/basvandijk/monad-control")
+    (synopsis "Monad transformers to lift control operations like exception
+catching")
+    (description "This package defines the type class @code{MonadBaseControl},
+a subset of @code{MonadBase} into which generic control operations such as
+@code{catch} can be lifted from @code{IO} or any other base monad.")
+    (license bsd-3)))
+
+(define-public ghc-byteorder
+  (package
+    (name "ghc-byteorder")
+    (version "1.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/byteorder/byteorder-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://community.haskell.org/~aslatter/code/byteorder")
+    (synopsis
+     "Exposes the native endianness of the system")
+    (description
+     "This package is for working with the native byte-ordering of the
+system.")
+    (license bsd-3)))
+
+(define-public ghc-base-compat
+  (package
+    (name "ghc-base-compat")
+    (version "0.8.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/base-compat/base-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/base-compat")
+    (synopsis "Haskell compiler compatibility library")
+    (description "This library provides functions available in later versions
+of base to a wider range of compilers, without requiring the use of CPP
+pragmas in your code.")
+    (license bsd-3)))
+
+(define-public ghc-blaze-builder
+  (package
+    (name "ghc-blaze-builder")
+    (version "0.4.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/blaze-builder/blaze-builder-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))          ; FIXME: Missing test libraries.
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (home-page "http://github.com/lpsmith/blaze-builder")
+    (synopsis "Efficient buffered output")
+    (description "This library provides an implementation of the older
+@code{blaze-builder} interface in terms of the new builder that shipped with
+@code{bytestring-0.10.4.0}.  This implementation is mostly intended as a
+bridge to the new builder, so that code that uses the old interface can
+interoperate with code that uses the new implementation.")
+    (license bsd-3)))
+
+(define-public ghc-blaze-markup
+  (package
+    (name "ghc-blaze-markup")
+    (version "0.7.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/blaze-markup/blaze-markup-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "080vlhd8dwjxrma4bb524lh8gxs5lm3xh122icy6lnnyipla0s9y"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (propagated-inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-text" ,ghc-text)))
+    (home-page "http://jaspervdj.be/blaze")
+    (synopsis "Fast markup combinator library for Haskell")
+    (description "This library provides core modules of a markup combinator
+library for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-blaze-html
+  (package
+    (name "ghc-blaze-html")
+    (version "0.8.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/blaze-html/blaze-html-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (propagated-inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-text" ,ghc-text)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)))
+    (home-page "http://jaspervdj.be/blaze")
+    (synopsis "Fast HTML combinator library")
+    (description "This library provides HTML combinators for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-easy-file
+  (package
+    (name "ghc-easy-file")
+    (version "0.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/easy-file/easy-file-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://github.com/kazu-yamamoto/easy-file")
+    (synopsis "File handling library for Haskell")
+    (description "This library provides file handling utilities for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-async
+  (package
+    (name "ghc-async")
+    (version "2.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/async/async-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (propagated-inputs
+     `(("ghc-stm" ,ghc-stm)))
+    (home-page "https://github.com/simonmar/async")
+    (synopsis "Library to run IO operations asynchronously")
+    (description "Async provides a library to run IO operations
+asynchronously, and wait for their results. It is a higher-level interface
+over threads in Haskell, in which @code{Async a} is a concurrent thread that
+will eventually deliver a value of type @code{a}.")
+    (license bsd-3)))
+
+(define-public ghc-fingertree
+  (package
+    (name "ghc-fingertree")
+    (version "0.1.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/fingertree/fingertree-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (home-page "http://hackage.haskell.org/package/fingertree")
+    (synopsis "Generic finger-tree structure")
+    (description "This library provides finger trees, a general sequence
+representation with arbitrary annotations, for use as a base for
+implementations of various collection types.  It includes examples, as
+described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
+simple general-purpose data structure\".")
+    (license bsd-3)))
+
+(define-public ghc-optparse-applicative
+  (package
+    (name "ghc-optparse-applicative")
+    (version "0.11.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/optparse-applicative"
+             "/optparse-applicative-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
+    (home-page "https://github.com/pcapriotti/optparse-applicative")
+    (synopsis "Utilities and combinators for parsing command line options")
+    (description "This package provides utilities and combinators for parsing
+command line options in Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-base-orphans
+  (package
+    (name "ghc-base-orphans")
+    (version "0.4.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/base-orphans/base-orphans-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/base-orphans")
+    (synopsis "Orphan instances for backwards compatibility")
+    (description "This package defines orphan instances that mimic instances
+available in later versions of base to a wider (older) range of compilers.")
+    (license bsd-3)))
+
+(define-public ghc-auto-update
+  (package
+    (name "ghc-auto-update")
+    (version "0.1.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/auto-update/auto-update-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/yesodweb/wai")
+    (synopsis "Efficiently run periodic, on-demand actions")
+    (description "This library provides mechanisms to efficiently run
+periodic, on-demand actions in Haskell.")
+    (license expat)))
+
+(define-public ghc-tagged
+  (package
+    (name "ghc-tagged")
+    (version "0.8.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tagged/tagged-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/tagged")
+    (synopsis "Haskell phantom types to avoid passing dummy arguments")
+    (description "This library provides phantom types for Haskell 98, to avoid
+having to unsafely pass dummy arguments.")
+    (license bsd-3)))
+
+(define-public ghc-unbounded-delays
+  (package
+    (name "ghc-unbounded-delays")
+    (version "0.1.0.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/basvandijk/unbounded-delays")
+    (synopsis "Unbounded thread delays and timeouts")
+    (description "The @code{threadDelay} and @code{timeout} functions from the
+Haskell base library use the bounded @code{Int} type for specifying the delay
+or timeout period.  This package provides alternative functions which use the
+unbounded @code{Integer} type.")
+    (license bsd-3)))
+
+;; This package builds `clock` without tests, since the tests rely on tasty
+;; and tasty-quickcheck, which in turn require clock to build.  When tasty and
+;; tasty-quickcheck are added, we will add ghc-clock with tests enabled.
+(define ghc-clock-bootstrap
+  (package
+    (name "ghc-clock-bootstrap")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/"
+             "clock/"
+             "clock-" version ".tar.gz"))
+       (sha256
+        (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
+                               ;; tasty-quickcheck, which need clock to build.
+    (home-page "https://hackage.haskell.org/package/clock")
+    (synopsis "High-resolution clock for Haskell")
+    (description "A package for convenient access to high-resolution clock and
+timer functions of different operating systems via a unified API.")
+    (license bsd-3)))
+
+(define-public ghc-clock
+  (package
+    (name "ghc-clock")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/"
+             "clock/"
+             "clock-" version ".tar.gz"))
+       (sha256
+        (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/clock")
+    (synopsis "High-resolution clock for Haskell")
+    (description "A package for convenient access to high-resolution clock and
+timer functions of different operating systems via a unified API.")
+    (license bsd-3)))
+
+(define-public ghc-charset
+  (package
+    (name "ghc-charset")
+    (version "0.3.7.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/charset/charset-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-semigroups" ,ghc-semigroups)))
+    (inputs
+     `(("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "http://github.com/ekmett/charset")
+    (synopsis "Fast unicode character sets for Haskell")
+    (description "This package provides fast unicode character sets for
+Haskell, based on complemented PATRICIA tries.")
+    (license bsd-3)))
+
+(define-public ghc-bytestring-builder
+  (package
+    (name "ghc-bytestring-builder")
+    (version "0.10.6.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/bytestring-builder"
+             "/bytestring-builder-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww"))))
+    (build-system haskell-build-system)
+    (arguments `(#:haddock? #f)) ; Package contains no documentation.
+    (home-page "http://hackage.haskell.org/package/bytestring-builder")
+    (synopsis "The new bytestring builder, packaged outside of GHC")
+    (description "This package provides the bytestring builder that is
+debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
+Compatibility package for older packages.")
+    (license bsd-3)))
+
+(define-public ghc-nats
+  (package
+    (name "ghc-nats")
+    (version "1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/nats/nats-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0"))))
+    (build-system haskell-build-system)
+    (arguments `(#:haddock? #f))
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)))
+    (home-page "https://hackage.haskell.org/package/nats")
+    (synopsis "Natural numbers")
+    (description "This library provides the natural numbers for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-void
+  (package
+    (name "ghc-void")
+    (version "0.7.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/void/void-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-semigroups" ,ghc-semigroups)))
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)))
+    (home-page "http://github.com/ekmett/void")
+    (synopsis
+     "Logically uninhabited data type")
+    (description
+     "A Haskell 98 logically uninhabited data type, used to indicate that a
+given term should not exist.")
+    (license bsd-3)))
+
+(define-public ghc-kan-extensions
+  (package
+    (name "ghc-kan-extensions")
+    (version "4.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/kan-extensions/kan-extensions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0iywbadpy8s3isfzlx9dlz3apaywhqq4gdbxkwygksq8pzdhwkrk"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-adjunctions" ,ghc-adjunctions)))
+    (inputs
+     `(("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-free" ,ghc-free)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page "http://github.com/ekmett/kan-extensions/")
+    (synopsis "Kan extensions library")
+    (description "This library provides Kan extensions, Kan lifts, various
+forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-statevar
+  (package
+    (name "ghc-statevar")
+    (version "1.1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/StateVar/StateVar-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-stm" ,ghc-stm)))
+    (home-page "http://hackage.haskell.org/package/StateVar")
+    (synopsis "State variables for Haskell")
+    (description "This package provides state variables, which are references
+in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
+    (license bsd-3)))
+
+(define-public ghc-lens
+  (package
+    (name "ghc-lens")
+    (version "4.13")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/lens/lens-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0g4g0xksrb2m8wgsmraaq8qnk1sssb42kr65fc7clgyid6zyfmim"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
+    (propagated-inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-free" ,ghc-free)
+       ("ghc-kan-extensions" ,ghc-kan-extensions)
+       ("ghc-parallel" ,ghc-parallel)
+       ("ghc-reflection" ,ghc-reflection)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-vector" ,ghc-vector)))
+    (inputs
+     `(("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-text" ,ghc-text)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-void" ,ghc-void)
+       ("ghc-generic-deriving" ,ghc-generic-deriving)
+       ("ghc-nats" ,ghc-nats)
+       ("ghc-simple-reflect" ,ghc-simple-reflect)
+       ("hlint" ,hlint)))
+    (home-page "http://github.com/ekmett/lens/")
+    (synopsis "Lenses, Folds and Traversals")
+    (description "This library provides @code{Control.Lens}.  The combinators
+in @code{Control.Lens} provide a highly generic toolbox for composing families
+of getters, folds, isomorphisms, traversals, setters and lenses and their
+indexed variants.")
+    (license bsd-3)))
+
+(define-public ghc-tagsoup
+  (package
+    (name "ghc-tagsoup")
+    (version "0.13.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tagsoup/tagsoup-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-text" ,ghc-text)))
+    (home-page
+     "http://community.haskell.org/~ndm/tagsoup/")
+    (synopsis
+     "Parsing and extracting information from (possibly malformed) HTML/XML
+documents")
+    (description
+     "TagSoup is a library for parsing HTML/XML.  It supports the HTML 5
+specification, and can be used to parse either well-formed XML, or
+unstructured and malformed HTML from the web.  The library also provides
+useful functions to extract information from an HTML document, making it ideal
+for screen-scraping.")
+    (license bsd-3)))
+
+(define-public ghc-digest
+  (package
+    (name "ghc-digest")
+    (version "0.0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/digest/digest-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("zlib" ,zlib)))
+    (home-page
+     "http://hackage.haskell.org/package/digest")
+    (synopsis
+     "Various cryptographic hashes for bytestrings")
+    (description
+     "This package provides efficient cryptographic hash implementations for
+strict and lazy bytestrings.  For now, CRC32 and Adler32 are supported; they
+are implemented as FFI bindings to efficient code from zlib.")
+    (license bsd-3)))
+
+(define-public ghc-cheapskate
+  (package
+    (name "ghc-cheapskate")
+    (version "0.1.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/cheapskate/cheapskate-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-xss-sanitize" ,ghc-xss-sanitize)
+       ("ghc-data-default" ,ghc-data-default)))
+    (inputs
+     `(("ghc-mtl" ,ghc-mtl)
+       ("ghc-text" ,ghc-text)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-uniplate" ,ghc-uniplate)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-wai-extra" ,ghc-wai-extra)
+       ("ghc-wai" ,ghc-wai)
+       ("ghc-http-types" ,ghc-http-types)))
+    (home-page "http://github.com/jgm/cheapskate")
+    (synopsis "Experimental markdown processor")
+    (description "Cheapskate is an experimental Markdown processor in pure
+Haskell.  It aims to process Markdown efficiently and in the most forgiving
+possible way.  It is designed to deal with any input, including garbage, with
+linear performance.  Output is sanitized by default for protection against XSS
+attacks.")
+    (license bsd-3)))
+
+(define-public ghc-bifunctors
+  (package
+    (name "ghc-bifunctors")
+    (version "5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/bifunctors/bifunctors-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tagged" ,ghc-tagged)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "http://github.com/ekmett/bifunctors/")
+    (synopsis "Bifunctors for Haskell")
+    (description "This package provides bifunctors for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-semigroupoids
+  (package
+    (name "ghc-semigroupoids")
+    (version "5.0.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/semigroupoids/semigroupoids-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1jf7jnfhdvl6p18wdr21yi2fim1xb8alcn6szhrdswj0dkilgq6d"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)))
+    (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page "http://github.com/ekmett/semigroupoids")
+    (synopsis "Semigroupoids operations for Haskell")
+    (description "This library provides a wide array of (semi)groupoids and
+operations for working with them.  A @code{Semigroupoid} is a @code{Category}
+without the requirement of identity arrows for every object in the category.
+A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
+Finally, to work with these weaker structures it is beneficial to have
+containers that can provide stronger guarantees about their contents, so
+versions of @code{Traversable} and @code{Foldable} that can be folded with
+just a @code{Semigroup} are added.")
+    (license bsd-3)))
+
+(define-public ghc-contravariant
+  (package
+    (name "ghc-contravariant")
+    (version "1.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/contravariant/contravariant-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "184hcmhsznqrkmqlc1kza9pb5p591anva574ry8wrh81vqmhwfb5"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-void" ,ghc-void)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-statevar" ,ghc-statevar)))
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)))
+    (home-page
+     "http://github.com/ekmett/contravariant/")
+    (synopsis "Contravariant functors")
+    (description "Contravariant functors for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-semigroups
+  (package
+    (name "ghc-semigroups")
+    (version "0.17.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/semigroups/semigroups-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0gvpfi7s6ys4qha3y9a1zl1a15gf9cgg33wjb94ghg82ivcxnc3r"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-nats" ,ghc-nats)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-hashable" ,ghc-hashable)))
+    (home-page "http://github.com/ekmett/semigroups/")
+    (synopsis "Semigroup operations for Haskell")
+    (description "This package provides semigroups for Haskell.  In
+mathematics, a semigroup is an algebraic structure consisting of a set
+together with an associative binary operation.  A semigroup generalizes a
+monoid in that there might not exist an identity element.  It
+also (originally) generalized a group (a monoid with all inverses) to a type
+where every element did not have to have an inverse, thus the name
+semigroup.")
+    (license bsd-3)))
+
+(define-public ghc-free
+  (package
+    (name "ghc-free")
+    (version "4.12.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/free/free-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-prelude-extras" ,ghc-prelude-extras)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-exceptions" ,ghc-exceptions)))
+    (inputs
+     `(("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "http://github.com/ekmett/free/")
+    (synopsis "Unrestricted monads for Haskell")
+    (description "This library provides free monads, which are useful for many
+tree-like structures and domain specific languages.  If @code{f} is a
+@code{Functor} then the free @code{Monad} on @code{f} is the type of trees
+whose nodes are labeled with the constructors of @code{f}.  The word \"free\"
+is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
+f} makes no constraining assumptions beyond those given by @code{f} and the
+definition of @code{Monad}.")
+    (license bsd-3)))
+
+(define-public ghc-adjunctions
+  (package
+    (name "ghc-adjunctions")
+    (version "4.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/adjunctions/adjunctions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "00p030iypjzjib8pxz1x6mxfi59wvyrwjj11zv9bh766dgkdbwjq"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-profunctors" ,ghc-profunctors)))
+    (inputs
+     `(("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-free" ,ghc-free)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-void" ,ghc-void)))
+    (home-page "http://github.com/ekmett/adjunctions/")
+    (synopsis "Adjunctions and representable functors")
+    (description "This library provides adjunctions and representable functors
+for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-fast-logger
+  (package
+    (name "ghc-fast-logger")
+    (version "2.4.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/fast-logger/fast-logger-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0kjk1861qcls8m8y7i55msfpprws5wk6c5mxzi35g2qbl2sih4p5"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-auto-update" ,ghc-auto-update)))
+    (inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-text" ,ghc-text)))
+    (home-page "https://hackage.haskell.org/package/fast-logger")
+    (synopsis "Fast logging system")
+    (description "This library provides a fast logging system for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-doctest
+  (package
+    (name "ghc-doctest")
+    (version "0.10.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/doctest/doctest-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))          ; FIXME: missing test framework
+    (propagated-inputs
+     `(("ghc-syb" ,ghc-syb)
+       ("ghc-paths" ,ghc-paths)))
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-stringbuilder" ,ghc-stringbuilder)
+       ("ghc-silently" ,ghc-silently)
+       ("ghc-setenv" ,ghc-setenv)))
+    (home-page
+     "https://github.com/sol/doctest#readme")
+    (synopsis "Test interactive Haskell examples")
+    (description "The doctest program checks examples in source code comments.
+It is modeled after doctest for Python, see
+@uref{http://docs.python.org/library/doctest.html, the Doctest website}.")
+    (license expat)))
+
+(define-public ghc-lifted-base
+  (package
+    (name "ghc-lifted-base")
+    (version "0.2.3.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/lifted-base/lifted-base-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
+    (propagated-inputs
+     `(("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-monad-control" ,ghc-monad-control)))
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/basvandijk/lifted-base")
+    (synopsis "Lifted IO operations from the base library")
+    (description "Lifted-base exports IO operations from the @code{base}
+library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
+Note that not all modules from @code{base} are converted yet.  The package
+includes a copy of the @code{monad-peel} test suite written by Anders
+Kaseorg.")
+    (license bsd-3)))
+
+(define-public ghc-word8
+  (package
+    (name "ghc-word8")
+    (version "0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/word8/word8-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "http://hackage.haskell.org/package/word8")
+    (synopsis "Word8 library for Haskell")
+    (description "Word8 library to be used with @code{Data.ByteString}.")
+    (license bsd-3)))
+
+(define-public ghc-stringsearch
+  (package
+    (name "ghc-stringsearch")
+    (version "0.3.6.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/stringsearch/stringsearch-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
+    (build-system haskell-build-system)
+    (home-page "https://bitbucket.org/dafis/stringsearch")
+    (synopsis "Fast searching, splitting and replacing of ByteStrings")
+    (description "This package provides several functions to quickly search
+for substrings in strict or lazy @code{ByteStrings}.  It also provides
+functions for breaking or splitting on substrings and replacing all
+occurrences of a substring (the first in case of overlaps) with another.")
+    (license bsd-3)))
+
+(define-public ghc-tasty-quickcheck
+  (package
+    (name "ghc-tasty-quickcheck")
+    (version "0.8.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tasty-quickcheck/"
+             "tasty-quickcheck-" version ".tar.gz"))
+       (sha256
+        (base32
+         "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (inputs
+     `(("ghc-tagged" ,ghc-tagged)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-random" ,ghc-random)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-pcre-light" ,ghc-pcre-light)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "QuickCheck support for the Tasty test framework")
+    (description "This package provides QuickCheck support for the Tasty
+Haskell test framework.")
+    (license expat)))
+
+(define-public ghc-tasty-golden
+  (package
+    (name "ghc-tasty-golden")
+    (version "2.3.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tasty-golden/tasty-golden-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-temporary" ,ghc-temporary)))
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-async" ,ghc-async)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-temporary-rc" ,ghc-temporary-rc)))
+    (home-page
+     "https://github.com/feuerbach/tasty-golden")
+    (synopsis "Golden tests support for tasty")
+    (description
+     "This package provides support for 'golden testing'.  A golden test is an
+IO action that writes its result to a file.  To pass the test, this output
+file should be identical to the corresponding 'golden' file, which contains
+the correct result for the test.")
+    (license expat)))
+
+(define-public ghc-tasty
+  (package
+    (name "ghc-tasty")
+    (version "0.11.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tasty/tasty-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-stm" ,ghc-stm)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-unbounded-delays" ,ghc-unbounded-delays)
+       ("ghc-async" ,ghc-async)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "Modern and extensible testing framework")
+    (description "Tasty is a modern testing framework for Haskell.  It lets
+you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
+and any other types of tests into a single test suite.")
+    (license expat)))
+
+(define-public ghc-tasty-hunit
+  (package
+    (name "ghc-tasty-hunit")
+    (version "0.9.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "HUnit support for the Tasty test framework")
+    (description "This package provides HUnit support for the Tasty Haskell
+test framework.")
+    (license expat)))
+
+(define-public ghc-cookie
+  (package
+    (name "ghc-cookie")
+    (version "0.4.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/cookie/cookie-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-old-locale" ,ghc-old-locale)))
+    (inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-text" ,ghc-text)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "http://github.com/snoyberg/cookie")
+    (synopsis "HTTP cookie parsing and rendering")
+    (description "HTTP cookie parsing and rendering library for Haskell.")
+    (license bsd-3)))
+
+(define-public ghc-scientific
+  (package
+    (name "ghc-scientific")
+    (version "0.3.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/scientific/scientific-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0mimdkva0cgzaychr6whv9if29z0r5wwhkss9bmd4rz8kq1kgngn"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-vector" ,ghc-vector)))
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/basvandijk/scientific")
+    (synopsis "Numbers represented using scientific notation")
+    (description "This package provides @code{Data.Scientific}, which provides
+the number type @code{Scientific}.  Scientific numbers are arbitrary precision
+and space efficient.  They are represented using
+@uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific
+notation}.")
+    (license bsd-3)))
+
+(define-public ghc-aeson
+  (package
+    (name "ghc-aeson")
+    (version "0.10.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/aeson/aeson-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (propagated-inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-dlist" ,ghc-dlist)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-vector" ,ghc-vector)))
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-text" ,ghc-text)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/bos/aeson")
+    (synopsis "Fast JSON parsing and encoding")
+    (description "This package provides a JSON parsing and encoding library
+for Haskell, optimized for ease of use and high performance.  (A note on
+naming: in Greek mythology, Aeson was the father of Jason.)")
+    (license bsd-3)))
+
+(define-public ghc-wai
+  (package
+    (name "ghc-wai")
+    (version "3.0.4.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/wai/wai-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1551n0g0n22vml33v0jz5xgjcy6j79algvsdqg11a1z5ljjrjlqf"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-vault" ,ghc-vault)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-network" ,ghc-network)))
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-text" ,ghc-text)
+       ("ghc-http-types" ,ghc-http-types)))
+    (home-page "https://hackage.haskell.org/package/wai")
+    (synopsis "Web application interface for Haskell")
+    (description "This package provides a Web Application Interface (WAI)
+library for the Haskell language.  It defines a common protocol for
+communication between web applications and web servers.")
+    (license bsd-3)))
+
+(define-public ghc-wai-logger
+  (package
+    (name "ghc-wai-logger")
+    (version "2.2.4.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/wai-logger/wai-logger-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
+                               ; by propagated-inputs.
+    (propagated-inputs
+     `(("ghc-auto-update" ,ghc-auto-update)
+       ("ghc-byteorder" ,ghc-byteorder)
+       ("ghc-easy-file" ,ghc-easy-file)
+       ("ghc-unix-time" ,ghc-unix-time)))
+    (inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-network" ,ghc-network)
+       ("ghc-wai" ,ghc-wai)))
+    (home-page "http://hackage.haskell.org/package/wai-logger")
+    (synopsis "Logging system for WAI")
+    (description "This package provides the logging system for WAI.")
+    (license bsd-3)))
+
+(define-public ghc-wai-extra
+  (package
+    (name "ghc-wai-extra")
+    (version "3.0.11.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/wai-extra/wai-extra-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1kr2s5qyx1dvnwr372h7pca4sgxjv0pdx96xkgsfi180h3mb0vq8"))))
+    (build-system haskell-build-system)
+    (propagated-inputs
+     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-cookie" ,ghc-cookie)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-stringsearch" ,ghc-stringsearch)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-wai-logger" ,ghc-wai-logger)
+       ("ghc-zlib" ,ghc-zlib)
+       ("ghc-word8" ,ghc-word8)
+       ("ghc-iproute" ,ghc-iproute)
+       ("ghc-void" ,ghc-void)))
+    (inputs
+     `(("ghc-wai" ,ghc-wai)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-text" ,ghc-text)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-vault" ,ghc-vault)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "http://github.com/yesodweb/wai")
+    (synopsis "Some basic WAI handlers and middleware")
+    (description "This library provides basic WAI handlers and middleware
+functionality.")
+    (license expat)))
+
+(define-public idris
+  (package
+    (name "idris")
+    (version "0.9.19.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/idris-"
+                           version "/idris-" version ".tar.gz"))
+       (sha256
+        (base32
+         "10641svdsjlxbxmbvylpia04cz5nn9486lpiay8ibqcrc1792qgc"))
+       (modules '((guix build utils)))
+       (snippet
+        '(substitute* "idris.cabal"
+           ;; Package description file has a too-tight version restriction,
+           ;; rendering it incompatible with GHC 7.10.2.  This is fixed
+           ;; upstream.  See
+           ;; <https://github.com/idris-lang/Idris-dev/issues/2734>.
+           (("vector < 0.11") "vector < 0.12")))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases (modify-phases %standard-phases
+                  (add-before 'configure 'patch-cc-command
+                              (lambda _
+                                (setenv "CC" "gcc"))))))
+    (inputs
+     `(("gmp" ,gmp)
+       ("ncurses" ,ncurses)
+       ("ghc-annotated-wl-pprint" ,ghc-annotated-wl-pprint)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)
+       ("ghc-cheapskate" ,ghc-cheapskate)
+       ("ghc-fingertree" ,ghc-fingertree)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-network" ,ghc-network)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-parsers" ,ghc-parsers)
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-split" ,ghc-split)
+       ("ghc-text" ,ghc-text)
+       ("ghc-trifecta" ,ghc-trifecta)
+       ("ghc-uniplate" ,ghc-uniplate)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-zip-archive" ,ghc-zip-archive)
+       ("ghc-zlib" ,ghc-zlib)))
+    (home-page "http://www.idris-lang.org")
+    (synopsis "General purpose language with full dependent types")
+    (description "Idris is a general purpose language with full dependent
+types.  It is compiled, with eager evaluation.  Dependent types allow types to
+be predicated on values, meaning that some aspects of a program's behaviour
+can be specified precisely in the type.  The language is closely related to
+Epigram and Agda.")
+    (license bsd-3)))
+
 ;;; haskell.scm ends here
diff --git a/gnu/packages/less.scm b/gnu/packages/less.scm
index a1914b6953..efdf8ab0c4 100644
--- a/gnu/packages/less.scm
+++ b/gnu/packages/less.scm
@@ -26,7 +26,7 @@
 (define-public less
   (package
     (name "less")
-    (version "451")
+    (version "481")
     (source
      (origin
       (method url-fetch)
@@ -34,7 +34,7 @@
                           version ".tar.gz"))
       (sha256
        (base32
-        "0mszdd9m1dsbg59pav62swg9f87xmjpfspcw2jsazzksciy2is4z"))))
+        "19fxj0h10y5bhr3a1xa7kqvnwl44db3sdypz8jxl1q79yln8z8rz"))))
     (build-system gnu-build-system)
     (inputs `(("ncurses" ,ncurses)))
     (home-page "https://www.gnu.org/software/less/")
diff --git a/gnu/packages/linux.scm b/gnu/packages/linux.scm
index 2c2ebab2e4..ecb0fd090b 100644
--- a/gnu/packages/linux.scm
+++ b/gnu/packages/linux.scm
@@ -210,7 +210,7 @@ for SYSTEM, or #f if there is no configuration for SYSTEM."
      #f)))
 
 (define-public linux-libre
-  (let* ((version "4.2.3")
+  (let* ((version "4.2.4")
          (build-phase
           '(lambda* (#:key system inputs #:allow-other-keys #:rest args)
              ;; Apply the neat patch.
@@ -283,7 +283,7 @@ for SYSTEM, or #f if there is no configuration for SYSTEM."
              (uri (linux-libre-urls version))
              (sha256
               (base32
-               "1xpx32k6bzxqg5y8lyaana97jjcli00iyqklh5fdhirfvjb9dimd"))))
+               "11r9yhi4c2zwfb8i21zk014gcm1kvnabq410wjy6g6a015d5v37w"))))
     (build-system gnu-build-system)
     (native-inputs `(("perl" ,perl)
                      ("bc" ,bc)
diff --git a/gnu/packages/man.scm b/gnu/packages/man.scm
index 31598d0168..46b7d8b9b0 100644
--- a/gnu/packages/man.scm
+++ b/gnu/packages/man.scm
@@ -162,7 +162,7 @@ Linux kernel and C library interfaces employed by user-space programs.")
 (define-public help2man
   (package
     (name "help2man")
-    (version "1.47.1")
+    (version "1.47.2")
     (source
      (origin
       (method url-fetch)
@@ -170,7 +170,7 @@ Linux kernel and C library interfaces employed by user-space programs.")
                           version ".tar.xz"))
       (sha256
        (base32
-        "01ib718afwc28bmh1n0p5h7245vs3rrfm7bj1sq4avmh1kv2d6y5"))))
+        "0z1zgw6k1fba59fii6ksfi1g2gci6i4ysa3kdfh3j475fdkn1if4"))))
     (build-system gnu-build-system)
     (arguments `(;; There's no `check' target.
                  #:tests? #f))
diff --git a/gnu/packages/music.scm b/gnu/packages/music.scm
index a72f7543dd..c693f0faf0 100644
--- a/gnu/packages/music.scm
+++ b/gnu/packages/music.scm
@@ -1,5 +1,6 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -33,6 +34,7 @@
   #:use-module (gnu packages base) ;libbdf
   #:use-module (gnu packages boost)
   #:use-module (gnu packages bison)
+  #:use-module (gnu packages cdrom)
   #:use-module (gnu packages code)
   #:use-module (gnu packages check)
   #:use-module (gnu packages compression)
@@ -55,6 +57,7 @@
   #:use-module (gnu packages linux) ; for alsa-utils
   #:use-module (gnu packages man)
   #:use-module (gnu packages mp3)
+  #:use-module (gnu packages ncurses)
   #:use-module (gnu packages netpbm)
   #:use-module (gnu packages pdf)
   #:use-module (gnu packages perl)
@@ -67,6 +70,7 @@
   #:use-module (gnu packages tcl)
   #:use-module (gnu packages texinfo)
   #:use-module (gnu packages texlive)
+  #:use-module (gnu packages video)
   #:use-module (gnu packages web)
   #:use-module (gnu packages xml)
   #:use-module (gnu packages xorg)
@@ -74,6 +78,67 @@
   #:use-module (gnu packages zip)
   #:use-module ((srfi srfi-1) #:select (last)))
 
+(define-public cmus
+  (package
+    (name "cmus")
+    (version "2.7.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://github.com/" name "/" name "/archive/v"
+                    version ".tar.gz"))
+              (file-name (string-append name "-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0raixgjavkm7hxppzsc5zqbfbh2bhjcmbiplhnsxsmyj8flafyc1"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:tests? #f ; cmus does not include tests
+       #:phases
+       (modify-phases %standard-phases
+         (replace
+          'configure
+          (lambda* (#:key outputs #:allow-other-keys)
+            (let ((out (assoc-ref outputs "out")))
+
+              ;; It's an idiosyncratic configure script that doesn't
+              ;; understand --prefix=..; it wants prefix=.. instead.
+              (zero?
+               (system* "./configure"
+                        (string-append "prefix=" out)))))))))
+    ;; TODO: cmus optionally supports the following formats, which haven't yet
+    ;; been added to Guix:
+    ;;
+    ;; - Roar, libroar
+    ;;
+    ;; - DISCID_LIBS, apparently different from cd-discid which is included in
+    ;;   Guix.  See <http://sourceforge.net/projects/discid/>
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (inputs
+     `(("alsa-lib" ,alsa-lib)
+       ("ao" ,ao)
+       ("ffmpeg" ,ffmpeg)
+       ("flac" ,flac)
+       ("jack" ,jack-1)
+       ("libcddb" ,libcddb)
+       ("libcdio-paranoia" ,libcdio-paranoia)
+       ("libcue" ,libcue)
+       ("libmad" ,libmad)
+       ("libmodplug" ,libmodplug)
+       ("libmpcdec" ,libmpcdec)
+       ("libsamplerate" ,libsamplerate)
+       ("libvorbis" ,libvorbis)
+       ("ncurses" ,ncurses)
+       ("opusfile" ,opusfile)
+       ("pulseaudio" ,pulseaudio)
+       ("wavpack" ,wavpack)))
+     (home-page "https://cmus.github.io/")
+     (synopsis "Small console music player")
+     (description "Cmus is a small and fast console music player.  It supports
+many input formats and provides a customisable Vi-style user interface.")
+     (license license:gpl2+)))
+
 (define-public hydrogen
   (package
     (name "hydrogen")
diff --git a/gnu/packages/ntp.scm b/gnu/packages/ntp.scm
index a53d98efdd..9e6db67e3e 100644
--- a/gnu/packages/ntp.scm
+++ b/gnu/packages/ntp.scm
@@ -35,7 +35,7 @@
 (define-public ntp
   (package
    (name "ntp")
-   (version "4.2.8p3")
+   (version "4.2.8p4")
    (source (origin
 	    (method url-fetch)
 	    (uri (string-append
@@ -44,7 +44,7 @@
                   "/ntp-" version ".tar.gz"))
 	    (sha256
 	     (base32
-	      "13zkzcvjm5kbxl4xbcmaq07slplhmpkgahzcqnqlba3cxpra9341"))
+	      "1fgxbhv0wyiivi6kh5zpzrd0yqmc48z7d3zmjspw9lj84mbn2s8d"))
             (modules '((guix build utils)))
             (snippet
              '(begin
diff --git a/gnu/packages/patches/evilwm-lost-focus-bug.patch b/gnu/packages/patches/evilwm-lost-focus-bug.patch
new file mode 100644
index 0000000000..af24af8fe9
--- /dev/null
+++ b/gnu/packages/patches/evilwm-lost-focus-bug.patch
@@ -0,0 +1,18 @@
+evilwm may sometimes lose focus after closing a window.  This means that
+evilwm stops responding to keyboard shortcuts, and if no other window is open
+which the mouse can be moved over to regain focus evilwm becomes unusable and
+has to be restarted.
+
+Patch derived from discussion at
+https://wiki.archlinux.org/index.php/Evilwm#Lost_focus_bug_fix
+
+--- evilwm-1.1.1/client.c
++++ evilwm-1.1.1/client.c
+@@ -172,6 +172,7 @@
+ 	 *  _NET_WM_STATE) */
+ 	if (c->remove) {
+ 		LOG_DEBUG("setting WithdrawnState\n");
++		XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
+ 		set_wm_state(c, WithdrawnState);
+ 		ewmh_withdraw_client(c);
+ 	} else {
diff --git a/gnu/packages/python.scm b/gnu/packages/python.scm
index 9db578ed96..54d882cb6e 100644
--- a/gnu/packages/python.scm
+++ b/gnu/packages/python.scm
@@ -3060,6 +3060,43 @@ that client code uses to construct the grammar directly in Python code.")
 (define-public python2-numpydoc
   (package-with-python2 python-numpydoc))
 
+(define-public python-numexpr
+  (package
+    (name "python-numexpr")
+    (version "2.4.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://pypi.python.org/packages/source/"
+                           "n/numexpr/numexpr-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0nsnff5312fm38w6dm34bw7ghfqqy8vl9gig0al963h4mz8zm8nz"))))
+    (build-system python-build-system)
+    (arguments `(#:tests? #f))          ; no tests included
+    (propagated-inputs
+     `(("python-numpy" ,python-numpy)))
+    (home-page "https://github.com/pydata/numexpr")
+    (synopsis "Fast numerical expression evaluator for NumPy")
+    (description
+     "Numexpr is a fast numerical expression evaluator for NumPy.  With it,
+expressions that operate on arrays are accelerated and use less memory than
+doing the same calculation in Python.  In addition, its multi-threaded
+capabilities can make use of all your cores, which may accelerate
+computations, most specially if they are not memory-bounded (e.g. those using
+transcendental functions).")
+    (license license:expat)))
+
+(define-public python2-numexpr
+  (let ((numexpr (package-with-python2 python-numexpr)))
+    (package (inherit numexpr)
+      ;; Make sure to use special packages for Python 2 instead
+      ;; of those automatically rewritten by package-with-python2.
+      (propagated-inputs
+       `(("python2-numpy" ,python2-numpy)
+         ,@(alist-delete "python-numpy"
+                         (package-propagated-inputs numexpr)))))))
+
 (define-public python-matplotlib
   (package
     (name "python-matplotlib")
diff --git a/gnu/packages/statistics.scm b/gnu/packages/statistics.scm
index f854a44d96..0c0464c2b9 100644
--- a/gnu/packages/statistics.scm
+++ b/gnu/packages/statistics.scm
@@ -24,6 +24,7 @@
   #:use-module (guix utils)
   #:use-module (guix build-system gnu)
   #:use-module (guix build-system r)
+  #:use-module (guix build-system python)
   #:use-module (gnu packages)
   #:use-module (gnu packages compression)
   #:use-module (gnu packages gcc)
@@ -35,11 +36,14 @@
   #:use-module (gnu packages pcre)
   #:use-module (gnu packages perl)
   #:use-module (gnu packages pkg-config)
+  #:use-module (gnu packages python)
   #:use-module (gnu packages readline)
   #:use-module (gnu packages texlive)
   #:use-module (gnu packages texinfo)
   #:use-module (gnu packages base)
-  #:use-module (gnu packages xorg))
+  #:use-module (gnu packages xorg)
+  #:use-module (gnu packages zip)
+  #:use-module (srfi srfi-1))
 
 (define-public r
   (package
@@ -933,3 +937,119 @@ times.")
 large data (e.g. 100GB in RAM), fast ordered joins, fast add/modify/delete of
 columns by group, column listing and fast file reading.")
     (license license:gpl2+)))
+
+(define-public python-patsy
+  (package
+    (name "python-patsy")
+    (version "0.4.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://pypi.python.org/packages/source/"
+                                  "p/patsy/patsy-" version ".zip"))
+              (sha256
+               (base32
+                "1kbs996xc2haxalmhd19rr1wh5fa4gbbxf81czkf5w4kam7h7wz4"))))
+    (build-system python-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (replace 'check (lambda _ (zero? (system* "nosetests" "-v"))))
+         (add-after 'unpack 'prevent-generation-of-egg-archive
+          (lambda _
+            (substitute* "setup.py"
+              (("from setuptools import setup")
+               "from distutils.core import setup"))
+            #t)))))
+    (propagated-inputs
+     `(("python-numpy" ,python-numpy)
+       ("python-scipy" ,python-scipy)
+       ("python-six" ,python-six)))
+    (native-inputs
+     `(("python-nose" ,python-nose)
+       ("unzip" ,unzip)))
+    (home-page "https://github.com/pydata/patsy")
+    (synopsis "Describe statistical models and build design matrices")
+    (description
+     "Patsy is a Python package for describing statistical models and for
+building design matrices.")
+    ;; The majority of the code is distributed under BSD-2.  The module
+    ;; patsy.compat contains code derived from the Python standard library,
+    ;; and is covered by the PSFL.
+    (license (list license:bsd-2 license:psfl))))
+
+(define-public python2-patsy
+  (let ((patsy (package-with-python2 python-patsy)))
+    (package (inherit patsy)
+      (native-inputs
+       `(("python2-setuptools" ,python2-setuptools)
+         ,@(package-native-inputs patsy)))
+      (propagated-inputs
+       `(("python2-numpy" ,python2-numpy)
+         ("python2-scipy" ,python2-scipy)
+         ,@(alist-delete "python-numpy"
+                         (alist-delete "python-scipy"
+                                       (package-propagated-inputs patsy))))))))
+
+(define-public python-statsmodels
+  (package
+    (name "python-statsmodels")
+    (version "0.6.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://pypi.python.org/packages/source/"
+                           "s/statsmodels/statsmodels-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0xn67sqr0cc1lmlhzm71352hrb4hw7g318p5ff5q97pc98vl8kmy"))))
+    (build-system python-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         ;; tests must be run after installation
+         (delete 'check)
+         (add-after 'unpack 'set-matplotlib-backend-to-agg
+          (lambda _
+            ;; Set the matplotlib backend to Agg to avoid problems using the
+            ;; GTK backend without a display.
+            (substitute* (find-files "statsmodels/graphics/tests" "\\.py")
+              (("import matplotlib\\.pyplot as plt" line)
+               (string-append "import matplotlib;matplotlib.use('Agg');"
+                              line)))
+            #t))
+         (add-after 'install 'check
+          (lambda _
+            (with-directory-excursion "/tmp"
+              (zero? (system* "nosetests"
+                              "--stop"
+                              "-v" "statsmodels"))))))))
+    (propagated-inputs
+     `(("python-numpy" ,python-numpy)
+       ("python-scipy" ,python-scipy)
+       ("python-pandas" ,python-pandas)
+       ("python-patsy" ,python-patsy)
+       ("python-matplotlib" ,python-matplotlib)))
+    (native-inputs
+     `(("python-cython" ,python-cython)
+       ("python-nose" ,python-nose)
+       ("python-sphinx" ,python-sphinx)))
+    (home-page "http://statsmodels.sourceforge.net/")
+    (synopsis "Statistical modeling and econometrics in Python")
+    (description
+     "Statsmodels is a Python package that provides a complement to scipy for
+statistical computations including descriptive statistics and estimation and
+inference for statistical models.")
+    (license license:bsd-3)))
+
+(define-public python2-statsmodels
+  (let ((stats (package-with-python2 python-statsmodels)))
+    (package (inherit stats)
+      (propagated-inputs
+       `(("python2-numpy" ,python2-numpy)
+         ("python2-scipy" ,python2-scipy)
+         ("python2-pandas" ,python2-pandas)
+         ("python2-patsy" ,python2-patsy)
+         ("python2-matplotlib" ,python2-matplotlib)))
+      (native-inputs
+       `(("python2-setuptools" ,python2-setuptools)
+         ,@(package-native-inputs stats))))))
diff --git a/gnu/packages/video.scm b/gnu/packages/video.scm
index ced17f0e30..a95fe83bbd 100644
--- a/gnu/packages/video.scm
+++ b/gnu/packages/video.scm
@@ -3,6 +3,7 @@
 ;;; Copyright © 2014, 2015 David Thompson <davet@gnu.org>
 ;;; Copyright © 2014, 2015 Mark H Weaver <mhw@netris.org>
 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
+;;; Copyright © 2015 Efraim Flashner <efraim@flashner.co.il>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -584,7 +585,7 @@ treaming protocols.")
 (define-public mplayer
   (package
     (name "mplayer")
-    (version "1.1.1")
+    (version "1.2")
     (source (origin
              (method url-fetch)
              (uri (string-append
@@ -592,7 +593,7 @@ treaming protocols.")
                    version ".tar.xz"))
              (sha256
               (base32
-               "0xlcg7rszrwmw29wqr0plsw5d1rq0hb7vjsq7bmmfsly2z1wg3yf"))))
+               "1dp2lbxyhgjr8sn91kf6xw3w6d7dsgq08v4dgrq20afz1bqzdrzz"))))
     (build-system gnu-build-system)
     ;; FIXME: Add additional inputs once available.
     (native-inputs
@@ -601,8 +602,11 @@ treaming protocols.")
      `(("alsa-lib" ,alsa-lib)
        ("cdparanoia" ,cdparanoia)
        ("fontconfig" ,fontconfig)
+       ("ffmpeg", ffmpeg)
        ("freetype" ,freetype)
        ("lame" ,lame)
+       ("libdvdcss", libdvdcss)
+       ("libdvdnav", libdvdnav)
        ("libmpg123" ,mpg123)                      ; audio codec for MP3
 ;;        ("giflib" ,giflib) ; uses QuantizeBuffer, requires version >= 5
        ("libjpeg" ,libjpeg)
@@ -639,7 +643,7 @@ treaming protocols.")
                       "./configure"
                       (string-append "--extra-cflags=-I"
                                      libx11 "/include") ; to detect libx11
-                      "--disable-tremor-internal" ; forces external libvorbis
+		       "--disable-ffmpeg_a" ; disables bundled ffmpeg
                       (string-append "--prefix=" out)
                       ;; Enable runtime cpu detection where supported,
                       ;; and choose a suitable target.
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index e0859ccf30..db5fa1e3da 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -3,6 +3,7 @@
 ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
 ;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
 ;;; Copyright © 2015 xd1le <elisp.vim@gmail.com>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -22,6 +23,7 @@
 (define-module (gnu packages wm)
   #:use-module (guix licenses)
   #:use-module (guix packages)
+  #:use-module (gnu packages)
   #:use-module (gnu packages linux)
   #:use-module (guix build-system gnu)
   #:use-module (guix build-system haskell)
@@ -190,10 +192,19 @@ developers.")
     (source (origin
               (method url-fetch)
               (uri (string-append "http://hackage.haskell.org/package/xmonad/"
-                                  "xmonad-" version ".tar.gz"))
+                                  name "-" version ".tar.gz"))
               (sha256
                (base32
-                "1pfjssamiwpwjp1qqkm9m9p9s35pv381m0cwg6jxg0ppglibzq1r"))))
+                "1pfjssamiwpwjp1qqkm9m9p9s35pv381m0cwg6jxg0ppglibzq1r"))
+              (modules '((guix build utils)))
+              (snippet
+               ;; Here we update the constraints on the utf8-string package in
+               ;; the Cabal file.  We allow a newer version which is compatible
+               ;; with GHC 7.10.2.  The same change is applied on Hackage.  See
+               ;; <https://hackage.haskell.org/package/xmonad-0.11.1/revisions/>.
+               '(substitute* "xmonad.cabal"
+                  (("utf8-string >= 0.3 && < 0.4")
+                   "utf8-string >= 0.3 && < 1.1")))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-mtl" ,ghc-mtl)
@@ -232,7 +243,7 @@ tiled on several screens.")
 (define-public ghc-xmonad-contrib
   (package
     (name "ghc-xmonad-contrib")
-    (version "0.11.3")
+    (version "0.11.4")
     (source
      (origin
        (method url-fetch)
@@ -240,10 +251,11 @@ tiled on several screens.")
                            "xmonad-contrib-" version ".tar.gz"))
        (sha256
         (base32
-         "14h9vr33yljymswj50wbimav263y9abdcgi07mvfis0zd08rxqxa"))))
+         "1g5cw9vvnfbiyi599fngk02zlmdhrf82x0bndhypkn6kybab6yd3"))))
     (build-system haskell-build-system)
     (propagated-inputs
      `(("ghc-mtl" ,ghc-mtl)
+       ("ghc-old-time" ,ghc-old-time)
        ("ghc-random" ,ghc-random)
        ("ghc-utf8-string" ,ghc-utf8-string)
        ("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
@@ -256,3 +268,46 @@ tiled on several screens.")
      "Third party tiling algorithms, configurations, and scripts to Xmonad, a
 tiling window manager for X.")
     (license bsd-3)))
+
+(define-public evilwm
+  (package
+    (name "evilwm")
+    (version "1.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "http://www.6809.org.uk/evilwm/evilwm-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0ak0yajzk3v4dg5wmaghv6acf7v02a4iw8qxmq5yw5ard8lrqn3r"))
+       (patches (map search-patch '("evilwm-lost-focus-bug.patch")))))
+    (build-system gnu-build-system)
+    (inputs
+     `(("libx11" ,libx11)
+       ("libxext" ,libxext)
+       ("libxrandr" ,libxrandr)))
+    (arguments
+     `(#:modules ((srfi srfi-26)
+                  (guix build utils)
+                  (guix build gnu-build-system))
+       #:make-flags (let ((inputs (map (cut assoc-ref %build-inputs <>)
+                                       '("libx11" "libxext" "libxrandr")))
+                          (join (lambda (proc strs)
+                                  (string-join (map proc strs) " ")))
+                          (dash-I (cut string-append "-I" <> "/include"))
+                          (dash-L (cut string-append "-L" <> "/lib")))
+                      `("desktopfilesdir=$(prefix)/share/xsessions"
+                        ,(string-append "prefix=" (assoc-ref %outputs "out"))
+                        ,(string-append "CPPFLAGS=" (join dash-I inputs))
+                        ,(string-append "LDFLAGS=" (join dash-L inputs))))
+       #:tests? #f                      ;no tests
+       #:phases (modify-phases %standard-phases
+                  (delete 'configure)))) ;no configure script
+    (home-page "http://www.6809.org.uk/evilwm/")
+    (synopsis "Minimalist window manager for the X Window System")
+    (description
+     "evilwm is a minimalist window manager based on aewm, extended to feature
+many keyboard controls with repositioning and maximize toggles, solid window
+drags, snap-to-border support, and virtual desktops.")
+    (license (x11-style "file:///README"))))
diff --git a/gnu/packages/xiph.scm b/gnu/packages/xiph.scm
index c4db640d0f..705ebe1d73 100644
--- a/gnu/packages/xiph.scm
+++ b/gnu/packages/xiph.scm
@@ -4,6 +4,7 @@
 ;;; Copyright © 2013 David Thompson <dthompson2@worcester.edu>
 ;;; Copyright © 2014 Sree Harsha Totakura <sreeharsha@totakura.in>
 ;;; Copyright © 2014 Mark H Weaver <mhw@netris.org>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -46,6 +47,7 @@
             libkate
             vorbis-tools
             opus
+            opusfile
             opus-tools))
 
 (define libogg
@@ -341,6 +343,34 @@ decoding .opus files.")
     (license license:bsd-3)
     (home-page "http://www.opus-codec.org")))
 
+(define opusfile
+  (package
+    (name "opusfile")
+    (version "0.6")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "http://downloads.xiph.org/releases/opus/opusfile-" version
+                    ".tar.gz"))
+              (sha256
+               (base32
+                "19iys2kld75k0210b807i4illrdmj3cmmnrgxlc9y4vf6mxp2a14"))))
+    (build-system gnu-build-system)
+    (propagated-inputs
+     `(("opus" ,opus)))
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (inputs
+     `(("libogg" ,libogg)
+       ("openssl" ,openssl)))
+    (synopsis "Versatile audio codec")
+    (description
+     "The opusfile library provides seeking, decode, and playback of Opus
+streams in the Ogg container (.opus files) including over http(s) on posix and
+windows systems.")
+    (license license:bsd-3)
+    (home-page "http://www.opus-codec.org")))
+
 (define-public icecast
   (package
     (name "icecast")
diff --git a/gnu/packages/xorg.scm b/gnu/packages/xorg.scm
index f90c75ae10..b85a9c3aaf 100644
--- a/gnu/packages/xorg.scm
+++ b/gnu/packages/xorg.scm
@@ -1,7 +1,7 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2013, 2014 Andreas Enge <andreas@enge.fr>
 ;;; Copyright © 2014, 2015 Mark H Weaver <mhw@netris.org>
-;;; Copyright © 2014 Eric Bavier <bavier@member.fsf.org>
+;;; Copyright © 2014, 2015 Eric Bavier <bavier@member.fsf.org>
 ;;; Copyright © 2015 Ludovic Courtès <ludo@gnu.org>
 ;;; Copyright © 2015 Eric Dvorsak <eric@dvorsak.fr>
 ;;;
@@ -413,6 +413,23 @@ provided.")
             "16ic8wfwwr3jicaml7b5a0sk6plcgc1kg84w02881yhwmqm3nicb"))))
     (build-system gnu-build-system)
     (native-inputs `(("pkg-config" ,pkg-config)))
+    (arguments
+     `(#:phases (modify-phases %standard-phases
+                  (add-after
+                   'install 'install-fonts-dir
+                   ;; The X font server will not add directories to the font
+                   ;; path unless they contain a "fonts.dir" file, so add some
+                   ;; dummy files.
+                   (lambda* (#:key outputs #:allow-other-keys)
+                     (let ((out (assoc-ref outputs "out")))
+                       (for-each (lambda (d)
+                                   (call-with-output-file
+                                       (string-append out "/share/fonts/X11"
+                                                      "/" d "/fonts.dir")
+                                     (lambda (p)
+                                       (format p "0~%"))))
+                                 '("75dpi" "100dpi" "misc" "cyrillic"))
+                       #t))))))
     (home-page "http://www.x.org/wiki/")
     (synopsis "Xorg font aliases")
     (description
@@ -3826,6 +3843,34 @@ running on X server.")
     (license license:x11)))
 
 
+(define-public xlsfonts
+  (package
+    (name "xlsfonts")
+    (version "1.0.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://xorg/individual/app/xlsfonts-"
+             version
+             ".tar.bz2"))
+       (sha256
+        (base32
+         "1yi774g6r1kafsbnxbkrwyndd3i60362ck1fps9ywz076pn5naa0"))))
+    (build-system gnu-build-system)
+    (inputs
+     `(("xproto" ,xproto)
+       ("libx11" ,libx11)))
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (home-page "http://www.x.org/wiki/")
+    (synopsis "List fonts available from an X server")
+    (description
+     "xlsfonts lists fonts available from an X server via the X11 core
+protocol.")
+    (license license:x11)))
+
+
 (define-public xmodmap
   (package
     (name "xmodmap")