gnu: Move non-compilers out of haskell.scm.

* gnu/packages/haskell.scm (ghc-abstract-deque, ghc-abstract-par,
ghc-adjunctions, ghc-aeson-compat, ghc-alex, ghc-alsa-core,
ghc-annotated-wl-pprint, ghc-ansi-terminal, ghc-ansi-wl-pprint,
ghc-appar, ghc-async, ghc-atomic-write, ghc-attoparsec,
ghc-attoparsec-bootstrap, ghc-attoparsec-iso8601, ghc-auto-update,
ghc-aws, ghc-base16-bytestring, ghc-base64-bytestring, ghc-base-compat,
ghc-basement, ghc-base-orphans, ghc-base-prelude,
ghc-base-unicode-symbols, ghc-bifunctors, ghc-bindings-dsl,
ghc-blaze-builder, ghc-blaze-markup, ghc-bloomfilter, ghc-boxes,
ghc-byteable, ghc-byteorder, ghc-bytes, ghc-bytestring-builder,
ghc-bytestring-handle, ghc-bytestring-lexing, ghc-bzlib-conduit,
ghc-c2hs, ghc-cairo, ghc-call-stack, ghc-call-stack-boot,
ghc-case-insensitive, ghc-cereal, ghc-cereal-conduit, ghc-cgi,
ghc-charset, ghc-chart, ghc-chart-cairo, ghc-chasingbottoms,
ghc-cheapskate, ghc-chell, ghc-chell-quickcheck, ghc-chunked-data,
ghc-clock, ghc-clock-bootstrap, ghc-cmark, ghc-cmark-gfm, ghc-cmdargs,
ghc-code-page, ghc-colour, ghc-comonad, ghc-concatenative,
ghc-concurrent-output, ghc-conduit, ghc-conduit-algorithms,
ghc-conduit-combinators, ghc-conduit-extra, ghc-configurator,
ghc-connection, ghc-constraints, ghc-contravariant,
ghc-contravariant-extras, ghc-convertible, ghc-data-accessor,
ghc-data-accessor-transformers, ghc-data-default,
ghc-data-default-class, ghc-data-default-instances-base,
ghc-data-default-instances-containers, ghc-data-default-instances-dlist,
ghc-data-default-instances-old-locale, ghc-data-hash, ghc-data-ordlist,
ghc-deepseq-generics, ghc-descriptive, ghc-diff, ghc-disk-free-space,
ghc-distributive, ghc-dlist, ghc-doctemplates, ghc-doctest,
ghc-double-conversion, ghc-easy-file, ghc-easyplot, ghc-echo,
ghc-edisonapi, ghc-edisoncore, ghc-edit-distance, ghc-either,
ghc-email-validate, ghc-enclosed-exceptions, ghc-equivalence, ghc-erf,
ghc-errorcall-eq-instance, ghc-errors, ghc-esqueleto, ghc-exactprint,
ghc-exceptions, ghc-executable-path, ghc-extensible-exceptions,
ghc-extra, ghc-fail, ghc-fast-logger, ghc-feed, ghc-fgl,
ghc-fgl-arbitrary, ghc-file-embed, ghc-filemanip, ghc-findbin,
ghc-fingertree, ghc-fixed, ghc-foldl, ghc-foundation, ghc-free,
ghc-fsnotify, ghc-generic-deriving, ghc-generics-sop,
ghc-geniplate-mirror, ghc-genvalidity, ghc-genvalidity-property,
ghc-gitrev, ghc-glob, ghc-gluraw, ghc-glut, ghc-gnuplot, ghc-graphviz,
ghc-gtk2hs-buildtools, ghc-hackage-security, ghc-haddock,
ghc-haddock-api, ghc-haddock-library, ghc-half, ghc-happy, ghc-hashable,
ghc-hashable-bootstrap, ghc-hashable-time, ghc-hashtables,
ghc-haskell-lexer, ghc-haskell-src, ghc-haskell-src-exts,
ghc-haskell-src-exts-util, ghc-haskell-src-meta, ghc-hasktags, ghc-hex,
ghc-highlighting-kate, ghc-hindent, ghc-hinotify, ghc-hmatrix,
ghc-hmatrix-gsl, ghc-hmatrix-gsl-stats, ghc-hmatrix-special,
ghc-hostname, ghc-hourglass, ghc-hpack, ghc-hs-bibutils, ghc-hslogger,
ghc-hslua, ghc-hslua-module-text, ghc-http-api-data, ghc-ieee754,
ghc-ifelse, ghc-indents, ghc-inline-c, ghc-inline-c-cpp,
ghc-integer-logarithms, ghc-integer-logarithms-bootstrap,
ghc-interpolate, ghc-intervalmap, ghc-invariant, ghc-iproute, ghc-iwlib,
ghc-json, ghc-juicypixels, ghc-kan-extensions, ghc-language-c,
ghc-language-haskell-extract, ghc-lens, ghc-libffi, ghc-libmpd,
ghc-libxml, ghc-lifted-async, ghc-lifted-base, ghc-linear,
ghc-logging-facade, ghc-logict, ghc-lzma, ghc-lzma-conduit,
ghc-markdown-unlit, ghc-math-functions, ghc-megaparsec, ghc-memory,
ghc-memotrie, ghc-microlens, ghc-microlens-ghc, ghc-microlens-mtl,
ghc-microlens-platform, ghc-microlens-th, ghc-missingh, ghc-mmap,
ghc-mmorph, ghc-mockery, ghc-monad-control, ghc-monad-logger,
ghc-monad-loops, ghc-monad-par, ghc-monad-par-extras, ghc-monadplus,
ghc-monadrandom, ghc-monads-tf, ghc-mono-traversable, ghc-murmur-hash,
ghc-mwc-random, ghc-nats, ghc-nats-bootstrap, ghc-network,
ghc-network-info, ghc-network-uri, ghc-newtype-generics, ghc-objectname,
ghc-old-locale, ghc-old-time, ghc-opengl, ghc-openglraw,
ghc-operational, ghc-options, ghc-optparse-applicative, ghc-pandoc,
ghc-pandoc-citeproc, ghc-pandoc-types, ghc-parallel, ghc-parsec-numbers,
ghc-parser-combinators, ghc-parsers, ghc-path, ghc-path-io, ghc-paths,
ghc-patience, ghc-pcre-light, ghc-persistent, ghc-persistent-sqlite,
ghc-persistent-template, ghc-polyparse, ghc-pqueue, ghc-prelude-extras,
ghc-pretty-hex, ghc-pretty-show, ghc-primitive, ghc-profunctors,
ghc-psqueues, ghc-random, ghc-raw-strings-qq, ghc-rebase, ghc-reducers,
ghc-refact, ghc-reflection, ghc-regex, ghc-regex-applicative,
ghc-regex-base, ghc-regex-compat, ghc-regex-compat-tdfa,
ghc-regex-pcre-builtin, ghc-regex-posix, ghc-regex-tdfa,
ghc-regex-tdfa-text, ghc-rerebase, ghc-resolv, ghc-resource-pool,
ghc-resourcet, ghc-rfc5051, ghc-rio, ghc-safe, ghc-safe-exceptions,
ghc-safeio, ghc-safesemaphore, ghc-sandi, ghc-scientific,
ghc-scientific-bootstrap, ghc-sdl, ghc-sdl-image, ghc-sdl-mixer,
ghc-securemem, ghc-semigroupoids, ghc-semigroups,
ghc-semigroups-bootstrap, ghc-setenv, ghc-setlocale, ghc-shakespeare,
ghc-shelly, ghc-silently, ghc-simple-reflect, ghc-simple-sendfile,
ghc-skylighting-core, ghc-skylighting, ghc-smallcheck, ghc-socks,
ghc-split, ghc-statevar, ghc-statistics, ghc-stm-chans, ghc-stm-conduit,
ghc-stmonadtrans, ghc-storable-complex, ghc-streaming-commons,
ghc-strict, ghc-stringbuilder, ghc-string-qq, ghc-stringsearch,
ghc-stylish-haskell, ghc-syb, ghc-system-fileio, ghc-system-filepath,
ghc-tagged, ghc-tar, ghc-temporary, ghc-temporary-rc, ghc-terminal-size,
ghc-texmath, ghc-text-binary, ghc-tf-random, ghc-th-abstraction,
ghc-th-expand-syns, ghc-th-lift, ghc-th-lift-instances, ghc-th-orphans,
ghc-th-reify-many, ghc-time-locale-compat, ghc-tldr,
ghc-transformers-base, ghc-transformers-compat, ghc-tree-diff,
ghc-trifecta, ghc-tuple-th, ghc-typed-process, ghc-unbounded-delays,
ghc-unexceptionalio, ghc-union-find, ghc-uniplate, ghc-unix-compat,
ghc-unix-time, ghc-unliftio, ghc-unliftio-core,
ghc-unordered-containers, ghc-unordered-containers-bootstrap,
ghc-uri-bytestring, ghc-utf8-string, ghc-utility-ht, ghc-uuid,
ghc-uuid-types, ghc-validation, ghc-validity, ghc-vault, ghc-vector,
ghc-vector-algorithms, ghc-vector-binary-instances, ghc-vector-builder,
ghc-vector-th-unbox, ghc-void, ghc-wave, ghc-wcwidth,
ghc-wcwidth-bootstrap, ghc-weigh, ghc-wl-pprint,
ghc-wl-pprint-annotated, ghc-wl-pprint-text, ghc-word8, ghc-x11,
ghc-x11-xft, ghc-xdg-basedir, ghc-xml, ghc-xml-conduit, ghc-xml-types,
ghc-yaml, ghc-zip-archive, ghc-zlib): Move variables from here...
* gnu/packages/haskell-xyz.scm: ...to here.
* gnu/packages/agda.scm,
gnu/packages/bioconductor.scm,
gnu/packages/bioinformatics.scm,
gnu/packages/cran.scm,
gnu/packages/emacs-xyz.scm,
gnu/packages/games.scm,
gnu/packages/graphics.scm,
gnu/packages/haskell-apps.scm,
gnu/packages/haskell-check.scm,
gnu/packages/idris.scm,
gnu/packages/statistics.scm,
gnu/packages/wm.scm: Update module references.

Co-authored-by: Timothy Sample <samplet@ngyro.com>

1 files changed, 11096 insertions, 1 deletions

diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 53c4dcc5ff..46e5153906 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -1,5 +1,24 @@
 ;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2015, 2016 Federico Beffa <beffa@fbengineering.ch>
+;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
+;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
+;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
+;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
+;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
+;;; Copyright © 2017 Peter Mikkelsen <petermikkelsen10@gmail.com>
+;;; Copyright © 2017, 2018 Alex Vong <alexvong1995@gmail.com>
+;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
+;;; Copyright © 2017, 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2018 Tonton <tonton@riseup.net>
+;;; Copyright © 2018, 2019 Timothy Sample <samplet@ngyro.com>
+;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
+;;; Copyright © 2018, 2019 Gabriel Hondet <gabrielhondet@gmail.com>
 ;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
+;;; Copyright © 2019 Jacob MacDonald <jaccarmac@gmail.com>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -18,13 +37,1804 @@
 
 (define-module (gnu packages haskell-xyz)
   #:use-module (gnu packages)
-  #:use-module (gnu packages haskell)
+  #:use-module (gnu packages base)
+  #:use-module (gnu packages compression)
+  #:use-module (gnu packages emacs)
+  #:use-module (gnu packages gcc)
+  #:use-module (gnu packages gl)
+  #:use-module (gnu packages graphviz)
+  #:use-module (gnu packages gtk)
+  #:use-module (gnu packages haskell-apps)
   #:use-module (gnu packages haskell-check)
+  #:use-module (gnu packages haskell-crypto)
+  #:use-module (gnu packages haskell-web)
+  #:use-module (gnu packages libffi)
+  #:use-module (gnu packages linux)
+  #:use-module (gnu packages lua)
+  #:use-module (gnu packages maths)
+  #:use-module (gnu packages pcre)
+  #:use-module (gnu packages pkg-config)
+  #:use-module (gnu packages sdl)
+  #:use-module (gnu packages xml)
+  #:use-module (gnu packages xorg)
   #:use-module (guix build-system haskell)
   #:use-module (guix download)
+  #:use-module (guix git-download)
   #:use-module ((guix licenses) #:prefix license:)
   #:use-module (guix packages))
 
+(define-public ghc-abstract-deque
+  (package
+    (name "ghc-abstract-deque")
+    (version "0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "abstract-deque-" version "/"
+                           "abstract-deque-" version ".tar.gz"))
+       (sha256
+        (base32
+         "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-random" ,ghc-random)))
+    (home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
+    (synopsis "Abstract, parameterized interface to mutable Deques for Haskell")
+    (description "This Haskell package provides an abstract interface to
+highly-parameterizable queues/deques.
+
+Background: There exists a feature space for queues that extends between:
+
+@itemize
+@item Simple, single-ended, non-concurrent, bounded queues
+
+@item Double-ended, thread-safe, growable queues with important points
+in between (such as the queues used for work stealing).
+@end itemize
+
+This package includes an interface for Deques that allows the programmer
+to use a single API for all of the above, while using the type system to
+select an efficient implementation given the requirements (using type families).
+
+This package also includes a simple reference implementation based on
+@code{IORef} and @code{Data.Sequence}.")
+    (license license:bsd-3)))
+
+(define-public ghc-abstract-par
+  (package
+    (name "ghc-abstract-par")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "abstract-par-" version "/"
+                           "abstract-par-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/simonmar/monad-par")
+    (synopsis "Abstract parallelization interface for Haskell")
+    (description "This Haskell package is an abstract interface
+only.  It provides a number of type clasess, but not an
+implementation.  The type classes separate different levels
+of @code{Par} functionality.  See the @code{Control.Monad.Par.Class}
+module for more details.")
+    (license license:bsd-3)))
+
+(define-public ghc-adjunctions
+  (package
+    (name "ghc-adjunctions")
+    (version "4.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/adjunctions/adjunctions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-free" ,ghc-free)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-void" ,ghc-void)))
+    (native-inputs
+     `(("ghc-generic-deriving" ,ghc-generic-deriving)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/ekmett/adjunctions/")
+    (synopsis "Adjunctions and representable functors")
+    (description "This library provides adjunctions and representable functors
+for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-aeson-compat
+  (package
+    (name "ghc-aeson-compat")
+    (version "0.3.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "aeson-compat-" version "/"
+                           "aeson-compat-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0j4v13pgk21zy8hqkbx8hw0n05jdl17qphxz9rj4h333pr547r3i"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))  ;  FIXME: Tests require QuickCheck >= 2.10
+    (inputs `(("ghc-base-compat" ,ghc-base-compat)
+              ("ghc-aeson" ,ghc-aeson)
+              ("ghc-attoparsec" ,ghc-attoparsec)
+              ("ghc-attoparsec" ,ghc-attoparsec-iso8601)
+              ("ghc-exceptions" ,ghc-exceptions)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-scientific" ,ghc-scientific)
+              ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-tagged" ,ghc-tagged)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-nats" ,ghc-nats)))
+    (home-page "https://github.com/phadej/aeson-compat")
+    (synopsis "Compatibility layer for ghc-aeson")
+    (description "This Haskell package provides compatibility layer for
+ghc-aeson.")
+    (license license:bsd-3)))
+
+(define-public ghc-alex
+  (package
+    (name "ghc-alex")
+    (version "3.2.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/alex/alex-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0cpjixgsr0b2x4s6hz4aa6gnmjw9i7xd9nlfi8m37zqlidq4v3nm"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'check 'set-check-variables
+           (lambda _
+             (setenv "PATH" (string-append (getcwd) "/dist/build/alex:"
+                                           (getenv "PATH")))
+             (setenv "alex_datadir" (string-append (getcwd) "/data"))
+             #t)))))
+    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (native-inputs
+     `(("which" ,which)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-alsa-core
+  (package
+    (name "ghc-alsa-core")
+    (version "0.5.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/alsa-core/alsa-core-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1avh4a419h9d2zsslg6j8hm87ppgsgqafz8ll037rk2yy1g4jl7b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+       ("alsa-lib" ,alsa-lib)))
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (home-page "http://www.haskell.org/haskellwiki/ALSA")
+    (synopsis "Binding to the ALSA Library API (Exceptions)")
+    (description "This package provides access to ALSA infrastructure, that is
+needed by both alsa-seq and alsa-pcm.")
+    (license 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
+             "https://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 license:bsd-3)))
+
+(define-public ghc-ansi-terminal
+  (package
+    (name "ghc-ansi-terminal")
+    (version "0.8.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0428gq8m3fdnb7ldcsyk97qcch76hcxbgh2666p6f76fs2qbhg7b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-colour" ,ghc-colour)))
+    (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 license:bsd-3)))
+
+(define-public ghc-ansi-wl-pprint
+  (package
+    (name "ghc-ansi-wl-pprint")
+    (version "0.6.8.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "ansi-wl-pprint/ansi-wl-pprint-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0gnb4mkqryv08vncxnj0bzwcnd749613yw3cxfzw6y3nsldp4c56"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-appar
+  (package
+    (name "ghc-appar")
+    (version "0.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/appar/appar-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://hackage.haskell.org/package/appar")
+    (synopsis "Simple applicative parser")
+    (description "This package provides a simple applicative parser in Parsec
+style.")
+    (license license:bsd-3)))
+
+(define-public ghc-async
+  (package
+    (name "ghc-async")
+    (version "2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/async/async-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09whscli1q5z7lzyq9rfk0bq1ydplh6pjmc6qv0x668k5818c2wg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (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 license:bsd-3)))
+
+(define-public ghc-atomic-write
+  (package
+    (name "ghc-atomic-write")
+    (version "0.2.0.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/atomic-write/atomic-write-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1iaq0hprxcv0sl1sgwcgmm87zraf738va1bciwnx2jkk3k1v9iyv"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-temporary" ,ghc-temporary)
+       ("ghc-unix-compat" ,ghc-unix-compat)))
+    (native-inputs
+     `(("ghc-temporary" ,ghc-temporary)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/stackbuilders/atomic-write")
+    (synopsis "Atomically write to a file")
+    (description
+     "Atomically write to a file on POSIX-compliant systems while preserving
+permissions.  @code{mv} is an atomic operation.  This makes it simple to write
+to a file atomically just by using the @code{mv} operation.  However, this
+will destroy the permissions on the original file.  This library preserves
+permissions while atomically writing to a file.")
+    (license license:expat)))
+
+(define-public ghc-attoparsec
+  (package
+    (name "ghc-attoparsec")
+    (version "0.13.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/attoparsec/attoparsec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0j6qcwd146yzlkc9mcvzvnixsyl65n2a68l28322q5v9p4g4g4yx"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'patch-for-newer-quickcheck
+           (lambda _
+             (substitute* "attoparsec.cabal"
+               (("QuickCheck >= 2\\.7 && < 2\\.10")
+                "QuickCheck >= 2.7 && < 2.12"))
+             ;; This test fails because of the newer QuickCheck:
+             ;; <https://github.com/bos/attoparsec/issues/134>.
+             (substitute* "tests/QC/ByteString.hs"
+               ((", testProperty \"satisfyWith\" satisfyWith")
+                "")))))))
+    (inputs
+     `(("ghc-scientific" ,ghc-scientific)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
+       ("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 license:bsd-3)))
+
+(define-public ghc-attoparsec-bootstrap
+  (package
+    (inherit ghc-attoparsec)
+    (name "ghc-attoparsec-bootstrap")
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-scientific" ,ghc-scientific-bootstrap)))
+    (native-inputs '())
+    (properties '(hidden? #t))))
+
+(define-public ghc-attoparsec-iso8601
+  (package
+    (name "ghc-attoparsec-iso8601")
+    (version "1.0.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "attoparsec-iso8601-" version "/"
+                           "attoparsec-iso8601-" version ".tar.gz"))
+       (sha256
+        (base32
+         "12l55b76bhya9q89mfmqmy6sl5v39b6gzrw5rf3f70vkb23nsv5a"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4")))
+    (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+              ("ghc-base-compat" ,ghc-base-compat)))
+    (home-page "https://github.com/bos/aeson")
+    (synopsis "Parse ISO 8601 dates")
+    (description "Haskell library for parsing of ISO 8601 dates, originally
+from aeson.")
+    (license license:bsd-3)))
+
+(define-public ghc-auto-update
+  (package
+    (name "ghc-auto-update")
+    (version "0.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/auto-update/auto-update-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09dlh2alsx2mw5kvj931yhbj0aw7jmly2cm9xbscm2sf098w35jy"))))
+    (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 license:expat)))
+
+(define-public ghc-aws
+  (package
+    (name "ghc-aws")
+    (version "0.20")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "aws-" version "/aws-" version ".tar.gz"))
+       (sha256 (base32
+                "0pwpabmypi1w8rni9qfwabgn95jks4h8dyw6889mn8xzsrhdhyf0"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; Tests require AWS credentials.
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-byteable" ,ghc-byteable)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-cereal" ,ghc-cereal)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-cryptonite" ,ghc-cryptonite)
+       ("ghc-data-default" ,ghc-data-default)
+       ("ghc-http-conduit" ,ghc-http-conduit)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-network" ,ghc-network)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-xml-conduit" ,ghc-xml-conduit)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-errors" ,ghc-errors)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-http-client-tls" ,ghc-http-client-tls)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-conduit-combinators" ,ghc-conduit-combinators)))
+    (home-page "https://github.com/aristidb/aws")
+    (synopsis "Amazon Web Services for Haskell")
+    (description "This package attempts to provide support for using
+Amazon Web Services like S3 (storage), SQS (queuing) and others to
+Haskell programmers.  The ultimate goal is to support all Amazon
+Web Services.")
+    (license license:bsd-3)))
+
+(define-public ghc-base16-bytestring
+  (package
+    (name "ghc-base16-bytestring")
+    (version "0.1.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/base16-bytestring/"
+             "base16-bytestring-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/bos/base16-bytestring")
+    (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings")
+    (description
+     "This package provides a Haskell library for working with base16-encoded
+data quickly and efficiently, using the ByteString type.")
+    (license license:bsd-3)))
+
+(define-public ghc-base64-bytestring
+  (package
+    (name "ghc-base64-bytestring")
+    (version "1.0.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "13305brzlac24pifiqd5a2z10c6k6amhpdy9cc0z5ryrkgnm8dhr"))))
+    (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 license:bsd-3)))
+
+(define-public ghc-base-compat
+  (package
+    (name "ghc-base-compat")
+    (version "0.10.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/base-compat/base-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ksp990gxs731mq19rzbxrbs43nazfljjc8krlx5bjqblw3kfs8d"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (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 license:bsd-3)))
+
+(define-public ghc-basement
+  (package
+    (name "ghc-basement")
+    (version "0.0.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "basement/basement-" version ".tar.gz"))
+       (sha256
+        (base32
+         "194jw567di4q2758943q9rrwkbf9gl261my7qc21i9xhyabipx67"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/haskell-foundation/foundation")
+    (synopsis "Basic primitives for Foundation starter pack")
+    (description
+     "This package contains basic primitives for the Foundation set of
+packages.")
+    (license license:bsd-3)))
+
+(define-public ghc-base-orphans
+  (package
+    (name "ghc-base-orphans")
+    (version "0.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/base-orphans/base-orphans-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "057f9npnqk71ccfh95djfkpd54dzazphj06grwxa3fyhwcwxrb8a"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (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 license:bsd-3)))
+
+(define-public ghc-base-prelude
+  (package
+    (name "ghc-base-prelude")
+    (version "1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "base-prelude-" version "/"
+                           "base-prelude-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1zk728sd09hh2r4xwz4lazsrrgg5cshydn64932sm0vckplndk73"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/nikita-volkov/base-prelude")
+    (synopsis "The most complete prelude formed solely from the Haskell's base
+package")
+    (description "This Haskell package aims to reexport all the non-conflicting
+and most general definitions from the \"base\" package.
+
+This includes APIs for applicatives, arrows, monoids, foldables, traversables,
+exceptions, generics, ST, MVars and STM.
+
+This package will never have any dependencies other than \"base\".
+
+Versioning policy:
+
+The versioning policy of this package deviates from PVP in the sense
+that its exports in part are transitively determined by the version of \"base\".
+Therefore it's recommended for the users of @code{ghc-base-prelude} to specify
+the bounds of \"base\" as well.")
+    (license license:expat)))
+
+(define-public ghc-base-unicode-symbols
+  (package
+    (name "ghc-base-unicode-symbols")
+    (version "0.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/base-unicode-symbols/base-unicode-symbols-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ia6li7qjg1zkak4gf6mnbshw45mq9bfjr0jch58ds0lscmvwyzf"))))
+    (build-system haskell-build-system)
+    (home-page "http://www.haskell.org/haskellwiki/Unicode-symbols")
+    (synopsis "Unicode alternatives for common functions and operators")
+    (description "This package defines new symbols for a number of functions,
+operators and types in the base package.  All symbols are documented with
+their actual definition and information regarding their Unicode code point.
+They should be completely interchangeable with their definitions.  For
+further Unicode goodness you can enable the @code{UnicodeSyntax}
+@url{https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exs.html#unicode-syntax,
+language extension}.  This extension enables Unicode characters to be used to
+stand for certain ASCII character sequences, i.e. → instead of @code{->},
+∀ instead of @code{forall} and many others.")
+    (license license:bsd-3)))
+
+(define-public ghc-bifunctors
+  (package
+    (name "ghc-bifunctors")
+    (version "5.5.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/bifunctors/bifunctors-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1jn9rxg643xnlhrknmjz88nblcpsr45xwjkwwnn5nxpasa7m4d6l"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-th-abstraction" ,ghc-th-abstraction)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/ekmett/bifunctors/")
+    (synopsis "Bifunctors for Haskell")
+    (description "This package provides bifunctors for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-bindings-dsl
+  (package
+    (name "ghc-bindings-dsl")
+    (version "1.0.25")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/bindings-DSL/"
+                           "bindings-DSL-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0kqrd78nspl3lk4a0fqn47d8dirjg3b24dkvkigcrlb81hw35pk3"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/jwiegley/bindings-dsl/wiki")
+    (synopsis "FFI domain specific language, on top of hsc2hs")
+    (description
+     "This is a set of macros to be used when writing Haskell FFI.  They were
+designed to be able to fully describe C interfaces, so that @code{hsc2hs} can
+extract from them all Haskell code needed to mimic such interfaces.  All
+Haskell names used are automatically derived from C names, structures are
+mapped to Haskell instances of @code{Storable}, and there are also macros you
+can use with C code to help write bindings to inline functions or macro
+functions.")
+    (license license:bsd-3)))
+
+(define-public ghc-blaze-builder
+  (package
+    (name "ghc-blaze-builder")
+    (version "0.4.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/blaze-builder/blaze-builder-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "05681dih2d8s96an945wkbwl05w8ddbcfx8n3r3ck79ydyb8pz4i"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))          ; FIXME: Missing test libraries.
+    (inputs
+     `(("ghc-utf8-string" ,ghc-utf8-string)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-blaze-markup
+  (package
+    (name "ghc-blaze-markup")
+    (version "0.8.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "blaze-markup/blaze-markup-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0ih1c3qahkdgzbqihdhny5s313l2m66fbb88w8jbx7yz56y7rawh"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "blaze-markup.cabal"
+               (("tasty            >= 1\\.0  && < 1\\.1")
+                "tasty            >= 1.0  && < 1.2")))))))
+    (inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)))
+    (native-inputs
+     `(("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 "https://jaspervdj.be/blaze")
+    (synopsis "Fast markup combinator library for Haskell")
+    (description "This library provides core modules of a markup combinator
+library for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-bloomfilter
+  (package
+    (name "ghc-bloomfilter")
+    (version "2.0.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "bloomfilter/bloomfilter-" version ".tar.gz"))
+       (sha256
+        (base32
+         "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-random" ,ghc-random)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/bloomfilter")
+    (synopsis "Pure and impure Bloom filter implementations")
+    (description "This package provides both mutable and immutable Bloom
+filter data types, along with a family of hash functions and an easy-to-use
+interface.")
+    (license license:bsd-3)))
+
+(define-public ghc-boxes
+  (package
+    (name "ghc-boxes")
+    (version "0.1.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/boxes/boxes-"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "1hsnmw95i58d4bkpxby3ddsj1cawypw4mdyb18m393s5i8p7iq9q"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-split" ,ghc-split)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/boxes")
+    (synopsis "2D text pretty-printing library")
+    (description
+     "Boxes is a pretty-printing library for laying out text in two dimensions,
+using a simple box model.")
+    (license license:bsd-3)))
+
+(define-public ghc-byteable
+  (package
+    (name "ghc-byteable")
+    (version "0.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "byteable/byteable-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/vincenthz/hs-byteable")
+    (synopsis "Type class for sequence of bytes")
+    (description
+     "This package provides an abstract class to manipulate sequence of bytes.
+The use case of this class is abstracting manipulation of types that are just
+wrapping a bytestring with stronger and more meaniful name.")
+    (license license:bsd-3)))
+
+(define-public ghc-byteorder
+  (package
+    (name "ghc-byteorder")
+    (version "1.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://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 license:bsd-3)))
+
+(define-public ghc-bytes
+  (package
+   (name "ghc-bytes")
+   (version "0.15.5")
+   (source
+    (origin
+     (method url-fetch)
+     (uri
+      (string-append "https://hackage.haskell.org/package/bytes-"
+                     version "/bytes-"
+                     version ".tar.gz"))
+     (file-name (string-append name "-" version ".tar.gz"))
+     (sha256
+      (base32
+       "063il2vrn0p88r9gzndh4ijs0mxj37khkc9ym9bqdsv7ngk3b683"))))
+   (build-system haskell-build-system)
+   (inputs `(("ghc-cereal" ,ghc-cereal)
+             ("cabal-doctest" ,cabal-doctest)
+             ("ghc-doctest" ,ghc-doctest)
+             ("ghc-scientific" ,ghc-scientific)
+             ("ghc-transformers-compat" ,ghc-transformers-compat)
+             ("ghc-unordered-containers" ,ghc-unordered-containers)
+             ("ghc-void" ,ghc-void)
+             ("ghc-vector" ,ghc-vector)))
+   (synopsis "Serialization between @code{binary} and @code{cereal}")
+   (description "This package provides a simple compatibility shim that lets
+you work with both @code{binary} and @code{cereal} with one chunk of
+serialization code.")
+   (home-page "https://hackage.haskell.org/package/bytes")
+   (license license:bsd-3)))
+
+(define-public ghc-bytestring-builder
+  (package
+    (name "ghc-bytestring-builder")
+    (version "0.10.8.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/bytestring-builder"
+             "/bytestring-builder-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1hnvjac28y44yn78c9vdp1zvrknvlw98ky3g4n5vivr16rvh8x3d"))))
+    (build-system haskell-build-system)
+    (arguments `(#:haddock? #f)) ; Package contains no documentation.
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-bytestring-handle
+  (package
+    (name "ghc-bytestring-handle")
+    (version "0.1.0.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/bytestring-handle/bytestring-handle-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "bytestring-handle.cabal"
+               (("QuickCheck >= 2\\.1\\.2 && < 2\\.11")
+                "QuickCheck >= 2.1.2 && < 2.12")
+               (("base >= 4\\.2 && < 4\\.11")
+                "base >= 4.2 && < 4.12")))))))
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://hub.darcs.net/ganesh/bytestring-handle")
+    (synopsis "ByteString-backed Handles")
+    (description "ByteString-backed Handles") ; There is no description
+    (license license:bsd-3)))
+
+(define-public ghc-bytestring-lexing
+  (package
+    (name "ghc-bytestring-lexing")
+    (version "0.5.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "bytestring-lexing/bytestring-lexing-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0wrzniawhgpphc6yx1v972gyqxdbv0pizaz9bafahrshyb9svy81"))))
+    (build-system haskell-build-system)
+    (home-page "http://code.haskell.org/~wren/")
+    (synopsis "Parse and produce literals from strict or lazy bytestrings")
+    (description
+     "This package provides tools to parse and produce literals efficiently
+from strict or lazy bytestrings.")
+    (license license:bsd-2)))
+
+(define-public ghc-bzlib-conduit
+  (package
+    (name "ghc-bzlib-conduit")
+    (version "0.3.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/bzlib-conduit/"
+                           "bzlib-conduit-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0fd2hnr782s7qgipazg2yxwia9qqhkvm9bcm90773c3zkxa13n23"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-bindings-dsl" ,ghc-bindings-dsl)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-resourcet" ,ghc-resourcet)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-random" ,ghc-random)))
+    (home-page "https://github.com/snoyberg/bzlib-conduit")
+    (synopsis "Streaming compression/decompression via conduits")
+    (description
+     "This package provides Haskell bindings to bzlib and Conduit support for
+streaming compression and decompression.")
+    (license license:bsd-3)))
+
+(define-public ghc-c2hs
+  (package
+    (name "ghc-c2hs")
+    (version "0.28.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/c2hs/c2hs-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1nplgxfin139x12sb656f5870rpdclrhzi8mq8pry035qld15pci"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-language-c" ,ghc-language-c)
+       ("ghc-dlist" ,ghc-dlist)))
+    (native-inputs
+     `(("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-shelly" ,ghc-shelly)
+       ("gcc" ,gcc)))
+    (arguments
+     `(;; XXX: Test failures are induced by a parse error in <bits/floatn.h>
+       ;; of glibc 2.28.
+       #:tests? #f
+
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'check 'set-cc
+           ;; add a cc executable in the path, needed for some tests to pass
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((gcc (assoc-ref inputs "gcc"))
+                   (tmpbin (tmpnam))
+                   (curpath (getenv "PATH")))
+               (mkdir-p tmpbin)
+               (symlink (which "gcc") (string-append tmpbin "/cc"))
+               (setenv "PATH" (string-append tmpbin ":" curpath)))
+             #t))
+         (add-after 'check 'remove-cc
+           ;; clean the tmp dir made in 'set-cc
+           (lambda _
+             (let* ((cc-path (which "cc"))
+                    (cc-dir (dirname cc-path)))
+               (delete-file-recursively cc-dir)
+               #t))))))
+    (home-page "https://github.com/haskell/c2hs")
+    (synopsis "Create Haskell bindings to C libraries")
+    (description "C->Haskell assists in the development of Haskell bindings to
+C libraries.  It extracts interface information from C header files and
+generates Haskell code with foreign imports and marshaling.  Unlike writing
+foreign imports by hand (or using hsc2hs), this ensures that C functions are
+imported with the correct Haskell types.")
+    (license license:gpl2)))
+
+(define-public ghc-cairo
+  (package
+    (name "ghc-cairo")
+    (version "0.13.5.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/cairo/"
+                           "cairo-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:modules ((guix build haskell-build-system)
+                  (guix build utils)
+                  (ice-9 match)
+                  (srfi srfi-26))
+       #:phases
+       (modify-phases %standard-phases
+         ;; FIXME: This is a copy of the standard configure phase with a tiny
+         ;; difference: this package needs the -package-db flag to be passed
+         ;; to "runhaskell" in addition to the "configure" action, because it
+         ;; depends on gtk2hs-buildtools, which provide setup hooks.  Without
+         ;; this option the Setup.hs file cannot be evaluated.  The
+         ;; haskell-build-system should be changed to pass "-package-db" to
+         ;; "runhaskell" in any case.
+         (replace 'configure
+           (lambda* (#:key outputs inputs tests? (configure-flags '())
+                     #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (name-version (strip-store-file-name out))
+                    (input-dirs (match inputs
+                                  (((_ . dir) ...)
+                                   dir)
+                                  (_ '())))
+                    (ghc-path (getenv "GHC_PACKAGE_PATH"))
+                    (params (append `(,(string-append "--prefix=" out))
+                                    `(,(string-append "--libdir=" out "/lib"))
+                                    `(,(string-append "--bindir=" out "/bin"))
+                                    `(,(string-append
+                                        "--docdir=" out
+                                        "/share/doc/" name-version))
+                                    '("--libsubdir=$compiler/$pkg-$version")
+                                    '("--package-db=../package.conf.d")
+                                    '("--global")
+                                    `(,@(map
+                                         (cut string-append "--extra-include-dirs=" <>)
+                                         (search-path-as-list '("include") input-dirs)))
+                                    `(,@(map
+                                         (cut string-append "--extra-lib-dirs=" <>)
+                                         (search-path-as-list '("lib") input-dirs)))
+                                    (if tests?
+                                        '("--enable-tests")
+                                        '())
+                                    configure-flags)))
+               (unsetenv "GHC_PACKAGE_PATH")
+               (apply invoke "runhaskell" "-package-db=../package.conf.d"
+                      "Setup.hs" "configure" params)
+               (setenv "GHC_PACKAGE_PATH" ghc-path)
+               #t))))))
+    (inputs
+     `(("ghc-utf8-string" ,ghc-utf8-string)
+       ("cairo" ,cairo)))
+    (native-inputs
+     `(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools)
+       ("pkg-config" ,pkg-config)))
+    (home-page "http://projects.haskell.org/gtk2hs/")
+    (synopsis "Haskell bindings to the Cairo vector graphics library")
+    (description
+     "Cairo is a library to render high quality vector graphics.  There exist
+various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG
+documents, amongst others.")
+    (license license:bsd-3)))
+
+(define-public ghc-call-stack
+  (package
+    (name "ghc-call-stack")
+    (version "0.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "call-stack/call-stack-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1qmihf5jafmc79sk52l6gpx75f5bnla2lp62kh3p34x3j84mwpzj"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-nanospec" ,ghc-nanospec)))
+    (home-page "https://github.com/sol/call-stack#readme")
+    (synopsis "Use GHC call-stacks in a backward compatible way")
+    (description "This package provides a compatibility layer for using GHC
+call stacks with different versions of the compiler.")
+    (license license:expat)))
+
+;; This is used as an input to ghc-hunit.  We cannot use ghc-call-stack there,
+;; because it depends on ghc-nanospec, which depends on ghc-hunit.
+(define-public ghc-call-stack-boot
+  (hidden-package
+   (package
+     (inherit ghc-call-stack)
+     (arguments '(#:tests? #f))
+     (inputs '()))))
+
+(define-public ghc-case-insensitive
+  (package
+    (name "ghc-case-insensitive")
+    (version "1.2.0.11")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/case-insensitive/case-insensitive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1qrpxfirsxckg7jv28f5ah2qc8lh95hp7rnqkbqs1ahcwlbnvkm7"))))
+    (build-system haskell-build-system)
+    ;; these inputs are necessary to use this library
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page
+     "https://github.com/basvandijk/case-insensitive")
+    (synopsis "Case insensitive string comparison")
+    (description
+     "The module @code{Data.CaseInsensitive} provides the @code{CI} type
+constructor which can be parameterised by a string-like type like:
+@code{String}, @code{ByteString}, @code{Text}, etc.  Comparisons of values of
+the resulting type will be insensitive to cases.")
+    (license license:bsd-3)))
+
+(define-public ghc-cereal
+  (package
+    (name "ghc-cereal")
+    (version "0.5.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/cereal/cereal-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1j7imh2mzqcljld7sx0av69699955rpy3hzivi5723i6a9nszgbs"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-fail" ,ghc-fail)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-cereal-conduit
+  (package
+    (name "ghc-cereal-conduit")
+    (version "0.8.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "cereal-conduit/cereal-conduit-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1srr7agvgfw78q5s1npjq5sgynvhjgllpihiv37ylkwqm4c4ap6r"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-cereal" ,ghc-cereal)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/snoyberg/conduit")
+    (synopsis "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits")
+    (description
+     "This package turn @code{Data.Serialize} @code{Gets} and @code{Puts} into
+@code{Sources}, @code{Sinks}, and @code{Conduits}.")
+    (license license:bsd-3)))
+
+(define-public ghc-cgi
+  (package
+    (name "ghc-cgi")
+    (version "3001.3.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/cgi/cgi-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1hbpplss1m4rdpm4ibip6fpimlhssqa14fl338kl2jbc463i64cj"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "cgi.cabal"
+               (("exceptions < 0\\.9")
+                "exceptions < 0.11")
+               (("time >= 1\\.5 && < 1\\.7")
+                "time >= 1.5 && < 1.9")
+               (("doctest >= 0\\.8 && < 0\\.12")
+                "doctest >= 0.8 && < 0.17")
+               (("QuickCheck >= 2\\.8\\.1 && < 2\\.10")
+                "QuickCheck >= 2.8.1 && < 2.12")))))))
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-multipart" ,ghc-multipart)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-network" ,ghc-network)))
+    (native-inputs
+     `(("ghc-doctest" ,ghc-doctest)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (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 license:bsd-3)))
+
+(define-public ghc-charset
+  (package
+    (name "ghc-charset")
+    (version "0.3.7.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/charset/charset-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-chart
+  (package
+    (name "ghc-chart")
+    (version "1.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/Chart/"
+                           "Chart-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1f5azj17y8xsb3gjhf7gg1gnnlq12rxkmfjmgcly314d7vghs05z"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-colour" ,ghc-colour)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-operational" ,ghc-operational)
+       ("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/timbod7/haskell-chart/wiki")
+    (synopsis "Library for generating 2D charts and plots")
+    (description
+     "This package provides a library for generating 2D charts and plots, with
+backends provided by the @code{Cairo} and @code{Diagrams} libraries.")
+    (license license:bsd-3)))
+
+(define-public ghc-chart-cairo
+  (package
+    (name "ghc-chart-cairo")
+    (version "1.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/Chart-cairo/"
+                           "Chart-cairo-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-cairo" ,ghc-cairo)
+       ("ghc-colour" ,ghc-colour)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-operational" ,ghc-operational)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-chart" ,ghc-chart)))
+    (home-page "https://github.com/timbod7/haskell-chart/wiki")
+    (synopsis "Cairo backend for Charts")
+    (description "This package provides a Cairo vector graphics rendering
+backend for the Charts library.")
+    (license license:bsd-3)))
+
+(define-public ghc-chasingbottoms
+  (package
+    (name "ghc-chasingbottoms")
+    (version "1.3.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/ChasingBottoms/"
+                           "ChasingBottoms-" version ".tar.gz"))
+       (sha256
+        (base32
+         "06cynx6hcbfpky7qq3b3mjjgwbnaxkwin3znbwq4b9ikiw0ng633"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-random" ,ghc-random)
+       ("ghc-syb" ,ghc-syb)))
+    (home-page "https://hackage.haskell.org/package/ChasingBottoms")
+    (synopsis "Testing of partial and infinite values in Haskell")
+    (description
+     ;; FIXME: There should be a @comma{} in the uref text, but it is not
+     ;; rendered properly.
+     "This is a library for testing code involving bottoms or infinite values.
+For the underlying theory and a larger example involving use of QuickCheck,
+see the article
+@uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
+\"Chasing Bottoms A Case Study in Program Verification in the Presence of
+Partial and Infinite Values\"}.")
+    (license license:expat)))
+
+(define-public ghc-cheapskate
+  (package
+    (name "ghc-cheapskate")
+    (version "0.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/cheapskate/cheapskate-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1hiqi7h76shjzs2zj0j8g6wnq2hbiq1hmfafdazr97fba2zl2432"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-xss-sanitize" ,ghc-xss-sanitize)
+       ("ghc-data-default" ,ghc-data-default)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-uniplate" ,ghc-uniplate)))
+    (home-page "https://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
+cross-site scripting (@dfn{XSS}) attacks.")
+    (license license:bsd-3)))
+
+(define-public ghc-chell
+  (package
+    (name "ghc-chell")
+    (version "0.4.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/chell/chell-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "10ingy9qnbmc8cqh4i9pskcw43l0mzk8f3d76b3qz3fig5ary3j9"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-options-bootstrap" ,ghc-options-bootstrap)
+       ("ghc-patience" ,ghc-patience)
+       ("ghc-random" ,ghc-random)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)))
+    (home-page "https://john-millikin.com/software/chell/")
+    (synopsis "Simple and intuitive library for automated testing")
+    (description
+     "Chell is a simple and intuitive library for automated testing.
+It natively supports assertion-based testing, and can use companion
+libraries such as @code{chell-quickcheck} to support more complex
+testing strategies.")
+    (license license:expat)))
+
+(define-public ghc-chell-quickcheck
+  (package
+    (name "ghc-chell-quickcheck")
+    (version "0.2.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/chell-quickcheck/"
+             "chell-quickcheck-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "chell-quickcheck.cabal"
+               (("QuickCheck >= 2\\.3 && < 2\\.11")
+                "QuickCheck >= 2.3 && < 2.12")))))))
+    (inputs
+     `(("ghc-chell" ,ghc-chell)
+       ("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap)
+       ("ghc-random" ,ghc-random)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://john-millikin.com/software/chell/")
+    (synopsis "QuickCheck support for the Chell testing library")
+    (description "More complex tests for @code{chell}.")
+    (license license:expat)))
+
+(define ghc-chell-quickcheck-bootstrap
+  (package
+    (name "ghc-chell-quickcheck-bootstrap")
+    (version "0.2.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/chell-quickcheck/"
+             "chell-quickcheck-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-chell" ,ghc-chell)
+       ("ghc-random" ,ghc-random)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (arguments
+     `(#:tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "chell-quickcheck.cabal"
+               (("QuickCheck >= 2\\.3 && < 2\\.11")
+                "QuickCheck >= 2.3 && < 2.12")))))))
+    (home-page "https://john-millikin.com/software/chell/")
+    (synopsis "QuickCheck support for the Chell testing library")
+    (description "More complex tests for @code{chell}.")
+    (license license:expat)))
+
+(define-public ghc-chunked-data
+  (package
+    (name "ghc-chunked-data")
+    (version "0.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "chunked-data-" version "/"
+                           "chunked-data-" version ".tar.gz"))
+       (sha256
+        (base32
+         "16m7y7fwrirbjbqqcsfmr4yxa9qvfax6r7pw0zl9ky71ms0wa47p"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-vector" ,ghc-vector)
+              ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "https://github.com/snoyberg/mono-traversable")
+    (synopsis "Typeclasses for dealing with various chunked data
+representations for Haskell")
+    (description "This Haskell package was originally present in
+classy-prelude.")
+    (license license:expat)))
+
+(define-public ghc-clock
+  (package
+    (name "ghc-clock")
+    (version "0.7.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "clock/"
+             "clock-" version ".tar.gz"))
+       (sha256
+        (base32 "07v91s20halsqjmziqb1sqjp2sjpckl9by7y28aaklwqi2bh2rl8"))))
+    (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 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.
+(define-public ghc-clock-bootstrap
+  (package
+    (inherit ghc-clock)
+    (name "ghc-clock-bootstrap")
+    (arguments '(#:tests? #f))
+    (inputs '())
+    (properties '((hidden? #t)))))
+
+(define-public ghc-cmark
+  (package
+    (name "ghc-cmark")
+    (version "0.5.6")
+    (source (origin
+              (method url-fetch)
+              ;; XXX As of version 0.5.6, this package bundles libcmark 0.28.0.
+              ;; See cbits/cmark_version.h.
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "cmark/cmark-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1c1j3a8b9qx5zk9myqm3gap8ymz7fipwrdmyfsq9wkkdr9x4np45"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/jgm/commonmark-hs")
+    (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
+    (description
+     "This package provides Haskell bindings for
+@uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
+CommonMark, a fully specified variant of Markdown.  It includes bundled libcmark
+sources, and does not require prior installation of the C library.")
+    (license license:bsd-3)))
+
+(define-public ghc-cmark-gfm
+  (package
+    (name "ghc-cmark-gfm")
+    (version "0.1.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "cmark-gfm/cmark-gfm-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "13b0mqks5c1q989slgsa3ixr5vvkfyic4ynzgv00kgl5qrs7hqk7"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/kivikakk/cmark-gfm-hs")
+    (synopsis
+     "Fast, accurate GitHub Flavored Markdown parser and renderer")
+    (description
+     "This package provides Haskell bindings for libcmark-gfm, the reference
+parser for GitHub Flavored Markdown, a fully specified variant of Markdown.
+It includes sources for libcmark-gfm and does not require prior installation
+of the C library.")
+    (license license:bsd-3)))
+
+(define-public ghc-cmdargs
+  (package
+    (name "ghc-cmdargs")
+    (version "0.10.20")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/cmdargs/cmdargs-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf"))))
+    (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 license:bsd-3)))
+
+(define-public ghc-code-page
+  (package
+  (name "ghc-code-page")
+  (version "0.1.3")
+  (source
+   (origin
+     (method url-fetch)
+     (uri (string-append
+           "https://hackage.haskell.org/package/code-page/code-page-"
+           version ".tar.gz"))
+      (sha256
+       (base32
+        "1491frk4jx6dlhifky9dvcxbsbcfssrz979a5hp5zn061rh8cp76"))))
+  (build-system haskell-build-system)
+  (home-page "https://github.com/RyanGlScott/code-page")
+  (synopsis "Windows code page library for Haskell")
+  (description "A cross-platform library with functions for adjusting
+code pages on Windows.  On all other operating systems, the library does
+nothing.")
+  (license license:bsd-3)))
+
+(define-public ghc-colour
+(package
+  (name "ghc-colour")
+  (version "2.3.4")
+  (source
+   (origin
+     (method url-fetch)
+     (uri (string-append
+           "https://hackage.haskell.org/package/colour/colour-"
+           version ".tar.gz"))
+     (sha256
+      (base32
+       "1sy51nz096sv91nxqk6yk7b92b5a40axv9183xakvki2nc09yhqg"))))
+  (arguments
+   ;; The tests for this package have the following dependency cycle:
+   ;; ghc-test-framework -> ghc-ansi-terminal -> ghc-colour.
+   `(#:tests? #f))
+  (build-system haskell-build-system)
+  (home-page "https://www.haskell.org/haskellwiki/Colour")
+  (synopsis "Model for human colour perception")
+  (description
+   "This package provides a data type for colours and transparency.
+Colours can be blended and composed.  Various colour spaces are
+supported.  A module of colour names (\"Data.Colour.Names\") is provided.")
+  (license license:expat)))
+
+(define-public ghc-comonad
+  (package
+    (name "ghc-comonad")
+    (version "5.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/comonad/comonad-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09g870c4flp4k3fgbibsd0mmfjani1qcpbcl685v8x89kxzrva3q"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)))
+    (inputs
+     `(("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://github.com/ekmett/comonad/")
+    (synopsis "Comonads for Haskell")
+    (description "This library provides @code{Comonad}s for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-concatenative
+  (package
+    (name "ghc-concatenative")
+    (version "1.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/concatenative/concatenative-"
+                    version ".tar.gz"))
+              (sha256
+               (base32
+                "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty")
+    (synopsis "Library for postfix control flow")
+    (description
+     "Concatenative gives Haskell Factor-style combinators and arrows for
+postfix notation.  For more information on stack based languages, see
+@uref{https://concatenative.org}.")
+    (license license:bsd-3)))
+
 (define-public ghc-concurrent-extra
   (package
     (name "ghc-concurrent-extra")
@@ -76,6 +1886,3384 @@ This package was inspired by the concurrency libraries of Java and
 Python.")
     (license license:bsd-3)))
 
+(define-public ghc-concurrent-output
+  (package
+    (name "ghc-concurrent-output")
+    (version "1.10.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/concurrent-output/concurrent-output-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0mwf155w89nbbkjln7hhbn8k3f8p0ylcvgrg31cm7ijpx4499i4c"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-terminal-size" ,ghc-terminal-size)))
+    (home-page
+     "https://hackage.haskell.org/package/concurrent-output")
+    (synopsis
+     "Ungarble output from several threads or commands")
+    (description
+     "Lets multiple threads and external processes concurrently output to the
+console, without it getting all garbled up.
+
+Built on top of that is a way of defining multiple output regions, which are
+automatically laid out on the screen and can be individually updated by
+concurrent threads.  Can be used for progress displays etc.")
+    (license license:bsd-2)))
+
+(define-public ghc-conduit
+  (package
+    (name "ghc-conduit")
+    (version "1.3.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "conduit/conduit-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1sangm0qqi9dzlq95746a3kl14k8b09592a423shxjf2a0b1yx5v"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-mono-traversable" ,ghc-mono-traversable)
+       ("ghc-mmorph" ,ghc-mmorph)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-silently" ,ghc-silently)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-unliftio" ,ghc-unliftio)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-void" ,ghc-void)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-split" ,ghc-split)))
+    (home-page "https://github.com/snoyberg/conduit")
+    (synopsis "Streaming data library ")
+    (description
+     "The conduit package is a solution to the streaming data problem,
+allowing for production, transformation, and consumption of streams of data
+in constant memory.  It is an alternative to lazy I/O which guarantees
+deterministic resource handling, and fits in the same general solution
+space as enumerator/iteratee and pipes.")
+    (license license:expat)))
+
+(define-public ghc-conduit-algorithms
+  (package
+    (name "ghc-conduit-algorithms")
+    (version "0.0.8.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "conduit-algorithms/conduit-algorithms-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "07gx2q3d1bbfw14q41rmqg0i4m018pci10lswc0k1ij6lw7sb9fd"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-bzlib-conduit" ,ghc-bzlib-conduit)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-combinators" ,ghc-conduit-combinators)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-lzma-conduit" ,ghc-lzma-conduit)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-pqueue" ,ghc-pqueue)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-stm-conduit" ,ghc-stm-conduit)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-th" ,ghc-test-framework-th)))
+    (home-page "https://github.com/luispedro/conduit-algorithms#readme")
+    (synopsis "Conduit-based algorithms")
+    (description
+     "This package provides algorithms on @code{Conduits}, including higher
+level asynchronous processing and some other utilities.")
+    (license license:expat)))
+
+(define-public ghc-conduit-combinators
+  (package
+    (name "ghc-conduit-combinators")
+    (version "1.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "conduit-combinators-" version "/"
+                           "conduit-combinators-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1lz70vwp4y4lpsivxl0cshq7aq3968rh48r6rjvpyaj2l0bdj5wp"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-conduit" ,ghc-conduit)
+              ("ghc-conduit-extra" ,ghc-conduit-extra)
+              ("ghc-transformers-base" ,ghc-transformers-base)
+              ("ghc-primitive" ,ghc-primitive)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-void" ,ghc-void)
+              ("ghc-mwc-random" ,ghc-mwc-random)
+              ("ghc-unix-compat" ,ghc-unix-compat)
+              ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+              ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+              ("ghc-resourcet" ,ghc-resourcet)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-chunked-data" ,ghc-chunked-data)
+              ("ghc-mono-traversable" ,ghc-mono-traversable)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-silently" ,ghc-silently)
+                     ("ghc-safe" ,ghc-safe)
+                     ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/snoyberg/mono-traversable")
+    (synopsis "Commonly used conduit functions, for both chunked and
+unchunked data")
+    (description "This Haskell package provides a replacement for Data.Conduit.List,
+as well as a convenient Conduit module.")
+    (license license:expat)))
+
+(define-public ghc-conduit-extra
+  (package
+    (name "ghc-conduit-extra")
+    (version "1.3.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "conduit-extra/conduit-extra-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0jaj350vv6mbb26gdwcqz4gwzfzrjydv5pis2da49wz1npbakcfw"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-typed-process" ,ghc-typed-process)
+       ("ghc-async" ,ghc-async)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (native-inputs
+     `(("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/snoyberg/conduit")
+    (synopsis "Conduit adapters for common libraries")
+    (description
+     "The @code{conduit} package itself maintains relative small dependencies.
+The purpose of this package is to collect commonly used utility functions
+wrapping other library dependencies, without depending on heavier-weight
+dependencies.  The basic idea is that this package should only depend on
+@code{haskell-platform} packages and @code{conduit}.")
+    (license license:expat)))
+
+(define-public ghc-configurator
+  (package
+    (name "ghc-configurator")
+    (version "0.3.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "configurator/configurator-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "http://github.com/bos/configurator")
+    (synopsis "Configuration management")
+    (description
+     "This package provides a configuration management library for programs
+and daemons.  The features include:
+
+@enumerate
+@item Automatic, dynamic reloading in response to modifications to
+  configuration files.
+@item A simple, but flexible, configuration language, supporting several of
+  the most commonly needed types of data, along with interpolation of strings
+  from the configuration or the system environment (e.g. @code{$(HOME)}).
+@item Subscription-based notification of changes to configuration properties.
+@item An @code{import} directive allows the configuration of a complex
+  application to be split across several smaller files, or common configuration
+  data to be shared across several applications.
+@end enumerate\n")
+    (license license:bsd-3)))
+
+(define-public ghc-connection
+  (package
+    (name "ghc-connection")
+    (version "0.2.8")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "connection/connection-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1swkb9w5vx9ph7x55y51dc0srj2z27nd9ibgn8c0qcl6hx7g9cbh"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-byteable" ,ghc-byteable)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-network" ,ghc-network)
+       ("ghc-tls" ,ghc-tls)
+       ("ghc-socks" ,ghc-socks)
+       ("ghc-x509" ,ghc-x509)
+       ("ghc-x509-store" ,ghc-x509-store)
+       ("ghc-x509-system" ,ghc-x509-system)
+       ("ghc-x509-validation" ,ghc-x509-validation)))
+    (home-page "https://github.com/vincenthz/hs-connection")
+    (synopsis "Simple and easy network connections API")
+    (description
+     "This package provides a simple network library for all your connection
+needs.  It provides a very simple API to create sockets to a destination with
+the choice of SSL/TLS, and SOCKS.")
+    (license license:bsd-3)))
+
+(define-public ghc-constraints
+  (package
+    (name "ghc-constraints")
+    (version "0.10.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/constraints/constraints-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1xy3vv78jxc17hm0z7qqspxjwv7l2jbcbj670yrl2f053qkfr02q"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/ekmett/constraints/")
+    (synopsis "Constraint manipulation")
+    (description
+     "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
+They stopped crashing the compiler in GHC 7.6.  This package provides
+a vocabulary for working with them.")
+    (license license:bsd-3)))
+
+(define-public ghc-contravariant
+  (package
+    (name "ghc-contravariant")
+    (version "1.4.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/contravariant/contravariant-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1vfhk8c5cxmmakx7rflap1ipkx5q0j5vnlrcz7yz6y53kxhksgf9"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-void" ,ghc-void)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-statevar" ,ghc-statevar)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page
+     "https://github.com/ekmett/contravariant/")
+    (synopsis "Contravariant functors")
+    (description "Contravariant functors for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-contravariant-extras
+  (package
+    (name "ghc-contravariant-extras")
+    (version "0.3.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "contravariant-extras-" version "/"
+                           "contravariant-extras-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0gg62ccl94kvh7mnvdq09pifqxjx2kgs189si90nmg44bafj7a9n"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tuple-th" ,ghc-tuple-th)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-base-prelude" ,ghc-base-prelude)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "https://github.com/nikita-volkov/contravariant-extras")
+    (synopsis "Extras for the @code{ghc-contravariant} Haskell package")
+    (description "This Haskell package provides extras for the
+@code{ghc-contravariant} package.")
+    (license license:expat)))
+
+(define-public ghc-convertible
+  (package
+    (name "ghc-convertible")
+    (version "1.1.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/convertible/"
+                           "convertible-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "https://hackage.haskell.org/package/convertible")
+    (synopsis "Typeclasses and instances for converting between types")
+    (description
+     "This package provides a typeclass with a single function that is
+designed to help convert between different types: numeric values, dates and
+times, and the like.  The conversions perform bounds checking and return a
+pure @code{Either} value.  This means that you need not remember which specific
+function performs the conversion you desire.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-accessor
+  (package
+    (name "ghc-data-accessor")
+    (version "0.2.2.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/data-accessor/data-accessor-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "1vf2g1gac3rm32g97rl0fll51m88q7ry4m6khnl5j47qsmx24r9l"))))
+    (build-system haskell-build-system)
+    (home-page "https://www.haskell.org/haskellwiki/Record_access")
+    (synopsis
+     "Haskell utilities for accessing and manipulating fields of records")
+    (description "This package provides Haskell modules for accessing and
+manipulating fields of records.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-accessor-transformers
+  (package
+    (name "ghc-data-accessor-transformers")
+    (version "0.2.1.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/data-accessor-transformers/"
+             "data-accessor-transformers-" version ".tar.gz"))
+       (sha256
+        (base32 "0yp030vafbpddl27m606aibbbr5ar5j5bsv4bksscz3cq4yq5j10"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-data-accessor" ,ghc-data-accessor)))
+    (home-page "https://www.haskell.org/haskellwiki/Record_access")
+    (synopsis "Use Accessor to access state in transformers State monad")
+    (description "This package provides Haskell modules to allow use of
+Accessor to access state in transformers State monad.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-default
+  (package
+    (name "ghc-data-default")
+    (version "0.7.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/data-default/data-default-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "04d5n8ybmcxba9qb6h389w9zfq1lvj81b82jh6maqp6pkhkmvydh"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-data-default-class"
+        ,ghc-data-default-class)
+       ("ghc-data-default-instances-base"
+        ,ghc-data-default-instances-base)
+       ("ghc-data-default-instances-containers"
+        ,ghc-data-default-instances-containers)
+       ("ghc-data-default-instances-dlist"
+        ,ghc-data-default-instances-dlist)
+       ("ghc-data-default-instances-old-locale"
+        ,ghc-data-default-instances-old-locale)))
+    (home-page "https://hackage.haskell.org/package/data-default")
+    (synopsis "Types with default values")
+    (description
+     "This package defines a class for types with a default value, and
+provides instances for types from the base, containers, dlist and old-locale
+packages.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-default-class
+  (package
+    (name "ghc-data-default-class")
+    (version "0.1.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/data-default-class/"
+             "data-default-class-" version ".tar.gz"))
+       (sha256
+        (base32 "0miyjz8d4jyvqf2vp60lyfbnflx6cj2k8apmm9ly1hq0y0iv80ag"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/data-default-class")
+    (synopsis "Types with default values")
+    (description
+     "This package defines a class for types with default values.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-base
+  (package
+    (name "ghc-data-default-instances-base")
+    (version "0.1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "data-default-instances-base/"
+             "data-default-instances-base-" version ".tar.gz"))
+       (sha256
+        (base32 "0ym1sw3ssdzzifxxhh76qlv8kkmb2iclc158incv1dklyr9y8kw4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-data-default-class" ,ghc-data-default-class)))
+    (home-page "https://hackage.haskell.org/package/data-default-instances-base")
+    (synopsis "Default instances for types in base")
+    (description
+     "This package provides default instances for types from the base
+package.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-containers
+  (package
+    (name "ghc-data-default-instances-containers")
+    (version "0.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "data-default-instances-containers/"
+             "data-default-instances-containers-" version ".tar.gz"))
+       (sha256
+        (base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-data-default-class" ,ghc-data-default-class)))
+    (home-page "https://hackage.haskell.org/package/data-default-instances-containers")
+    (synopsis "Default instances for types in containers")
+    (description "Provides default instances for types from the containers
+package.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-dlist
+  (package
+    (name "ghc-data-default-instances-dlist")
+    (version "0.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "data-default-instances-dlist/"
+             "data-default-instances-dlist-" version ".tar.gz"))
+       (sha256
+        (base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-dlist" ,ghc-dlist)))
+    (home-page "https://hackage.haskell.org/package/data-default-instances-dlist")
+    (synopsis "Default instances for types in dlist")
+    (description "Provides default instances for types from the dlist
+package.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-old-locale
+  (package
+    (name "ghc-data-default-instances-old-locale")
+    (version "0.0.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (string-append
+              "https://hackage.haskell.org/package/"
+              "data-default-instances-old-locale/"
+              "data-default-instances-old-locale-" version ".tar.gz"))
+        (sha256
+          (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (home-page
+      "https://hackage.haskell.org/package/data-default-instances-old-locale")
+    (synopsis "Default instances for types in old-locale")
+    (description "Provides Default instances for types from the old-locale
+  package.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-hash
+  (package
+    (name "ghc-data-hash")
+    (version "0.2.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/data-hash"
+                           "/data-hash-" version ".tar.gz"))
+       (sha256
+        (base32 "1ghbqvc48gf9p8wiy71hdpaj7by3b9cw6wgwi3qqz8iw054xs5wi"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://hackage.haskell.org/package/data-hash")
+    (synopsis "Combinators for building fast hashing functions")
+    (description
+     "This package provides combinators for building fast hashing functions.
+It includes hashing functions for all basic Haskell98 types.")
+    (license license:bsd-3)))
+
+(define-public ghc-data-ordlist
+  (package
+    (name "ghc-data-ordlist")
+    (version "0.4.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/data-ordlist/data-ordlist-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/data-ordlist")
+    (synopsis "Set and bag operations on ordered lists")
+    (description
+     "This module provides set and multiset operations on ordered lists.")
+    (license license:bsd-3)))
+
+(define-public ghc-deepseq-generics
+  (package
+    (name "ghc-deepseq-generics")
+    (version "0.2.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "deepseq-generics/deepseq-generics-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "17bwghc15mc9pchfd1w46jh2p3wzc86aj6a537wqwxn08rayzcxh"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "1pnidf8w8x0w5fsqgv8hhrw07slmhxwy5x4fikgk0bd6k76aqicb")))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://github.com/hvr/deepseq-generics")
+    (synopsis "Generic RNF implementation")
+    (description
+     "This package provides a @code{GHC.Generics}-based
+@code{Control.DeepSeq.Generics.genericRnf} function which can be used for
+providing an @code{rnf} implementation.")
+    (license license:bsd-3)))
+
+(define-public ghc-descriptive
+  (package
+    (name "ghc-descriptive")
+    (version "0.9.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/descriptive/descriptive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0y5693zm2kvqjilybbmrcv1g6n6x2p6zjgi0k0axjw1sdhh1g237"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page
+     "https://github.com/chrisdone/descriptive")
+    (synopsis
+     "Self-describing consumers/parsers: forms, cmd-line args, JSON, etc.")
+    (description
+     "This package provides datatypes and functions for creating consumers
+and parsers with useful semantics.")
+    (license license:bsd-3)))
+
+(define-public ghc-diff
+  (package
+    (name "ghc-diff")
+    (version "0.3.4")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "Diff/Diff-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0bqcdvhxx8dmqc3793m6axg813wv9ldz2j37f1wygbbrbbndmdvp"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://hub.darcs.net/sterlingclover/Diff")
+    (synopsis "O(ND) diff algorithm in Haskell")
+    (description
+     "This package provides an implementation of the standard diff algorithm,
+and utilities for pretty printing.")
+    (license license:bsd-3)))
+
+(define-public ghc-disk-free-space
+  (package
+    (name "ghc-disk-free-space")
+    (version "0.1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "disk-free-space/disk-free-space-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "07rqj8k1vh3cykq9yidpjxhgh1f7vgmjs6y1nv5kq2217ff4yypi"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/redneb/disk-free-space")
+    (synopsis "Retrieve information about disk space usage")
+    (description "A cross-platform library for retrieving information about
+disk space usage.")
+    (license license:bsd-3)))
+
+(define-public ghc-distributive
+  (package
+    (name "ghc-distributive")
+    (version "0.5.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/distributive/distributive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0y566r97sfyvhsmd4yxiz4ns2mqgwf5bdbp56wgxl6wlkidq0wwi"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("6" "06bd38rf31yrvvy989r44pm0id3dsxwcp6nxg7wk6ccj3n2b8rzk")))
+    (inputs
+     `(("ghc-tagged" ,ghc-tagged)
+       ("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-generic-deriving" ,ghc-generic-deriving)))
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/ekmett/distributive/")
+    (synopsis "Distributive functors for Haskell")
+    (description "This package provides distributive functors for Haskell.
+Dual to @code{Traversable}.")
+    (license license:bsd-3)))
+
+(define-public ghc-dlist
+  (package
+    (name "ghc-dlist")
+    (version "0.8.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/dlist/dlist-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0yirrh0s6acjy9hhvf5fqg2d6q5y6gm9xs04v6w1imndh1xqdwdc"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/spl/dlist")
+    (synopsis "Difference lists")
+    (description
+     "Difference lists are a list-like type supporting O(1) append.  This is
+particularly useful for efficient logging and pretty printing (e.g. with the
+Writer monad), where list append quickly becomes too expensive.")
+    (license license:bsd-3)))
+
+(define-public ghc-doctemplates
+  (package
+    (name "ghc-doctemplates")
+    (version "0.2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "doctemplates/doctemplates-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1gyckfg3kgvzhxw14i7iwrw0crygvsp86sy53bbr1yn7bxbgn33b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-scientific" ,ghc-scientific)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://github.com/jgm/doctemplates#readme")
+    (synopsis "Pandoc-style document templates")
+    (description
+     "This package provides a simple text templating system used by pandoc.")
+    (license license:bsd-3)))
+
+(define-public ghc-doctest
+  (package
+    (name "ghc-doctest")
+    (version "0.16.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/doctest/doctest-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0hkccch65s3kp0b36h7bqhilnpi4bx8kngncm7ma9vbd3dwacjdv"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))          ; FIXME: missing test framework
+    (inputs
+     `(("ghc-syb" ,ghc-syb)
+       ("ghc-paths" ,ghc-paths)
+       ("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-code-page" ,ghc-code-page)
+       ("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{https://docs.python.org/library/doctest.html, the Doctest website}.")
+    (license license:expat)))
+
+(define-public ghc-double-conversion
+  (package
+    (name "ghc-double-conversion")
+    (version "2.0.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "double-conversion/double-conversion-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/double-conversion")
+    (synopsis "Fast conversion between double precision floating point and text")
+    (description
+     "This package provides a library that performs fast, accurate conversion
+between double precision floating point and text.")
+    (license license:bsd-3)))
+
+(define-public ghc-easy-file
+  (package
+    (name "ghc-easy-file")
+    (version "0.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/easy-file/easy-file-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0zmlcz723051qpn8l8vi51c5rx1blwrw4094jcshkmj8p9r2xxaj"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://github.com/kazu-yamamoto/easy-file")
+    (synopsis "File handling library for Haskell")
+    (description "This library provides file handling utilities for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-easyplot
+  (package
+    (name "ghc-easyplot")
+    (version "1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/easyplot/easyplot-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "18kndgvdj2apjpfga6fp7m16y1gx8zrwp3c5vfj03sx4v6jvciqk"))))
+    (build-system haskell-build-system)
+    (propagated-inputs `(("gnuplot" ,gnuplot)))
+    (arguments
+     `(#:phases (modify-phases %standard-phases
+                  (add-after 'unpack 'fix-setup-suffix
+                    (lambda _ (rename-file "Setup.lhs" "Setup.hs") #t)))))
+    (home-page "https://hub.darcs.net/scravy/easyplot")
+    (synopsis "Haskell plotting library based on gnuplot")
+    (description "This package provides a plotting library for
+Haskell, using gnuplot for rendering.")
+    (license license:expat)))
+
+(define-public ghc-echo
+  (package
+    (name "ghc-echo")
+    (version "0.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/echo/echo-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1vw5ykpwhr39wc0hhcgq3r8dh59zq6ib4zxbz1qd2wl21wqhfkvh"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l")))
+    (home-page "https://github.com/RyanGlScott/echo")
+    (synopsis "Echo terminal input portably")
+    (description "The @code{base} library exposes the @code{hGetEcho} and
+@code{hSetEcho} functions for querying and setting echo status, but
+unfortunately, neither function works with MinTTY consoles on Windows.
+This library provides an alternative interface which works with both
+MinTTY and other consoles.")
+    (license license:bsd-3)))
+
+(define-public ghc-edisonapi
+  (package
+    (name "ghc-edisonapi")
+    (version "1.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/EdisonAPI"
+                           "/EdisonAPI-" version ".tar.gz"))
+       (sha256
+        (base32 "0vmmlsj8ggbpwx6fkf5fvb6jp0zpx6iba6b28m80lllr2p8bi8wm"))))
+    (build-system haskell-build-system)
+    (home-page "http://rwd.rdockins.name/edison/home/")
+    (synopsis "Library of efficient, purely-functional data structures (API)")
+    (description
+     "Edison is a library of purely functional data structures written by
+Chris Okasaki.  It is named after Thomas Alva Edison and for the mnemonic
+value EDiSon (Efficient Data Structures).  Edison provides several families of
+abstractions, each with multiple implementations.  The main abstractions
+provided by Edison are: Sequences such as stacks, queues, and dequeues;
+Collections such as sets, bags and heaps; and Associative Collections such as
+finite maps and priority queues where the priority and element are distinct.")
+    (license license:expat)))
+
+(define-public ghc-edisoncore
+  (package
+    (name "ghc-edisoncore")
+    (version "1.3.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/EdisonCore"
+                           "/EdisonCore-" version ".tar.gz"))
+       (sha256
+        (base32 "0fgj5iwiv3v2gdgx7kjcr15dcs4x1kvmjspp3p99wyhh0x6h3ikk"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-edisonapi" ,ghc-edisonapi)))
+    (home-page "http://rwd.rdockins.name/edison/home/")
+    (synopsis "Library of efficient, purely-functional data structures")
+    (description
+     "This package provides the core Edison data structure implementations,
+including multiple sequence, set, bag, and finite map concrete implementations
+with various performance characteristics.")
+    (license license:expat)))
+
+(define-public ghc-edit-distance
+  (package
+    (name "ghc-edit-distance")
+    (version "0.2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/edit-distance"
+                           "/edit-distance-" version ".tar.gz"))
+       (sha256
+        (base32 "0jkca97zyv23yyilp3jydcrzxqhyk27swhzh82llvban5zp8b21y"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "edit-distance.cabal"
+               (("QuickCheck >= 2\\.4 && <2\\.9")
+                "QuickCheck >= 2.4 && < 2.12")))))))
+    (inputs
+     `(("ghc-random" ,ghc-random)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/phadej/edit-distance")
+    (synopsis "Levenshtein and restricted Damerau-Levenshtein edit distances")
+    (description
+     "This package provides optimized functions to determine the edit
+distances for fuzzy matching, including Levenshtein and restricted
+Damerau-Levenshtein algorithms.")
+    (license license:bsd-3)))
+
+(define-public ghc-either
+  (package
+    (name "ghc-either")
+    (version "5.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "either-" version "/"
+                           "either-" version ".tar.gz"))
+       (sha256
+        (base32
+         "064hjfld7dkzs78sy30k5qkiva3hx24rax6dvzz5ygr2c0zypdkc"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-bifunctors" ,ghc-bifunctors)
+              ("ghc-exceptions" ,ghc-exceptions)
+              ("ghc-free" ,ghc-free)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-manodrandom" ,ghc-monadrandom)
+              ("ghc-mmorph" ,ghc-mmorph)
+              ("ghc-profunctors" ,ghc-profunctors)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-semigroupoids" ,ghc-semigroupoids)
+              ("ghc-transformers-base" ,ghc-transformers-base)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/ekmett/either")
+    (synopsis "Provides an either monad transformer for Haskell")
+    (description "This Haskell package provides an either monad transformer.")
+    (license license:bsd-3)))
+
+(define-public ghc-email-validate
+  (package
+    (name "ghc-email-validate")
+    (version "2.3.2.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "email-validate/email-validate-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0chgylvc8xmhp933rdbmpg5sv4y7yg2h6kbf0ip1dzmbd5p55pa5"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-doctest" ,ghc-doctest)))
+    (home-page
+     "https://github.com/Porges/email-validate-hs")
+    (synopsis "Email address validator for Haskell")
+    (description
+     "This Haskell package provides a validator that can validate an email
+address string against RFC 5322.")
+    (license license:bsd-3)))
+
+(define-public ghc-enclosed-exceptions
+  (package
+    (name "ghc-enclosed-exceptions")
+    (version "1.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "enclosed-exceptions/enclosed-exceptions-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1fghjj7nkiddrf03ks8brjpr5x25yi9fs7xg6adbi4mc2gqr6vdg"))))
+    (build-system haskell-build-system)
+    ;; FIXME: one of the tests blocks forever:
+    ;; "thread blocked indefinitely in an MVar operation"
+    (arguments '(#:tests? #f))
+    (inputs
+     `(("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-async" ,ghc-async)
+       ("ghc-transformers-base" ,ghc-transformers-base)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/jcristovao/enclosed-exceptions")
+    (synopsis "Catch all exceptions from within an enclosed computation")
+    (description
+     "This library implements a technique to catch all exceptions raised
+within an enclosed computation, while remaining responsive to (external)
+asynchronous exceptions.")
+    (license license:expat)))
+
+(define-public ghc-equivalence
+  (package
+    (name "ghc-equivalence")
+    (version "0.3.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/equivalence"
+                           "/equivalence-" version ".tar.gz"))
+       (sha256
+        (base32 "0a85bdyyvjqs5z4kfhhf758210k9gi9dv42ik66a3jl0z7aix8kx"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-stmonadtrans" ,ghc-stmonadtrans)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/pa-ba/equivalence")
+    (synopsis "Maintaining an equivalence relation implemented as union-find")
+    (description
+     "This is an implementation of Tarjan's Union-Find algorithm (Robert E.@:
+Tarjan.  \"Efficiency of a Good But Not Linear Set Union Algorithm\",JACM
+22(2), 1975) in order to maintain an equivalence relation.  This
+implementation is a port of the @code{union-find} package using the @code{ST}
+monad transformer (instead of the IO monad).")
+    (license license:bsd-3)))
+
+(define-public ghc-erf
+  (package
+    (name "ghc-erf")
+    (version "2.0.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "erf-" version "/"
+                           "erf-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/erf")
+    (synopsis "The error function, erf, and related functions for Haskell")
+    (description "This Haskell library provides a type class for the
+error function, erf, and related functions.  Instances for Float and
+Double.")
+    (license license:bsd-3)))
+
+(define-public ghc-errorcall-eq-instance
+  (package
+    (name "ghc-errorcall-eq-instance")
+    (version "0.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "errorcall-eq-instance/errorcall-eq-instance-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0hqw82m8bbrxy5vgdwb83bhzdx070ibqrm9rshyja7cb808ahijm"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "http://hackage.haskell.org/package/errorcall-eq-instance")
+    (synopsis "Orphan Eq instance for ErrorCall")
+    (description
+     "Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}.
+This package provides an orphan instance.")
+    (license license:expat)))
+
+(define-public ghc-errors
+  (package
+    (name "ghc-errors")
+    (version "2.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "errors-" version "/"
+                           "errors-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0x8znwn31qcx6kqx99wp7bc86kckfb39ncz3zxvj1s07kxlfawk7"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-unexceptionalio" ,ghc-unexceptionalio)
+       ("ghc-safe" ,ghc-safe)))
+    (home-page "https://github.com/gabriel439/haskell-errors-library")
+    (synopsis "Error handling library for Haskell")
+    (description "This library encourages an error-handling style that
+directly uses the type system, rather than out-of-band exceptions.")
+    (license license:bsd-3)))
+
+(define-public ghc-esqueleto
+  (let ((version "2.5.3")
+        (revision "1")
+        (commit "b81e0d951e510ebffca03c5a58658ad884cc6fbd"))
+    (package
+      (name "ghc-esqueleto")
+      (version (git-version version revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/bitemyapp/esqueleto")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32
+           "0lz1qxms7cfg5p3j37inlych0r2fwhm8xbarcys3df9m7jy9nixa"))))
+      (build-system haskell-build-system)
+      (arguments
+       `(#:haddock? #f  ; Haddock reports an internal error.
+         #:phases
+         (modify-phases %standard-phases
+           ;; This package normally runs tests for the MySQL, PostgreSQL, and
+           ;; SQLite backends.  Since we only have Haskell packages for
+           ;; SQLite, we remove the other two test suites.  FIXME: Add the
+           ;; other backends and run all three test suites.
+           (add-before 'configure 'remove-non-sqlite-test-suites
+             (lambda _
+               (use-modules (ice-9 rdelim))
+               (with-atomic-file-replacement "esqueleto.cabal"
+                 (lambda (in out)
+                   (let loop ((line (read-line in 'concat)) (deleting? #f))
+                     (cond
+                      ((eof-object? line) #t)
+                      ((string-every char-set:whitespace line)
+                       (unless deleting? (display line out))
+                       (loop (read-line in 'concat) #f))
+                      ((member line '("test-suite mysql\n"
+                                      "test-suite postgresql\n"))
+                       (loop (read-line in 'concat) #t))
+                      (else
+                       (unless deleting? (display line out))
+                       (loop (read-line in 'concat) deleting?)))))))))))
+      (inputs
+       `(("ghc-blaze-html" ,ghc-blaze-html)
+         ("ghc-conduit" ,ghc-conduit)
+         ("ghc-monad-logger" ,ghc-monad-logger)
+         ("ghc-persistent" ,ghc-persistent)
+         ("ghc-resourcet" ,ghc-resourcet)
+         ("ghc-tagged" ,ghc-tagged)
+         ("ghc-unliftio" ,ghc-unliftio)
+         ("ghc-unordered-containers" ,ghc-unordered-containers)))
+      (native-inputs
+       `(("ghc-hspec" ,ghc-hspec)
+         ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)
+         ("ghc-persistent-template" ,ghc-persistent-template)))
+      (home-page "https://github.com/bitemyapp/esqueleto")
+      (synopsis "Type-safe embedded domain specific language for SQL queries")
+      (description "This library provides a type-safe embedded domain specific
+language (EDSL) for SQL queries that works with SQL backends as provided by
+@code{ghc-persistent}.  Its language closely resembles SQL, so you don't have
+to learn new concepts, just new syntax, and it's fairly easy to predict the
+generated SQL and optimize it for your backend.")
+      (license license:bsd-3))))
+
+(define-public ghc-exactprint
+  (package
+    (name "ghc-exactprint")
+    (version "0.5.6.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "ghc-exactprint/ghc-exactprint-" version ".tar.gz"))
+       (sha256
+        (base32
+         "141k6qiys0m0r4br7ikp4i546vs3xcil9cwglzcdfcbnb5nj1z87"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-paths" ,ghc-paths)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-free" ,ghc-free)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-diff" ,ghc-diff)
+       ("ghc-silently" ,ghc-silently)
+       ("ghc-filemanip" ,ghc-filemanip)))
+    (home-page
+     "http://hackage.haskell.org/package/ghc-exactprint")
+    (synopsis "ExactPrint for GHC")
+    (description
+     "Using the API Annotations available from GHC 7.10.2, this library
+provides a means to round-trip any code that can be compiled by GHC, currently
+excluding @file{.lhs} files.")
+    (license license:bsd-3)))
+
+(define-public ghc-exceptions
+  (package
+    (name "ghc-exceptions")
+    (version "0.10.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/exceptions/exceptions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ms9zansv0pwzwdjncvx4kf18lnkjy2p61hvjhvxmjx5bqp93p8y"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://github.com/ekmett/exceptions/")
+    (synopsis "Extensible optionally-pure exceptions")
+    (description "This library provides extensible optionally-pure exceptions
+for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-executable-path
+  (package
+    (name "ghc-executable-path")
+    (version "0.0.3.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "executable-path/executable-path-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "0vxwmnsvx13cawcyhbyljkds0l1vr996ijldycx7nj0asjv45iww"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/executable-path")
+    (synopsis "Find out the full path of the executable")
+    (description
+     "The documentation of @code{System.Environment.getProgName} says that
+\"However, this is hard-to-impossible to implement on some non-Unix OSes, so
+instead, for maximum portability, we just return the leafname of the program
+as invoked.\" This library tries to provide the missing path.")
+    (license license:public-domain)))
+
+(define-public ghc-extensible-exceptions
+  (package
+    (name "ghc-extensible-exceptions")
+    (version "0.1.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "extensible-exceptions/extensible-exceptions-"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/extensible-exceptions")
+    (synopsis "Extensible exceptions for Haskell")
+    (description
+     "This package provides extensible exceptions for both new and old
+versions of GHC (i.e., < 6.10).")
+    (license license:bsd-3)))
+
+(define-public ghc-extra
+  (package
+    (name "ghc-extra")
+    (version "1.6.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/extra/extra-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0xxcpb00pgwi9cmy6a7ghh6rblxry42p8pz5ssfgj20fs1xwzj1b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-clock" ,ghc-clock)
+       ("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 license:bsd-3)))
+
+(define-public ghc-fail
+  (package
+    (name "ghc-fail")
+    (version "4.9.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/fail/fail-"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "18nlj6xvnggy61gwbyrpmvbdkq928wv0wx2zcsljb52kbhddnp3d"))))
+    (build-system haskell-build-system)
+    (arguments `(#:haddock? #f)) ; Package contains no documentation.
+    (home-page "https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail")
+    (synopsis "Forward-compatible MonadFail class")
+    (description
+     "This package contains the @code{Control.Monad.Fail} module providing the
+@uref{https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail, MonadFail}
+class that became available in
+@uref{https://hackage.haskell.org/package/base-4.9.0.0, base-4.9.0.0} for
+older @code{base} package versions.  This package turns into an empty package
+when used with GHC versions which already provide the
+@code{Control.Monad.Fail} module.")
+    (license license:bsd-3)))
+
+(define-public ghc-fast-logger
+  (package
+    (name "ghc-fast-logger")
+    (version "2.4.11")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/fast-logger/fast-logger-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ad2vq4nifdxshqk9yrmghqizhkgybfz134kpr6padglb2mxxrdv"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-auto-update" ,ghc-auto-update)
+       ("ghc-easy-file" ,ghc-easy-file)
+       ("ghc-unix-time" ,ghc-unix-time)))
+    (native-inputs
+     `(("hspec-discover" ,hspec-discover)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/fast-logger")
+    (synopsis "Fast logging system")
+    (description "This library provides a fast logging system for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-feed
+  (package
+    (name "ghc-feed")
+    (version "1.0.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "feed/feed-" version ".tar.gz"))
+       (sha256
+        (base32
+         "05rgg7x1984mgfhkmz792xj8lhwjgznixhygzr8blf517lns2nck"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("4" "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d")))
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-old-time" ,ghc-old-time)
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-xml-conduit" ,ghc-xml-conduit)
+       ("ghc-xml-types" ,ghc-xml-types)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://github.com/bergmark/feed")
+    (synopsis "Haskell package for handling various syndication formats")
+    (description "This Haskell package includes tools for generating and
+consuming feeds in both RSS (Really Simple Syndication) and Atom format.")
+    (license license:bsd-3)))
+
+(define-public ghc-fgl
+  (package
+    (name "ghc-fgl")
+    (version "5.6.0.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/fgl/fgl-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1i6cp4b3w7sjk7y1dq3fh6bci2sm5h3lnbbaw9ln19nwncg2wwll"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "fgl.cabal"
+               (("QuickCheck >= 2\\.8 && < 2\\.10")
+                "QuickCheck >= 2.8 && < 2.12")
+               (("hspec >= 2\\.1 && < 2\\.5")
+                "hspec >= 2.1 && < 2.6")))))))
+    (inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell")
+    (synopsis
+     "Martin Erwig's Functional Graph Library")
+    (description "The functional graph library, FGL, is a collection of type
+and function definitions to address graph problems.  The basis of the library
+is an inductive definition of graphs in the style of algebraic data types that
+encourages inductive, recursive definitions of graph algorithms.")
+    (license license:bsd-3)))
+
+(define-public ghc-fgl-arbitrary
+  (package
+    (name "ghc-fgl-arbitrary")
+    (version "0.2.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/fgl-arbitrary/fgl-arbitrary-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0ln1szgfy8fa78l3issq4fx3aqnnd54w3cb4wssrfi48vd5rkfjm"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "fgl-arbitrary.cabal"
+               (("QuickCheck >= 2\\.3 && < 2\\.10")
+                "QuickCheck >= 2.3 && < 2.12")
+               (("hspec >= 2\\.1 && < 2\\.5")
+                "hspec >= 2.1 && < 2.6")))))))
+    (inputs
+     `(("ghc-fgl" ,ghc-fgl)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/fgl-arbitrary")
+    (synopsis "QuickCheck support for fgl")
+    (description
+     "Provides Arbitrary instances for fgl graphs to avoid adding a
+QuickCheck dependency for fgl whilst still making the instances
+available to others.  Also available are non-fgl-specific functions
+for generating graph-like data structures.")
+    (license license:bsd-3)))
+
+(define-public ghc-file-embed
+  (package
+    (name "ghc-file-embed")
+    (version "0.0.10.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/file-embed/"
+                           "file-embed-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0lj164cnzqyd487mli91nnr7137a4h4qsasfwsnsh77sx12fpk9k"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/snoyberg/file-embed")
+    (synopsis "Use Template Haskell to embed file contents directly")
+    (description
+     "This package allows you to use Template Haskell to read a file or all
+the files in a directory, and turn them into @code{(path, bytestring)} pairs
+embedded in your Haskell code.")
+    (license license:bsd-3)))
+
+(define-public ghc-filemanip
+  (package
+    (name "ghc-filemanip")
+    (version "0.3.6.3")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "filemanip/filemanip-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-unix-compat" ,ghc-unix-compat)))
+    (home-page "https://github.com/bos/filemanip")
+    (synopsis "File and directory manipulation for Haskell")
+    (description
+     "This package provides a Haskell library for working with files and
+directories.  It includes code for pattern matching, finding files, modifying
+file contents, and more.")
+    (license license:bsd-3)))
+
+(define-public ghc-findbin
+  (package
+    (name "ghc-findbin")
+    (version "0.0.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/FindBin/FindBin-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/audreyt/findbin")
+    (synopsis "Get the absolute path of the running program")
+    (description
+     "This module locates the full directory of the running program, to allow
+the use of paths relative to it.  FindBin supports invocation of Haskell
+programs via \"ghci\", via \"runhaskell/runghc\", as well as compiled as
+an executable.")
+    (license license:bsd-3)))
+
+(define-public ghc-fingertree
+  (package
+    (name "ghc-fingertree")
+    (version "0.1.4.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/fingertree/fingertree-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "192fyzv0pn1437wdpqg1l80rswkk4rw3w61r4bq7dhv354bdqy4p"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-fixed
+  (package
+    (name "ghc-fixed")
+    (version "0.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/fixed/fixed-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1qhmwx8iqshns0crmr9d2f8hm65jxbcp3dvv0c39v34ra7if3a94"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/ekmett/fixed")
+    (synopsis "Signed 15.16 precision fixed point arithmetic")
+    (description
+     "This package provides functions for signed 15.16 precision fixed point
+arithmetic.")
+    (license license:bsd-3)))
+
+(define-public ghc-foldl
+  (package
+    (name "ghc-foldl")
+    (version "1.4.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "foldl-" version "/"
+                           "foldl-" version ".tar.gz"))
+       (sha256
+        (base32
+         "13n0ca3hw5jzqf6rxsdbhbwkn61a9zlm13f0f205s60j3sc72jzk"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
+              ("ghc-primitive" ,ghc-primitive)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-contravariant" ,ghc-contravariant)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-profunctors" ,ghc-profunctors)
+              ("ghc-semigroupoids" ,ghc-semigroupoids)
+              ("ghc-comonad" ,ghc-comonad)
+              ("ghc-vector-builder" ,ghc-vector-builder)))
+    (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library")
+    (synopsis "Composable, streaming, and efficient left folds for Haskell")
+    (description "This Haskell library provides strict left folds that stream
+in constant memory, and you can combine folds using @code{Applicative} style
+to derive new folds.  Derived folds still traverse the container just once
+and are often as efficient as hand-written folds.")
+    (license license:bsd-3)))
+
+(define-public ghc-foundation
+  (package
+    (name "ghc-foundation")
+    (version "0.0.21")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "foundation/foundation-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1q43y8wfj0wf9gdq2kzphwjwq6m5pvryy1lqgk954aq5z3ks1lsf"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-basement" ,ghc-basement)))
+    (home-page "https://github.com/haskell-foundation/foundation")
+    (synopsis "Alternative prelude with batteries and no dependencies")
+    (description
+     "This package provides a custom prelude with no dependencies apart from
+the base package.
+
+Foundation has the following goals:
+
+@enumerate
+@item provide a base like sets of modules that provide a consistent set of
+   features and bugfixes across multiple versions of GHC (unlike base).
+@item provide a better and more efficient prelude than base's prelude.
+@item be self-sufficient: no external dependencies apart from base;
+@item provide better data-types: packed unicode string by default, arrays;
+@item Numerical classes that better represent mathematical things (no more
+   all-in-one @code{Num});
+@item I/O system with less lazy IO.
+@end enumerate\n")
+    (license license:bsd-3)))
+
+(define-public ghc-free
+  (package
+    (name "ghc-free")
+    (version "5.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/free/free-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "15m3n9vhz7z3kzv1w3wlfa3x8jp4cbrkwmrcjr7jlx39iqffn1gg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-prelude-extras" ,ghc-prelude-extras)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-fsnotify
+  (package
+    (name "ghc-fsnotify")
+    (version "0.3.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/fsnotify/"
+                    "fsnotify-" version ".tar.gz"))
+              (sha256
+               (base32
+                "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-hinotify" ,ghc-hinotify)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-random" ,ghc-random)
+       ("ghc-shelly" ,ghc-shelly)
+       ("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://github.com/haskell-fswatch/hfsnotify")
+    (synopsis "Cross platform library for file change notification.")
+    (description "Cross platform library for file creation, modification, and
+deletion notification. This library builds upon existing libraries for platform
+specific Windows, Mac, and Linux file system event notification.")
+    (license license:bsd-3)))
+
+(define-public ghc-generic-deriving
+  (package
+    (name "ghc-generic-deriving")
+    (version "1.12.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/generic-deriving/generic-deriving-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1i7d6cpj9yhaqb79zays3nqchhaacacjz9bkc0zlwj73y5gvi22n"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-th-abstraction" ,ghc-th-abstraction)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (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 license:bsd-3)))
+
+(define-public ghc-generics-sop
+  (package
+    (name "ghc-generics-sop")
+    (version "0.3.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "generics-sop-" version "/"
+                           "generics-sop-" version ".tar.gz"))
+       (sha256
+        (base32
+         "168v62i845jh9jbfaz3ldz8svz4wmzq9mf2vhb7pxlnbkk8fqq1h"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://github.com/well-typed/generics-sop")
+    (synopsis "Generic Programming using True Sums of Products for Haskell")
+    (description "This Haskell package supports the definition of generic
+functions.  Datatypes are viewed in a uniform, structured way: the choice
+between constructors is represented using an n-ary sum, and the arguments of
+each constructor are represented using an n-ary product.")
+    (license license:bsd-3)))
+
+(define-public ghc-geniplate-mirror
+  (package
+    (name "ghc-geniplate-mirror")
+    (version "0.7.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package"
+                           "/geniplate-mirror"
+                           "/geniplate-mirror-" version ".tar.gz"))
+       (sha256
+        (base32 "1y0m0bw5zpm1y1y6d9qmxj3swl8j8hlw1shxbr5awycf6k884ssb"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/danr/geniplate")
+    (synopsis "Use Template Haskell to generate Uniplate-like functions")
+    (description
+     "Use Template Haskell to generate Uniplate-like functions.  This is a
+maintained mirror of the @uref{https://hackage.haskell.org/package/geniplate,
+geniplate} package, written by Lennart Augustsson.")
+    (license license:bsd-3)))
+
+(define-public ghc-genvalidity
+  (package
+    (name "ghc-genvalidity")
+    (version "0.5.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/genvalidity/genvalidity-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "17ykq38j9a2lzir6dqz5jgy6ndaafrpkhqhcg96c5ppg7wcxaaj0"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-validity" ,ghc-validity)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-hspec-core" ,ghc-hspec-core)))
+    (home-page
+     "https://github.com/NorfairKing/validity")
+    (synopsis
+     "Testing utilities for the @code{validity} library")
+    (description
+     "This package provides testing utilities that are useful in conjunction
+with the @code{Validity} typeclass.")
+    (license license:expat)))
+
+(define-public ghc-genvalidity-property
+  (package
+    (name "ghc-genvalidity-property")
+    (version "0.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "genvalidity-property/genvalidity-property-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0cjw5i2pydidda9bnp6x37ylhxdk9g874x5sadr6sscg5kq85a1b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-genvalidity" ,ghc-genvalidity)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-validity" ,ghc-validity)))
+    (native-inputs `(("ghc-doctest" ,ghc-doctest)))
+    (home-page
+     "https://github.com/NorfairKing/validity")
+    (synopsis
+     "Standard properties for functions on @code{Validity} types")
+    (description
+     "This package supplements the @code{Validity} typeclass with standard
+properties for functions operating on them.")
+    (license license:expat)))
+
+(define-public ghc-gitrev
+  (package
+    (name "ghc-gitrev")
+    (version "1.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/gitrev/gitrev-"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "0cl3lfm6k1h8fxp2vxa6ihfp4v8igkz9h35iwyq2frzm4kdn96d8"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-base-compat" ,ghc-base-compat)))
+    (home-page "https://github.com/acfoltzer/gitrev")
+    (synopsis "Compile git revision info into Haskell projects")
+    (description
+     "This package provides some handy Template Haskell splices for including
+the current git hash and branch in the code of your project.  This is useful
+for including in panic messages, @command{--version} output, or diagnostic
+info for more informative bug reports.")
+    (license license:bsd-3)))
+
+(define-public ghc-glob
+  (package
+    (name "ghc-glob")
+    (version "0.9.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "Glob-" version "/"
+                           "Glob-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1rbwcq9w9951qsnp13vqcm9r01yax2yh1wk8s4zxa3ckk9717iwg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-dlist" ,ghc-dlist)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "http://iki.fi/matti.niemenmaa/glob/")
+    (synopsis "Haskell library matching glob patterns against file paths")
+    (description "This package provides a Haskell library for @dfn{globbing}:
+matching patterns against file paths.")
+    (license license:bsd-3)))
+
+(define-public ghc-gluraw
+  (package
+    (name "ghc-gluraw")
+    (version "2.0.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/GLURaw/GLURaw-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-openglraw" ,ghc-openglraw)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-glut
+  (package
+    (name "ghc-glut")
+    (version "2.7.0.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/GLUT/GLUT-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "01i162fly4q1751fp60lgkzlb8kr0qqbvmxj74zc6skb19qggy2w"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-statevar" ,ghc-statevar)
+       ("ghc-opengl" ,ghc-opengl)
+       ("ghc-openglraw" ,ghc-openglraw)
+       ("freeglut" ,freeglut)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-gnuplot
+  (package
+    (name "ghc-gnuplot")
+    (version "0.5.5.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/gnuplot/gnuplot-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "1mlppnc13ygjzmf6ldydys4wvy35yb3xjwwfgf9rbi7nfcqjr6mn"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-temporary" ,ghc-temporary)
+       ("ghc-utility-ht" ,ghc-utility-ht)
+       ("ghc-data-accessor-transformers" ,ghc-data-accessor-transformers)
+       ("ghc-data-accessor" ,ghc-data-accessor)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("gnuplot" ,gnuplot)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'fix-path-to-gnuplot
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((gnuplot (assoc-ref inputs "gnuplot")))
+               (substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
+                 (("(gnuplotName = ).*$" all cmd)
+                  (string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
+    (home-page "https://www.haskell.org/haskellwiki/Gnuplot")
+    (synopsis "2D and 3D plots using gnuplot")
+    (description "This package provides a Haskell module for creating 2D and
+3D plots using gnuplot.")
+    (license license:bsd-3)))
+
+(define-public ghc-graphviz
+  (package
+    (name "ghc-graphviz")
+    (version "2999.20.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "graphviz/graphviz-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0kj7ap0gnliviq2p8lscw1m06capnsa90vpvcys24nqy5nw2wrp7"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-colour" ,ghc-colour)
+       ("ghc-dlist" ,ghc-dlist)
+       ("ghc-fgl" ,ghc-fgl)
+       ("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
+       ("ghc-polyparse" ,ghc-polyparse)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("graphviz" ,graphviz)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://hackage.haskell.org/package/graphviz")
+    (synopsis "Bindings to Graphviz for graph visualisation")
+    (description
+     "This library provides bindings for the Dot language used by
+the @uref{https://graphviz.org/, Graphviz} suite of programs for
+visualising graphs, as well as functions to call those programs.
+Main features of the graphviz library include:
+
+@enumerate
+@item Almost complete coverage of all Graphviz attributes and syntax
+@item Support for specifying clusters
+@item The ability to use a custom node type
+@item Functions for running a Graphviz layout tool with all specified output types
+@item Generate and parse Dot code with two options: strict and liberal
+@item Functions to convert FGL graphs and other graph-like data structures
+@item Round-trip support for passing an FGL graph through Graphviz to augment node
+and edge labels with positional information, etc.
+@end enumerate\n")
+    (license license:bsd-3)))
+
+(define-public ghc-gtk2hs-buildtools
+  (package
+    (name "ghc-gtk2hs-buildtools")
+    (version "0.13.4.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "gtk2hs-buildtools/gtk2hs-buildtools-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0yg6xmylgpylmnh5g33qwwn5x9bqckdvvv4czqzd9vrr12lnnghg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-random" ,ghc-random)
+       ("ghc-hashtables" ,ghc-hashtables)))
+    (native-inputs
+     `(("ghc-alex" ,ghc-alex)
+       ("ghc-happy" ,ghc-happy)))
+    (home-page "http://projects.haskell.org/gtk2hs/")
+    (synopsis "Tools to build the Gtk2Hs suite of user interface libraries")
+    (description
+     "This package provides a set of helper programs necessary to build the
+Gtk2Hs suite of libraries. These tools include a modified c2hs binding tool
+that is used to generate FFI declarations, a tool to build a type hierarchy
+that mirrors the C type hierarchy of GObjects found in glib, and a generator
+for signal declarations that are used to call back from C to Haskell. These
+tools are not needed to actually run Gtk2Hs programs.")
+    (license license:gpl2)))
+
+(define-public ghc-hackage-security
+  (package
+    (name "ghc-hackage-security")
+    (version "0.5.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "hackage-security/hackage-security-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f)) ; Tests fail because of framework updates.
+    (inputs
+     `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256)
+       ("ghc-ed25519" ,ghc-ed25519)
+       ("ghc-network" ,ghc-network)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-tar" ,ghc-tar)
+       ("ghc-zlib" ,ghc-zlib)))
+    (native-inputs
+     `(("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tar" ,ghc-tar)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-zlib" ,ghc-zlib)))
+    (home-page "https://github.com/haskell/hackage-security")
+    (synopsis "Hackage security library")
+    (description "This Hackage security library provides both server and
+client utilities for securing @uref{http://hackage.haskell.org/, the
+Hackage package server}.  It is based on
+@uref{http://theupdateframework.com/, The Update Framework}, a set of
+recommendations developed by security researchers at various universities
+in the US as well as developers on the @uref{https://www.torproject.org/,
+Tor project}.")
+    (license license:bsd-3)))
+
+(define-public ghc-haddock
+  (package
+    (name "ghc-haddock")
+    (version "2.19.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/haddock/haddock-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         ;; There are four test suites that require the ghc-haddock-test
+         ;; package, which no longer builds with GHC 8.4.3.  This phase
+         ;; removes these four test suites from the Cabal file, so that we
+         ;; do not need ghc-haddock-test as an input.
+         (add-before 'configure 'remove-haddock-test-test-suites
+           (lambda _
+             (use-modules (ice-9 rdelim))
+             (with-atomic-file-replacement "haddock.cabal"
+               (lambda (in out)
+                 (let loop ((line (read-line in 'concat)) (deleting? #f))
+                   (cond
+                    ((eof-object? line) #t)
+                    ((string-every char-set:whitespace line)
+                     (unless deleting? (display line out))
+                     (loop (read-line in 'concat) #f))
+                    ((member line '("test-suite html-test\n"
+                                    "test-suite hypsrc-test\n"
+                                    "test-suite latex-test\n"
+                                    "test-suite hoogle-test\n"))
+                     (loop (read-line in 'concat) #t))
+                    (else
+                     (unless deleting? (display line out))
+                     (loop (read-line in 'concat) deleting?)))))))))))
+    (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://www.haskell.org/haddock/")
+    (synopsis
+     "Documentation-generation tool for Haskell libraries")
+    (description
+     "Haddock is a documentation-generation tool for Haskell libraries.")
+    (license license:bsd-3)))
+
+(define-public ghc-haddock-api
+  (package
+    (name "ghc-haddock-api")
+    (version "2.19.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/haddock-api/haddock-api-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "haddock-api.cabal"
+               (("Cabal           \\^>= 2\\.0\\.0")
+                "Cabal           ^>= 2.2.0")
+               (("hspec           \\^>= 2\\.4\\.4")
+                "hspec            >= 2.4.4 && < 2.6")))))))
+    (inputs
+     `(("ghc-paths" ,ghc-paths)
+       ("ghc-haddock-library" ,ghc-haddock-library)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-haddock-library
+  (package
+    (name "ghc-haddock-library")
+    (version "1.5.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/haddock-library/haddock-library-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1cmbg8l5xrwpliclwy3l057raypjqy0hsg1h1743ahaj8gq10b7z"))
+       (patches (search-patches
+                 "ghc-haddock-library-unbundle.patch"))
+       (modules '((guix build utils)))
+       (snippet '(begin
+                   (delete-file-recursively "vendor")
+                   #t))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'relax-test-suite-dependencies
+           (lambda _
+             (substitute* "haddock-library.cabal"
+               (("base-compat\\s*\\^>= 0\\.9\\.3") "base-compat")
+               (("hspec\\s*\\^>= 2\\.4\\.4") "hspec"))))
+         ;; The release tarball does not contain the "fixtures/examples"
+         ;; directory, which is required for testing.  In the upstream
+         ;; repository, the directory exists and is populated.  Here, we
+         ;; create an empty directory to placate the tests.
+         (add-before 'check 'add-examples-directory
+           (lambda _
+             (mkdir "fixtures/examples")
+             #t)))))
+    (native-inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tree-diff" ,ghc-tree-diff)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-half
+  (package
+    (name "ghc-half")
+    (version "0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/half/half-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "14r0nx8hm5fic9gz0ybjjw4kyc758zfgvhhwvzsshpx5caq6zch6"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/ekmett/half")
+    (synopsis "Half-precision floating-point computations")
+    (description "This library provides a half-precision floating-point
+computation library for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-happy
+  (package
+    (name "ghc-happy")
+    (version "1.19.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/happy/happy-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "138xpxdb7x62lpmgmb6b3v3vgdqqvqn4273jaap3mjmc2gla709y"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'skip-test-issue93
+           (lambda _
+             ;; Tests run out of memory on a system with 2GB of available RAM,
+             ;; in 'issue93.a.hs' and 'issue93.n.hs'.
+             (substitute* "tests/Makefile"
+               ((" issue93.y ") " "))
+             #t)))))
+    (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 license:bsd-3)))
+
+(define-public ghc-hashable
+  (package
+    (name "ghc-hashable")
+    (version "1.2.7.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hashable/hashable-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1gra8gq3kb7b2sd845h55yxlrfqx3ii004c6vjhga8v0b30fzdgc"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-random" ,ghc-random)))
+    (native-inputs
+     `(("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/tibbe/hashable")
+    (synopsis "Class for types that can be converted to a hash value")
+    (description
+     "This package defines a class, @code{Hashable}, for types that can be
+converted to a hash value.  This class exists for the benefit of hashing-based
+data structures.  The package provides instances for basic types and a way to
+combine hash values.")
+    (license license:bsd-3)))
+
+(define-public ghc-hashable-bootstrap
+  (package
+    (inherit ghc-hashable)
+    (name "ghc-hashable-bootstrap")
+    (arguments `(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
+(define-public ghc-hashable-time
+  (package
+    (name "ghc-hashable-time")
+    (version "0.2.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hashable-time/hashable-time-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0k932nyd08l3xxbh2g3n76py2f4kd9yw4s5a065vjz0xp6wjnxdm"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "0rv40xkg3gj8jnqsry1gq3f5s5la6d5arg8fzkirnwdpcgha1as6")))
+    (inputs `(("ghc-hashable" ,ghc-hashable)))
+    (home-page "http://hackage.haskell.org/package/hashable-time")
+    (synopsis "Hashable instances for Data.Time")
+    (description
+     "This package provides @code{Hashable} instances for types in
+@code{Data.Time}.")
+    (license license:bsd-3)))
+
+(define-public ghc-hashtables
+  (package
+    (name "ghc-hashtables")
+    (version "1.2.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hashtables/hashtables-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "1giw9caajr07slf09j7zry9b0kvm4yj9q78zy1mawzi6gk3wglcg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/gregorycollins/hashtables")
+    (synopsis "Haskell Mutable hash tables in the ST monad")
+    (description "This package provides a Haskell library including a
+couple of different implementations of mutable hash tables in the ST
+monad, as well as a typeclass abstracting their common operations, and
+a set of wrappers to use the hash tables in the IO monad.")
+    (license license:bsd-3)))
+
+(define-public ghc-haskell-lexer
+  (package
+    (name "ghc-haskell-lexer")
+    (version "1.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/haskell-lexer/haskell-lexer-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/haskell-lexer")
+    (synopsis "Fully compliant Haskell 98 lexer")
+    (description
+     "This package provides a fully compliant Haskell 98 lexer.")
+    (license license:bsd-3)))
+
+(define-public ghc-haskell-src
+  (package
+    (name "ghc-haskell-src")
+    (version "1.0.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/haskell-src/haskell-src-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1g4dj1f0j68bhn4ixfac63wjzy6gsp6kwgxryb1k5nl3i0g99d5l"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-happy" ,ghc-happy)
+       ("ghc-syb" ,ghc-syb)))
+    (home-page
+     "https://hackage.haskell.org/package/haskell-src")
+    (synopsis
+     "Support for manipulating Haskell source code")
+    (description
+     "The @code{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 license:bsd-3)))
+
+(define-public ghc-haskell-src-exts
+  (package
+    (name "ghc-haskell-src-exts")
+    (version "1.20.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1sm3z4v1p5yffg01ldgavz71s3bvfhjfa13k428rk14bpkl8crlz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("cpphs" ,cpphs)
+       ("ghc-happy" ,ghc-happy)
+       ("ghc-pretty-show" ,ghc-pretty-show)))
+    (native-inputs
+     `(("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)))
+    (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 license:bsd-3)))
+
+(define-public ghc-haskell-src-exts-util
+  (package
+    (name "ghc-haskell-src-exts-util")
+    (version "0.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "haskell-src-exts-util/haskell-src-exts-util-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1803718paq89f8pdck4mb88hv2k1ah9lxzq0lgjgwi9n88ryycz8"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-data-default" ,ghc-data-default)
+       ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-uniplate" ,ghc-uniplate)))
+    (home-page "https://github.com/pepeiborra/haskell-src-exts-util")
+    (synopsis "Helper functions for working with haskell-src-exts trees")
+    (description
+     "This package provides helper functions for working with
+@code{haskell-src-exts} trees.")
+    (license license:bsd-3)))
+
+(define-public ghc-haskell-src-meta
+  (package
+    (name "ghc-haskell-src-meta")
+    (version "0.8.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "haskell-src-meta/haskell-src-meta-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "08jq156zv4m0fjq6712n99c1jwxnpa6kj6sq8ch0r1l0a1ay6ww4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-th-orphans" ,ghc-th-orphans)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://hackage.haskell.org/package/haskell-src-meta")
+    (synopsis "Parse source to template-haskell abstract syntax")
+    (description
+     "This package provides tools to parse Haskell sources to the
+template-haskell abstract syntax.")
+    (license license:bsd-3)))
+
+(define-public ghc-hasktags
+  (package
+    (name "ghc-hasktags")
+    (version "0.71.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hasktags/hasktags-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1s2k9qrgy1jily96img2pmn7g35mwnnfiw6si3aw32jfhg5zsh1c"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-system-filepath" ,ghc-system-filepath)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
+    (native-inputs
+     `(("ghc-json" ,ghc-json)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-microlens-platform" ,ghc-microlens-platform)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "http://github.com/MarcWeber/hasktags")
+    (synopsis "Make @code{Ctags} and @code{Etags} files for Haskell programs")
+    (description
+     "This package provides a means of generating tag files for Emacs and
+Vim.")
+    (license license:bsd-3)))
+
+(define-public ghc-hex
+  (package
+    (name "ghc-hex")
+    (version "0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "hex-" version "/"
+                           "hex-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1v31xiaivrrn0q2jz8919wvkjplv1kxna5ajhsj701fqxm1i5vhj"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/hex")
+    (synopsis "Convert strings into hexadecimal and back")
+    (description "This package provides conversion functions between
+bytestrings and their hexademical representation.")
+    (license license:bsd-3)))
+
+(define-public ghc-highlighting-kate
+  (package
+    (name "ghc-highlighting-kate")
+    (version "0.6.4")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "highlighting-kate/highlighting-kate-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1bqv00gfmrsf0jjr4qf3lhshvfkyzmhbi3pjb6mafbnsyn2k7f6q"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-diff" ,ghc-diff)
+       ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
+    (native-inputs
+     `(("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (home-page "https://github.com/jgm/highlighting-kate")
+    (synopsis "Syntax highlighting library")
+    (description
+     "Highlighting-kate is a syntax highlighting library with support for
+nearly one hundred languages.  The syntax parsers are automatically generated
+from @uref{https://kate-editor.org/, Kate syntax descriptions}, so any syntax
+supported by Kate can be added.  An (optional) command-line program is
+provided, along with a utility for generating new parsers from Kate XML syntax
+descriptions.")
+    (license license:gpl2+)))
+
+(define-public ghc-hindent
+  (package
+    (name "ghc-hindent")
+    (version "5.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hindent/hindent-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0wkfik7mvqskk23kyh7ybgnlh3j9j1ym7d3ncahsbli9w654b7xg"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:modules ((guix build haskell-build-system)
+                  (guix build utils)
+                  (guix build emacs-utils))
+       #:imported-modules (,@%haskell-build-system-modules
+                           (guix build emacs-utils))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'install 'emacs-install
+           (lambda* (#:key inputs outputs #:allow-other-keys)
+             (let* ((out   (assoc-ref outputs "out"))
+                    (elisp-file "elisp/hindent.el")
+                    (dest  (string-append out "/share/emacs/site-lisp"
+                                          "/guix.d/hindent-" ,version))
+                    (emacs (string-append (assoc-ref inputs "emacs")
+                                          "/bin/emacs")))
+               (make-file-writable elisp-file)
+               (emacs-substitute-variables elisp-file
+                 ("hindent-process-path"
+                  (string-append out "/bin/hindent")))
+               (install-file elisp-file dest)
+               (emacs-generate-autoloads "hindent" dest)))))))
+    (inputs
+     `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+       ("ghc-monad-loops" ,ghc-monad-loops)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-yaml" ,ghc-yaml)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-path" ,ghc-path)
+       ("ghc-path-io" ,ghc-path-io)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-diff" ,ghc-diff)
+       ("emacs" ,emacs-minimal)))
+    (home-page
+     "https://github.com/commercialhaskell/hindent")
+    (synopsis "Extensible Haskell pretty printer")
+    (description
+     "This package provides automatic formatting for Haskell files.  Both a
+library and an executable.")
+    (license license:bsd-3)))
+
+(define-public ghc-hinotify
+  (package
+    (name "ghc-hinotify")
+    (version "0.3.10")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/hinotify/"
+                    "hinotify-" version ".tar.gz"))
+              (sha256
+               (base32
+                "17ax3n68a5c2ddazp86aciliskrh6znd3bnry0wcllmb6dbpsaxg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)))
+    (home-page "https://github.com/kolmodin/hinotify.git")
+    (synopsis "Haskell binding to inotify")
+    (description "This library provides a wrapper to the Linux kernel's inotify
+feature, allowing applications to subscribe to notifications when a file is
+accessed or modified.")
+    (license license:bsd-3)))
+
+(define-public ghc-hmatrix
+  (package
+    (name "ghc-hmatrix")
+    (version "0.19.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hmatrix/hmatrix-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "10jd69nby29dggghcyjk6ykyr5wrn97nrv1dkpyrp0y5xm12xssj"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-random" ,ghc-random)
+       ("ghc-split" ,ghc-split)
+       ("ghc-storable-complex" ,ghc-storable-complex)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-vector" ,ghc-vector)
+       ;;("openblas" ,openblas)
+       ("lapack" ,lapack)))
+    ;; Guix's OpenBLAS is built with the flag "NO_LAPACK=1" which
+    ;; disables inclusion of the LAPACK functions.
+    ;; (arguments `(#:configure-flags '("--flags=openblas")))
+    (home-page "https://github.com/albertoruiz/hmatrix")
+    (synopsis "Haskell numeric linear algebra library")
+    (description "The HMatrix package provices a Haskell library for
+dealing with linear systems, matrix decompositions, and other
+numerical computations based on BLAS and LAPACK.")
+    (license license:bsd-3)))
+
+(define-public ghc-hmatrix-gsl
+  (package
+    (name "ghc-hmatrix-gsl")
+    (version "0.19.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "0v6dla426x4ywaq59jm89ql1i42n39iw6z0j378xwb676v9kfxhm"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hmatrix" ,ghc-hmatrix)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-random" ,ghc-random)
+       ("gsl" ,gsl)))
+    (native-inputs `(("pkg-config" ,pkg-config)))
+    (home-page "https://github.com/albertoruiz/hmatrix")
+    (synopsis "Haskell GSL binding")
+    (description "This Haskell library provides a purely functional
+interface to selected numerical computations, internally implemented
+using GSL.")
+    (license license:gpl3+)))
+
+(define-public ghc-hmatrix-gsl-stats
+  (package
+    (name "ghc-hmatrix-gsl-stats")
+    (version "0.4.1.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri
+        (string-append
+         "https://hackage.haskell.org/package/hmatrix-gsl-stats/hmatrix-gsl-stats-"
+         version ".tar.gz"))
+       (sha256
+        (base32 "1gslgk58lzin43cvbpivhw7nrn9qyaa6qwhy1z9ypvyal5p8n3sa"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-storable-complex" ,ghc-storable-complex)
+       ("ghc-hmatrix" ,ghc-hmatrix)
+       ("gsl" ,gsl)))
+    (native-inputs `(("pkg-config" ,pkg-config)))
+    (home-page "http://code.haskell.org/hmatrix-gsl-stats")
+    (synopsis "GSL Statistics interface for Haskell")
+    (description "This Haskell library provides a purely functional
+interface for statistics based on hmatrix and GSL.")
+    (license license:bsd-3)))
+
+(define-public ghc-hmatrix-special
+  (package
+    (name "ghc-hmatrix-special")
+    (version "0.19.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri
+        (string-append
+         "https://hackage.haskell.org/package/hmatrix-special/hmatrix-special-"
+         version ".tar.gz"))
+       (sha256
+        (base32 "1mywr61kr852sbff26n9x95kswx9l4ycbv6s68qsbkh02xzqq7qz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hmatrix" ,ghc-hmatrix)
+       ("ghc-hmatrix-gsl" ,ghc-hmatrix-gsl)))
+    (home-page "https://github.com/albertoruiz/hmatrix")
+    (synopsis "Haskell interface to GSL special functions")
+    (description "This library provides an interface to GSL special
+functions for Haskell.")
+    (license license:gpl3+)))
+
+(define-public ghc-hostname
+  (package
+    (name "ghc-hostname")
+    (version "1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/hostname/"
+                           "hostname-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/hostname")
+    (synopsis "Hostname in Haskell")
+    (description "Network.HostName is a simple package providing a means to
+determine the hostname.")
+    (license license:bsd-3)))
+
+(define-public ghc-hourglass
+  (package
+    (name "ghc-hourglass")
+    (version "0.2.12")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "hourglass/hourglass-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0jnay5j13vpz6i1rkaj3j0d9v8jfpri499xn3l7wd01f81f5ncs4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-old-locale" ,ghc-old-locale)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/vincenthz/hs-hourglass")
+    (synopsis "Simple time-related library for Haskell")
+    (description
+     "This is a simple time library providing a simple but powerful and
+performant API.  The backbone of the library are the @code{Timeable} and
+@code{Time} type classes.  Each @code{Timeable} instances can be converted to
+a type that has a @code{Time} instances, and thus are different
+representations of current time.")
+    (license license:bsd-3)))
+
+(define-public ghc-hpack
+  (package
+    (name "ghc-hpack")
+    (version "0.28.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/hpack/"
+                           "hpack-" version ".tar.gz"))
+       (sha256
+        (base32
+         "18w0h76jdp3mk9vin8da9iz3cwhcxmw787xy8wlh8bxcpcr16q5r"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-cryptonite" ,ghc-cryptonite)
+       ("ghc-glob" ,ghc-glob)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-http-client-tls" ,ghc-http-client-tls)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-yaml" ,ghc-yaml)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-interpolate" ,ghc-interpolate)
+       ("ghc-mockery" ,ghc-mockery)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-temporary" ,ghc-temporary)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/sol/hpack")
+    (synopsis "Tools for an alternative Haskell package format")
+    (description
+     "Hpack is a format for Haskell packages.  It is an alternative to the
+Cabal package format and follows different design principles.  Hpack packages
+are described in a file named @code{package.yaml}.  Both @code{cabal2nix} and
+@code{stack} support @code{package.yaml} natively.  For other build tools the
+@code{hpack} executable can be used to generate a @code{.cabal} file from
+@code{package.yaml}.")
+    (license license:expat)))
+
+(define-public ghc-hs-bibutils
+  (package
+    (name "ghc-hs-bibutils")
+    (version "6.6.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hs-bibutils/hs-bibutils-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0n2sz2zl4naspryd49ii858qkjp2lapns5a2gr8zm6vvn5sh1f0l"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-syb" ,ghc-syb)))
+    (home-page "https://hackage.haskell.org/package/hs-bibutils")
+    (synopsis "Haskell bindings to bibutils")
+    (description
+     "This package provides Haskell bindings to @code{bibutils}, a library
+that interconverts between various bibliography formats using a common
+MODS-format XML intermediate.")
+    (license license:gpl2+)))
+
+(define-public ghc-hslogger
+  (package
+    (name "ghc-hslogger")
+    (version "1.2.10")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "hslogger-" version "/" "hslogger-"
+                           version ".tar.gz"))
+       (sha256 (base32
+                "0as5gvlh6pi2gflakp695qnlizyyp059dqrhvjl4gjxalja6xjnp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-network" ,ghc-network)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://software.complete.org/hslogger")
+    (synopsis "Logging framework for Haskell, similar to Python's logging module")
+    (description "Hslogger lets each log message have a priority and source be
+associated with it.  The programmer can then define global handlers that route
+or filter messages based on the priority and source.  It also has a syslog
+handler built in.")
+    (license license:bsd-3)))
+
+(define-public ghc-hslua
+  (package
+    (name "ghc-hslua")
+    (version "0.9.5.2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "hslua/hslua-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1rdvv01p214zfjh6fcqjjgqwi8y42wad6cqzhlcv5gvclzw2ck8f"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:configure-flags '("-fsystem-lua")))
+    (inputs
+     `(("lua" ,lua)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-fail" ,ghc-fail)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+    (home-page "https://hackage.haskell.org/package/hslua")
+    (synopsis "Lua language interpreter embedding in Haskell")
+    (description
+     "The Scripting.Lua module is a wrapper of the Lua language interpreter as
+described in @url{https://www.lua.org/}.")
+    (license license:expat)))
+
+(define-public ghc-hslua-module-text
+  (package
+    (name "ghc-hslua-module-text")
+    (version "0.1.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "hslua-module-text/hslua-module-text-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0bcfpb1dhnxp0gr376ai4w7vczr9zrjl1r3r6w7kcxivfkwq9cxf"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n")))
+    (inputs
+     `(("ghc-hslua" ,ghc-hslua)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/hslua/hslua-module-text")
+    (synopsis "Lua module for text")
+    (description
+     "This package provides a UTF-8 aware subset of Lua's @code{string} module
+for Haskell.  The functions provided by this module are @code{upper},
+@code{lower}, @code{len}, @code{reverse}, and @code{sub}.")
+    (license license:expat)))
+
+(define-public ghc-http-api-data
+  (package
+    (name "ghc-http-api-data")
+    (version "0.3.8.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "http-api-data-" version "/"
+                           "http-api-data-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1cq6459b8wz6nvkvpi89dg189n5q2xdq4rdq435hf150555vmskf"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))  ;  FIXME: Tests require QuickCheck >= 2.9
+    (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+              ("ghc-attoparsec-iso8601" ,ghc-attoparsec-iso8601)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-http-types" ,ghc-http-types)
+              ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-uri-bytestring" ,ghc-uri-bytestring)
+              ("ghc-uuid-types" ,ghc-uuid-types)))
+    (home-page "https://github.com/fizruk/http-api-data")
+    (synopsis "Convert to/from HTTP API data like URL pieces, headers and
+query parameters")
+    (description "This Haskell package defines typeclasses used for converting
+Haskell data types to and from HTTP API data.")
+    (license license:bsd-3)))
+
+(define-public ghc-ieee754
+  (package
+    (name "ghc-ieee754")
+    (version "0.8.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/ieee754/"
+                    "ieee754-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1lcs521g9lzy9d7337vg4w7q7s8500rfqy7rcifcz6pm6yfgyb8f"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/patperry/hs-ieee754")
+    (synopsis "Utilities for dealing with IEEE floating point numbers")
+    (description "Utilities for dealing with IEEE floating point numbers,
+ported from the Tango math library; approximate and exact equality comparisons
+for general types.")
+    (license license:bsd-3)))
+
+(define-public ghc-ifelse
+  (package
+    (name "ghc-ifelse")
+    (version "0.85")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "IfElse/IfElse-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/IfElse")
+    (synopsis "Monadic control flow with anaphoric variants")
+    (description "This library provides functions for control flow inside of
+monads with anaphoric variants on @code{if} and @code{when} and a C-like
+@code{switch} function.")
+    (license license:bsd-3)))
+
+(define-public ghc-indents
+  (package
+    (name "ghc-indents")
+    (version "0.5.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/indents/indents-"
+                    version ".tar.gz"))
+              (sha256
+               (base32
+                "1ly3v41jacc6lrsvg4j3m5a6zs90gr8dyif5m6bf34hj1k5cgg0n"))))
+    (build-system haskell-build-system)
+    ;; This package needs an older version of tasty.
+    (arguments '(#:tests? #f))
+    (inputs
+     `(("ghc-concatenative" ,ghc-concatenative)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "http://patch-tag.com/r/salazar/indents")
+    (synopsis "Indentation sensitive parser-combinators for parsec")
+    (description
+     "This library provides functions for use in parsing indentation sensitive
+contexts.  It parses blocks of lines all indented to the same level as well as
+lines continued at an indented level below.")
+    (license license:bsd-3)))
+
+(define-public ghc-inline-c
+  (package
+    (name "ghc-inline-c")
+    (version "0.6.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/inline-c/"
+                           "inline-c-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0vbfrsqsi7mdziqsnj68bsqlwbqxxhvrmy9rv6w8z18d1m8w3n6h"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+       ("ghc-cryptohash" ,ghc-cryptohash)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-parsers" ,ghc-parsers)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-raw-strings-qq" ,ghc-raw-strings-qq)
+       ("ghc-regex-posix" ,ghc-regex-posix)))
+    (home-page "http://hackage.haskell.org/package/inline-c")
+    (synopsis "Write Haskell source files including C code inline")
+    (description
+     "inline-c lets you seamlessly call C libraries and embed high-performance
+inline C code in Haskell modules.  Haskell and C can be freely intermixed in
+the same source file, and data passed to and from code in either language with
+minimal overhead.  No FFI required.")
+    (license license:expat)))
+
+(define-public ghc-inline-c-cpp
+  (package
+    (name "ghc-inline-c-cpp")
+    (version "0.2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/inline-c-cpp/"
+                           "inline-c-cpp-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1rk7fmpkmxw9hhwr8df29kadnf0ybnwj64ggdbnsdrpfyhnkisci"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-inline-c" ,ghc-inline-c)
+       ("ghc-safe-exceptions" ,ghc-safe-exceptions)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/inline-c-cpp")
+    (synopsis "Lets you embed C++ code into Haskell")
+    (description
+     "This package provides utilities to inline C++ code into Haskell using
+@code{inline-c}.")
+    (license license:expat)))
+
+(define-public ghc-integer-logarithms
+  (package
+    (name "ghc-integer-logarithms")
+    (version "1.0.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "integer-logarithms/integer-logarithms-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1wj8kgjg5bn2yrs4zh9qfjv85cx6w998j9pi39yrbv305944mb9j"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "integer-logarithms.cabal"
+               (("tasty >= 0\\.10 && < 1\\.1")
+                "tasty >= 0.10 && < 1.2")))))))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)))
+    (home-page "https://github.com/Bodigrim/integer-logarithms")
+    (synopsis "Integer logarithms")
+    (description
+     "This package provides the following modules:
+@code{Math.NumberTheory.Logarithms} and
+@code{Math.NumberTheory.Powers.Integer} from the @code{arithmoi} package,
+@code{GHC.Integer.Logarithms.Compat} and
+@code{Math.NumberTheory.Power.Natural}, as well as some additional functions
+in migrated modules.")
+    (license license:expat)))
+
+(define-public ghc-integer-logarithms-bootstrap
+  (package
+    (inherit ghc-integer-logarithms)
+    (name "ghc-integer-logarithms-bootstrap")
+    (arguments `(#:tests? #f))
+    (native-inputs '())
+    (properties '(hidden? #t))))
+
+(define-public ghc-interpolate
+  (package
+    (name "ghc-interpolate")
+    (version "0.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/interpolate/"
+                           "interpolate-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1gkaj98yz363v38fv78sqby236mp8yqwqcilx7kr2b9z0w3204bf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
+    (native-inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/sol/interpolate")
+    (synopsis "String interpolation library")
+    (description "This package provides a string interpolation library for
+Haskell.")
+    (license license:expat)))
+
+(define-public ghc-intervalmap
+  (package
+    (name "ghc-intervalmap")
+    (version "0.6.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/IntervalMap/"
+                           "IntervalMap-" version ".tar.gz"))
+       (sha256
+        (base32
+         "06hin9wf1by8aqa7820fsi2339bh82184frkwz3jsb9sqa0hszcg"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "http://www.chr-breitkopf.de/comp/IntervalMap")
+    (synopsis "Containers for intervals, with efficient search")
+    (description
+     "This package provides ordered containers of intervals, with efficient
+search for all keys containing a point or overlapping an interval.  See the
+example code on the home page for a quick introduction.")
+    (license license:bsd-3)))
+
+(define-public ghc-invariant
+  (package
+    (name "ghc-invariant")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/invariant/invariant-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0aqj7z55632qdg45074kgn9qfdxzb0a2f8lgjzr0l0i4mm2rr37b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-statevar" ,ghc-statevar)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-th-abstraction" ,ghc-th-abstraction)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/nfrisby/invariant-functors")
+    (synopsis "Haskell98 invariant functors")
+    (description "Haskell98 invariant functors (also known as exponential
+functors).  For more information, see Edward Kmett's article
+@uref{http://comonad.com/reader/2008/rotten-bananas/, Rotten Bananas}.")
+    (license license:bsd-2)))
+
 (define-public ghc-io-streams
   (package
     (name "ghc-io-streams")
@@ -146,6 +5334,160 @@ about a networked peer (like remote address and port) to be propagated
 through a forwarding proxy that is configured to speak this protocol.")
     (license license:bsd-3)))
 
+(define-public ghc-iproute
+  (package
+    (name "ghc-iproute")
+    (version "1.7.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/iproute/iproute-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1vw1nm3s8vz1hqnjnqd3wh5rr4q3m2r4izn5ynhf93h9185qwqzd"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
+                               ; exported by ghc-byteorder.  Doctest issue.
+    (inputs
+     `(("ghc-appar" ,ghc-appar)
+       ("ghc-byteorder" ,ghc-byteorder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-safe" ,ghc-safe)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-iwlib
+  (package
+    (name "ghc-iwlib")
+    (version "0.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/iwlib/iwlib-"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "0khmfwql4vwj55idsxmhjhrbqzfir3g9wm5lmpvnf77mm95cfpdz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("wireless-tools" ,wireless-tools)))
+    (home-page "https://github.com/jaor/iwlib")
+    (synopsis "Haskell binding to the iw wireless networking library")
+    (description
+     "IWlib is a thin Haskell binding to the iw C library.  It provides
+information about the current wireless network connections, and adapters on
+supported systems.")
+    (license license:bsd-3)))
+
+(define-public ghc-json
+  (package
+    (name "ghc-json")
+    (version "0.9.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/json/"
+                           "json-" version ".tar.gz"))
+       (sha256
+        (base32
+         "13kkfgx58z18jphbg56jn08jn72wi3kvfndlwwx87hqwg7x1dfz6"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-syb" ,ghc-syb)))
+    (home-page "https://hackage.haskell.org/package/json")
+    (synopsis "Serializes Haskell data to and from JSON")
+    (description "This package provides a parser and pretty printer for
+converting between Haskell values and JSON.
+JSON (JavaScript Object Notation) is a lightweight data-interchange format.")
+    (license license:bsd-3)))
+
+(define-public ghc-juicypixels
+  (package
+    (name "ghc-juicypixels")
+    (version "3.2.9.5")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "JuicyPixels/JuicyPixels-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "0mf3ihr0xy2wc2wzb9a17g0n3p60x7pvm8akwpvhdy8klvs6r744"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-zlib" ,ghc-zlib)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-mmap" ,ghc-mmap)))
+    (home-page "https://github.com/Twinside/Juicy.Pixels")
+    (synopsis "Picture loading and serialization library")
+    (description
+     "This library can load and store images in PNG, Bitmap, JPEG, Radiance,
+TIFF and GIF formats.")
+    (license license:bsd-3)))
+
+(define-public ghc-kan-extensions
+  (package
+    (name "ghc-kan-extensions")
+    (version "5.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/kan-extensions/kan-extensions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1lyvyiwwh962j2nnnsqzlvp5zq6z8p3spvhmji99cjvldxc7wwkb"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-adjunctions" ,ghc-adjunctions)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-free" ,ghc-free)
+       ("ghc-invariant" ,ghc-invariant)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-language-c
+  (package
+    (name "ghc-language-c")
+    (version "0.8.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "language-c/language-c-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0sdkjj0hq8p69fcdm6ljbjkjvrsrb8a6rl5dq6dj6byj32ajrm3d"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-syb" ,ghc-syb)))
+    (native-inputs
+     `(("ghc-happy" ,ghc-happy)
+       ("ghc-alex" ,ghc-alex)))
+    (home-page "https://visq.github.io/language-c/")
+    (synopsis "Analysis and generation of C code")
+    (description
+     "Language C is a Haskell library for the analysis and generation of C code.
+It features a complete, well-tested parser and pretty printer for all of C99
+and a large set of GNU extensions.")
+    (license license:bsd-3)))
+
 (define-public ghc-language-glsl
   (package
     (name "ghc-language-glsl")
@@ -170,6 +5512,2071 @@ through a forwarding proxy that is configured to speak this protocol.")
 representation, parsing, and pretty-printing of GLSL 1.50 code.")
     (license license:bsd-3)))
 
+(define-public ghc-language-haskell-extract
+  (package
+    (name "ghc-language-haskell-extract")
+    (version "0.2.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "language-haskell-extract-" version "/"
+                           "language-haskell-extract-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-posix" ,ghc-regex-posix)))
+    (home-page "https://github.com/finnsson/template-helper")
+    (synopsis "Haskell module to automatically extract functions from
+the local code")
+    (description "This package contains helper functions on top of
+Template Haskell.
+
+For example, @code{functionExtractor} extracts all functions after a
+regexp-pattern, which can be useful if you wish to extract all functions
+beginning with @code{test} (for a test framework) or all functions beginning
+with @code{wc} (for a web service).")
+    (license license:bsd-3)))
+
+(define-public ghc-lens
+  (package
+    (name "ghc-lens")
+    (version "4.16.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/lens/lens-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1im4drhbydbawd6i0jsrzpqihnmx4ywpkg7yg94ddwsw3mxwkgpm"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri")))
+    (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)
+       ("ghc-call-stack" ,ghc-call-stack)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("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)))
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-th" ,ghc-test-framework-th)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-libffi
+  (package
+    (name "ghc-libffi")
+    (version "0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "libffi/libffi-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0g7jnhng3j7z5517aaqga0144aamibsbpgm3yynwyfzkq1kp0f28"))))
+    (build-system haskell-build-system)
+    (native-inputs `(("pkg-config" ,pkg-config)))
+    (inputs `(("libffi" ,libffi)))
+    (home-page "http://hackage.haskell.org/package/libffi")
+    (synopsis "Haskell binding to libffi")
+    (description
+     "A binding to libffi, allowing C functions of types only known at runtime
+to be called from Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-libmpd
+  (package
+    (name "ghc-libmpd")
+    (version "0.9.0.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/libmpd/libmpd-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1931m23iqb4wddpdidm4ph746zpaw41kkjzmb074j7yyfpk7x1jv"))))
+    (build-system haskell-build-system)
+    ;; Tests fail on i686.
+    ;; See https://github.com/vimus/libmpd-haskell/issues/112
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-network" ,ghc-network)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/vimus/libmpd-haskell")
+    (synopsis "Haskell client library for the Music Player Daemon")
+    (description "This package provides a pure Haskell client library for the
+Music Player Daemon.")
+    (license license:expat)))
+
+(define-public ghc-libxml
+  (package
+    (name "ghc-libxml")
+    (version "0.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/libxml/"
+                           "libxml-" version ".tar.gz"))
+       (sha256
+        (base32
+         "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("libxml2" ,libxml2)))
+    (arguments
+     `(#:configure-flags
+       `(,(string-append "--extra-include-dirs="
+                         (assoc-ref %build-inputs "libxml2")
+                         "/include/libxml2"))))
+    (home-page "https://hackage.haskell.org/package/libxml")
+    (synopsis "Haskell bindings to libxml2")
+    (description
+     "This library provides minimal Haskell binding to libxml2.")
+    (license license:bsd-3)))
+
+(define-public ghc-lifted-async
+  (package
+    (name "ghc-lifted-async")
+    (version "0.10.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/lifted-async/lifted-async-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1073r512c1x2m1v0jar9bwqg656slg7jd1jhsyj6m8awgx1l1mwf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-constraints" ,ghc-constraints)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-th" ,ghc-tasty-th)))
+    (home-page "https://github.com/maoe/lifted-async")
+    (synopsis "Run lifted IO operations asynchronously and wait for their results")
+    (description
+     "This package provides IO operations from @code{async} package lifted to any
+instance of @code{MonadBase} or @code{MonadBaseControl}.")
+    (license license:bsd-3)))
+
+(define-public ghc-lifted-base
+  (package
+    (name "ghc-lifted-base")
+    (version "0.2.3.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/lifted-base/lifted-base-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1i8p8d3rkdh21bhgjjh32vd7qqjr7jq7p59qds0aw2kmargsjd61"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
+    (inputs
+     `(("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("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 license:bsd-3)))
+
+(define-public ghc-linear
+  (package
+    (name "ghc-linear")
+    (version "1.20.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/linear/"
+                           "linear-" version ".tar.gz"))
+       (sha256
+        (base32
+         "046vkvxlb0s286qr55s0c6db0rlwbm1cmlmwhrrkqbkzhfcipgay"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-adjunctions" ,ghc-adjunctions)
+       ("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-bytes" ,ghc-bytes)
+       ("ghc-cereal" ,ghc-cereal)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-reflection" ,ghc-reflection)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-void" ,ghc-void)))
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-simple-reflect" ,ghc-simple-reflect)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "http://github.com/ekmett/linear/")
+    (synopsis "Linear algebra library for Haskell")
+    (description
+     "This package provides types and combinators for linear algebra on free
+vector spaces.")
+    (license license:bsd-3)))
+
+(define-public ghc-logging-facade
+  (package
+    (name "ghc-logging-facade")
+    (version "0.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "logging-facade/logging-facade-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://hackage.haskell.org/package/logging-facade")
+    (synopsis "Simple logging abstraction that allows multiple back-ends")
+    (description
+     "This package provides a simple logging abstraction that allows multiple
+back-ends.")
+    (license license:expat)))
+
+(define-public ghc-logict
+  (package
+    (name "ghc-logict")
+    (version "0.6.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/logict/logict-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
+    (build-system haskell-build-system)
+    (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 license:bsd-3)))
+
+(define-public ghc-lzma
+  (package
+    (name "ghc-lzma")
+    (version "0.0.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/lzma/"
+                           "lzma-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg"))))
+    (build-system haskell-build-system)
+    (arguments
+     '(#:tests? #f ; requires older versions of QuickCheck and tasty.
+       #:cabal-revision
+       ("3" "1sify6gnsalyp6dakfzi0mdy5jcz2kcp9jsdsgkmxd40nfzgd44m")))
+    (native-inputs
+     `(("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 "https://github.com/hvr/lzma")
+    (synopsis "LZMA/XZ compression and decompression")
+    (description
+     "This package provides a pure interface for compressing and
+decompressing LZMA streams of data represented as lazy @code{ByteString}s.  A
+monadic incremental interface is provided as well.")
+    (license license:bsd-3)))
+
+(define-public ghc-lzma-conduit
+  (package
+    (name "ghc-lzma-conduit")
+    (version "1.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/lzma-conduit/"
+                           "lzma-conduit-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0hm72da7xk9l3zxjh274yg444vf405djxqbkf3q3p2qhicmxlmg9"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-lzma" ,ghc-lzma)
+       ("ghc-resourcet" ,ghc-resourcet)))
+    (native-inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/alphaHeavy/lzma-conduit")
+    (synopsis "Conduit interface for lzma/xz compression")
+    (description
+     "This package provides a @code{Conduit} interface for the LZMA
+compression algorithm used in the @code{.xz} file format.")
+    (license license:bsd-3)))
+
+(define-public ghc-markdown-unlit
+  (package
+    (name "ghc-markdown-unlit")
+    (version "0.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "mirror://hackage/package/markdown-unlit/"
+                    "markdown-unlit-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1gy79vr85vcp13rdjh0hz7zv6daqqffww4j0cqn2lpjjh9xhsbg7"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-silently" ,ghc-silently)
+       ("ghc-stringbuilder" ,ghc-stringbuilder)
+       ("ghc-temporary" ,ghc-temporary)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/sol/markdown-unlit#readme")
+    (synopsis "Literate Haskell support for Markdown")
+    (description "This package allows you to have a README.md that at the
+same time is a literate Haskell program.")
+    (license license:expat)))
+
+(define-public ghc-math-functions
+  (package
+    (name "ghc-math-functions")
+    (version "0.2.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "math-functions-" version "/"
+                           "math-functions-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1sv5vabsx332v1lpb6v3jv4zrzvpx1n7yprzd8wlcda5vsc5a6zp"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f))  ; FIXME: 1 test fails.
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-erf" ,ghc-erf)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/math-functions")
+    (synopsis "Special functions and Chebyshev polynomials for Haskell")
+    (description "This Haskell library provides implementations of
+special mathematical functions and Chebyshev polynomials.  These
+functions are often useful in statistical and numerical computing.")
+    (license license:bsd-3)))
+
+(define-public ghc-megaparsec
+  (package
+    (name "ghc-megaparsec")
+    (version "6.5.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "megaparsec/megaparsec-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "12iggy7qpf8x93jm64zf0g215xwy779bqyfyjk2bhmxqqr1yzgdy"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("4" "0ij3asi5vwlhbgwsy6nhli9a0qb7926mg809fsgyl1rnhs9fvpx1")))
+    (inputs
+     `(("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-parser-combinators" ,ghc-parser-combinators)
+       ("ghc-scientific" ,ghc-scientific)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/mrkkrp/megaparsec")
+    (synopsis "Monadic parser combinators")
+    (description
+     "This is an industrial-strength monadic parser combinator library.
+Megaparsec is a feature-rich package that strikes a nice balance between
+speed, flexibility, and quality of parse errors.")
+    (license license:bsd-2)))
+
+(define-public ghc-memory
+  (package
+    (name "ghc-memory")
+    (version "0.14.16")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "memory/memory-" version ".tar.gz"))
+              (sha256
+               (base32
+                "03rbszi5d4z9rlbfv8ydrl1xf84xsh8z57g07f7j9qccn9587c3v"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-basement" ,ghc-basement)
+       ("ghc-foundation" ,ghc-foundation)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/vincenthz/hs-memory")
+    (synopsis "Memory abstractions for Haskell")
+    (description
+     "This package provides memory abstractions, such as chunk of memory,
+polymorphic byte array management and manipulation functions.  It contains a
+polymorphic byte array abstraction and functions similar to strict ByteString,
+different type of byte array abstraction, raw memory IO operations (memory
+set, memory copy, ..) and more")
+    (license license:bsd-3)))
+
+(define-public ghc-memotrie
+  (package
+    (name "ghc-memotrie")
+    (version "0.6.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/MemoTrie/MemoTrie-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "157p0pi6rrq74a35mq6zkkycv4ah7xhkbrcmnkb9xf7pznw4aq0x"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-newtype-generics" ,ghc-newtype-generics)))
+    (home-page "https://github.com/conal/MemoTrie")
+    (synopsis "Trie-based memo functions")
+    (description "This package provides a functional library for creating
+efficient memo functions using tries.")
+    (license license:bsd-3)))
+
+(define-public ghc-microlens
+  (package
+    (name "ghc-microlens")
+    (version "0.4.9.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "microlens-" version "/"
+                           "microlens-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0j2nzf0vpx2anvsrg2w0vy2z4jn3kkcs2n6glkzblhn1j9piqh51"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://github.com/aelve/microlens")
+    (synopsis "Provides a tiny lens Haskell library with no dependencies")
+    (description "This Haskell package provides a lens library, just like
+@code{ghc-lens}, but smaller.  It provides essential lenses and
+traversals (like @code{_1} and @code{_Just}), as well as ones which are simply
+nice to have (like @code{each}, @code{at}, and @code{ix}), and some
+combinators (like @code{failing} and @code{singular}), but everything else is
+stripped.  As the result, this package has no dependencies.")
+    (license license:bsd-3)))
+
+(define-public ghc-microlens-ghc
+  (package
+    (name "ghc-microlens-ghc")
+    (version "0.4.9.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/microlens-ghc/microlens-ghc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "03iwgg8zww9irv59l70c8yy7vzxir1zf66y12210xk91k5hq6jrj"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-microlens" ,ghc-microlens)))
+    (home-page "https://github.com/monadfix/microlens")
+    (synopsis "Use @code{microlens} with GHC libraries like @code{array}")
+    (description "This library provides everything that @code{microlens}
+provides plus instances to make @code{each}, @code{at}, and @code{ix}
+usable with arrays, @code{ByteString}, and containers.  This package is
+a part of the @uref{http://hackage.haskell.org/package/microlens,
+microlens} family; see the readme
+@uref{https://github.com/aelve/microlens#readme, on Github}.")
+    (license license:bsd-3)))
+
+(define-public ghc-microlens-mtl
+  (package
+    (name "ghc-microlens-mtl")
+    (version "0.1.11.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/microlens-mtl/microlens-mtl-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0l6z1gkzwcpv89bxf5vgfrjb6gq2pj7sjjc53nvi5b9alx34zryk"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-microlens" ,ghc-microlens)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://github.com/monadfix/microlens")
+    (synopsis
+     "@code{microlens} support for Reader/Writer/State from mtl")
+    (description
+     "This package contains functions (like @code{view} or @code{+=}) which
+work on @code{MonadReader}, @code{MonadWriter}, and @code{MonadState} from the
+mtl package.  This package is a part of the
+@uref{http://hackage.haskell.org/package/microlens, microlens} family; see the
+readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
+    (license license:bsd-3)))
+
+(define-public ghc-microlens-platform
+  (package
+    (name "ghc-microlens-platform")
+    (version "0.3.10")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "microlens-platform/microlens-platform-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1d4nhmgf9jq0ixc7qhwm7aaw3xdr0nalw58d0ydsydgf02cyazwv"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-microlens" ,ghc-microlens)
+       ("ghc-microlens-ghc" ,ghc-microlens-ghc)
+       ("ghc-microlens-mtl" ,ghc-microlens-mtl)
+       ("ghc-microlens-th" ,ghc-microlens-th)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/monadfix/microlens")
+    (synopsis "Feature-complete microlens")
+    (description
+     "This package exports a module which is the recommended starting point
+for using @uref{http://hackage.haskell.org/package/microlens, microlens} if
+you aren't trying to keep your dependencies minimal.  By importing
+@code{Lens.Micro.Platform} you get all functions and instances from
+@uref{http://hackage.haskell.org/package/microlens, microlens},
+@uref{http://hackage.haskell.org/package/microlens-th, microlens-th},
+@uref{http://hackage.haskell.org/package/microlens-mtl, microlens-mtl},
+@uref{http://hackage.haskell.org/package/microlens-ghc, microlens-ghc}, as
+well as instances for @code{Vector}, @code{Text}, and @code{HashMap}.  The
+minor and major versions of @code{microlens-platform} are incremented whenever
+the minor and major versions of any other @code{microlens} package are
+incremented, so you can depend on the exact version of
+@code{microlens-platform} without specifying the version of @code{microlens}
+you need.  This package is a part of the
+@uref{http://hackage.haskell.org/package/microlens, microlens} family; see the
+readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
+    (license license:bsd-3)))
+
+(define-public ghc-microlens-th
+  (package
+    (name "ghc-microlens-th")
+    (version "0.4.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "microlens-th-" version "/"
+                           "microlens-th-" version ".tar.gz"))
+       (sha256
+        (base32
+         "02nj7lnl61yffi3c6wn341arxhld5r0vj6nzcb5zmqjhnqsv8c05"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-microlens" ,ghc-microlens)
+              ("ghc-th-abstraction" ,ghc-th-abstraction)))
+    (home-page
+     "https://github.com/aelve/microlens")
+    (synopsis "Automatic generation of record lenses for
+@code{ghc-microlens}")
+    (description "This Haskell package lets you automatically generate lenses
+for data types; code was extracted from the lens package, and therefore
+generated lenses are fully compatible with ones generated by lens (and can be
+used both from lens and microlens).")
+    (license license:bsd-3)))
+
+(define-public ghc-missingh
+  (package
+    (name "ghc-missingh")
+    (version "1.4.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/MissingH/"
+                           "MissingH-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0wcvgrmav480w7nf4bl14yi0jq2yzanysxwzwas9hpb28vyjlgr8"))))
+    (build-system haskell-build-system)
+    ;; Tests require the unmaintained testpack package, which depends on the
+    ;; outdated QuickCheck version 2.7, which can no longer be built with
+    ;; recent versions of GHC and Haskell libraries.
+    (arguments '(#:tests? #f))
+    (inputs
+     `(("ghc-network" ,ghc-network)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-regex-compat" ,ghc-regex-compat)
+       ("ghc-hslogger" ,ghc-hslogger)
+       ("ghc-random" ,ghc-random)
+       ("ghc-old-time" ,ghc-old-time)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (native-inputs
+     `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "http://software.complete.org/missingh")
+    (synopsis "Large utility library")
+    (description
+     "MissingH is a library of all sorts of utility functions for Haskell
+programmers.  It is written in pure Haskell and thus should be extremely
+portable and easy to use.")
+    (license license:bsd-3)))
+
+(define-public ghc-mmap
+  (package
+    (name "ghc-mmap")
+    (version "0.5.9")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "mmap/mmap-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/mmap")
+    (synopsis "Memory mapped files for Haskell")
+    (description
+     "This library provides a wrapper to @code{mmap}, allowing files or
+devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
+@code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
+do on-demand loading.")
+    (license license:bsd-3)))
+
+(define-public ghc-mmorph
+  (package
+    (name "ghc-mmorph")
+    (version "1.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/mmorph/mmorph-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1gjz1ib968lqybma7my1n19qq6cdj6a7nskrlnwy4jy9jrwzs2n9"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://hackage.haskell.org/package/mmorph")
+    (synopsis "Monad morphisms")
+    (description
+     "This library provides monad morphism utilities, most commonly used for
+manipulating monad transformer stacks.")
+    (license license:bsd-3)))
+
+(define-public ghc-mockery
+  (package
+    (name "ghc-mockery")
+    (version "0.3.5")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "mockery/mockery-" version ".tar.gz"))
+              (sha256
+               (base32
+                "09ypgm3z69gq8mj6y66ss58kbjnk15r8frwcwbqcfbfksfnfv8dp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-temporary" ,ghc-temporary)
+       ("ghc-logging-facade" ,ghc-logging-facade)
+       ("ghc-base-compat" ,ghc-base-compat)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://hackage.haskell.org/package/mockery")
+    (synopsis "Support functions for automated testing")
+    (description
+     "The mockery package provides support functions for automated testing.")
+    (license license:expat)))
+
+(define-public ghc-monad-control
+  (package
+    (name "ghc-monad-control")
+    (version "1.0.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/monad-control"
+             "/monad-control-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1c92833gr6cadidjdp8mlznkpp8lyxl0w3y7d19y8yi3klc3843c"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("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 license:bsd-3)))
+
+(define-public ghc-monad-logger
+  (package
+    (name "ghc-monad-logger")
+    (version "0.3.29")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monad-logger-" version "/"
+                           "monad-logger-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
+              ("ghc-stm-chans" ,ghc-stm-chans)
+              ("ghc-lifted-base" ,ghc-lifted-base)
+              ("ghc-resourcet" ,ghc-resourcet)
+              ("ghc-conduit" ,ghc-conduit)
+              ("ghc-conduit-extra" ,ghc-conduit-extra)
+              ("ghc-fast-logger" ,ghc-fast-logger)
+              ("ghc-transformers-base" ,ghc-transformers-base)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-monad-loops" ,ghc-monad-loops)
+              ("ghc-blaze-builder" ,ghc-blaze-builder)
+              ("ghc-exceptions" ,ghc-exceptions)))
+    (home-page "https://github.com/kazu-yamamoto/logger")
+    (synopsis "Provides a class of monads which can log messages for Haskell")
+    (description "This Haskell package uses a monad transformer approach
+for logging.
+
+This package provides Template Haskell functions for determining source
+code locations of messages.")
+    (license license:expat)))
+
+(define-public ghc-monad-loops
+  (package
+    (name "ghc-monad-loops")
+    (version "0.4.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monad-loops-" version "/"
+                           "monad-loops-" version ".tar.gz"))
+       (sha256
+        (base32
+         "062c2sn3hc8h50p1mhqkpyv6x8dydz2zh3ridvlfjq9nqimszaky"))))
+    (build-system haskell-build-system)
+    (native-inputs `(("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/mokus0/monad-loops")
+    (synopsis "Monadic loops for Haskell")
+    (description "This Haskell package provides some useful control
+operators for looping.")
+    (license license:public-domain)))
+
+(define-public ghc-monad-par
+  (package
+    (name "ghc-monad-par")
+    (version "0.3.4.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monad-par-" version "/"
+                           "monad-par-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0ldrzqy24fsszvn2a2nr77m2ih7xm0h9bgkjyv1l274aj18xyk7q"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
+              ("ghc-abstract-deque" ,ghc-abstract-deque)
+              ("ghc-monad-par-extras" ,ghc-monad-par-extras)
+              ("ghc-mwc-random" ,ghc-mwc-random)
+              ("ghc-parallel" ,ghc-parallel)))
+    (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+                     ("ghc-test-framework-quickcheck2"
+                      ,ghc-test-framework-quickcheck2)
+                     ("ghc-test-framework" ,ghc-test-framework)
+                     ("ghc-test-framework-th" ,ghc-test-framework-th)))
+    (home-page "https://github.com/simonmar/monad-par")
+    (synopsis "Haskell library for parallel programming based on a monad")
+    (description "The @code{Par} monad offers an API for parallel
+programming.  The library works for parallelising both pure and @code{IO}
+computations, although only the pure version is deterministic.  The default
+implementation provides a work-stealing scheduler and supports forking tasks
+that are much lighter weight than IO-threads.")
+    (license license:bsd-3)))
+
+(define-public ghc-monad-par-extras
+  (package
+    (name "ghc-monad-par-extras")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monad-par-extras-" version "/"
+                           "monad-par-extras-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
+              ("ghc-cereal" ,ghc-cereal)
+              ("ghc-random" ,ghc-random)))
+    (home-page "https://github.com/simonmar/monad-par")
+    (synopsis "Combinators and extra features for Par monads for Haskell")
+    (description "This Haskell package provides additional data structures,
+and other added capabilities layered on top of the @code{Par} monad.")
+    (license license:bsd-3)))
+
+(define-public ghc-monadplus
+  (package
+    (name "ghc-monadplus")
+    (version "1.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/monadplus"
+                           "/monadplus-" version ".tar.gz"))
+       (sha256
+        (base32 "15b5320wdpmdp5slpphnc1x4rhjch3igw245dp2jxbqyvchdavin"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/monadplus")
+    (synopsis "Filtering and folding over arbitrary MonadPlus instances")
+    (description
+     "This package generalizes many common stream operations such as
+@code{filter}, @code{catMaybes} etc, enabling filtering and folding over
+arbitrary @code{MonadPlus} instances.")
+    (license license:bsd-3)))
+
+(define-public ghc-monadrandom
+  (package
+    (name "ghc-monadrandom")
+    (version "0.5.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "MonadRandom-" version "/"
+                           "MonadRandom-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0w44jl1n3kqvqaflh82l1wj3xxbhzfs3kf4m8rk7w6fgg8llmnmb"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
+              ("ghc-primitive" ,ghc-primitive)
+              ("ghc-fail" ,ghc-fail)
+              ("ghc-random" ,ghc-random)))
+    (home-page "https://github.com/byorgey/MonadRandom")
+    (synopsis "Random-number generation monad for Haskell")
+    (description "This Haskell package provides support for computations
+which consume random values.")
+    (license license:bsd-3)))
+
+(define-public ghc-monads-tf
+  (package
+    (name "ghc-monads-tf")
+    (version "0.1.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/monads-tf/monads-tf-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/monads-tf")
+    (synopsis "Monad classes, using type families")
+    (description
+     "Monad classes using type families, with instances for various monad transformers,
+inspired by the paper 'Functional Programming with Overloading and Higher-Order
+Polymorphism', by Mark P Jones.  This package is almost a compatible replacement for
+the @code{mtl-tf} package.")
+    (license license:bsd-3)))
+
+(define-public ghc-mono-traversable
+  (package
+    (name "ghc-mono-traversable")
+    (version "1.0.9.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "mono-traversable-" version "/"
+                           "mono-traversable-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0180ks0dyvpk1r20w5jw2w2n79mjnk69n9vhspaxzlyxqgim5psa"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-vector-algorithms" ,ghc-vector-algorithms)
+              ("ghc-split" ,ghc-split)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-semigroups" ,ghc-semigroups)
+                     ("ghc-foldl" ,ghc-foldl)))
+    (home-page "https://github.com/snoyberg/mono-traversable")
+    (synopsis "Haskell classes for mapping, folding, and traversing monomorphic
+containers")
+    (description "This Haskell package provides Monomorphic variants of the
+Functor, Foldable, and Traversable typeclasses.  If you understand Haskell's
+basic typeclasses, you understand mono-traversable.  In addition to what
+you are used to, it adds on an IsSequence typeclass and has code for marking
+data structures as non-empty.")
+    (license license:expat)))
+
+(define-public ghc-murmur-hash
+  (package
+    (name "ghc-murmur-hash")
+    (version "0.1.0.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/murmur-hash"
+                           "/murmur-hash-" version ".tar.gz"))
+       (sha256
+        (base32 "1bb58kfnzvx3mpc0rc0dhqc1fk36nm8prd6gvf20gk6lxaadpfc9"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/nominolo/murmur-hash")
+    (synopsis "MurmurHash2 implementation for Haskell")
+    (description
+     "This package provides an implementation of MurmurHash2, a good, fast,
+general-purpose, non-cryptographic hashing function.  See
+@url{https://sites.google.com/site/murmurhash/} for details.  This
+implementation is pure Haskell, so it might be a bit slower than a C FFI
+binding.")
+    (license license:bsd-3)))
+
+(define-public ghc-mwc-random
+  (package
+    (name "ghc-mwc-random")
+    (version "0.13.6.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "mwc-random-" version "/"
+                           "mwc-random-" version ".tar.gz"))
+       (sha256
+        (base32
+         "05j7yh0hh9nxic3dijmzv44kc6gzclvamdph7sq7w19wq57k6pq6"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-primitive" ,ghc-primitive)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-math-functions" ,ghc-math-functions)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/mwc-random")
+    (synopsis "Random number generation library for Haskell")
+    (description "This Haskell package contains code for generating
+high quality random numbers that follow either a uniform or normal
+distribution.  The generated numbers are suitable for use in
+statistical applications.
+
+The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222)
+multiply-with-carry generator, which has a period of 2^{8222} and
+fares well in tests of randomness.  It is also extremely fast,
+between 2 and 3 times faster than the Mersenne Twister.")
+    (license license:bsd-3)))
+
+(define-public ghc-nats
+  (package
+    (name "ghc-nats")
+    (version "1.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/nats/nats-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1v40drmhixck3pz3mdfghamh73l4rp71mzcviipv1y8jhrfxilmr"))))
+    (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 license:bsd-3)))
+
+(define-public ghc-nats-bootstrap
+  (package
+    (inherit ghc-nats)
+    (name "ghc-nats-bootstrap")
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable-bootstrap)))
+    (properties '((hidden? #t)))))
+
+(define-public ghc-network
+  (package
+    (name "ghc-network")
+    (version "2.6.3.6")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/network/network-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "198mam7ahny48p9fajznbqq16a8ya2gw0xm3gnm1si1rmc4hdplv"))))
+    (build-system haskell-build-system)
+    ;; The regression tests depend on an unpublished module.
+    (arguments `(#:tests? #f))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://github.com/haskell/network")
+    (synopsis "Low-level networking interface")
+    (description
+     "This package provides a low-level networking interface.")
+    (license license:bsd-3)))
+
+(define-public ghc-network-info
+  (package
+    (name "ghc-network-info")
+    (version "0.2.0.10")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "network-info-" version "/"
+                           "network-info-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/jystic/network-info")
+    (synopsis "Access the local computer's basic network configuration")
+    (description "This Haskell library provides simple read-only access to the
+local computer's networking configuration.  It is currently capable of
+getting a list of all the network interfaces and their respective
+IPv4, IPv6 and MAC addresses.")
+    (license license:bsd-3)))
+
+(define-public ghc-network-uri
+  (package
+    (name "ghc-network-uri")
+    (version "2.6.1.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/network-uri/network-uri-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1w27zkvn39kjr9lmw9421y8w43h572ycsfafsb7kyvr3a4ihlgj2"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
+    (inputs
+     `(("ghc-network" ,ghc-network)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page
+     "https://github.com/haskell/network-uri")
+    (synopsis "Library for URI manipulation")
+    (description "This package provides an URI manipulation interface.  In
+@code{network-2.6} the @code{Network.URI} module was split off from the
+@code{network} package into this package.")
+    (license license:bsd-3)))
+
+(define-public ghc-newtype-generics
+  (package
+    (name "ghc-newtype-generics")
+    (version "0.5.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "newtype-generics/newtype-generics-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0igyisw2djg19v9vkna1rwf47k97mvkvk4bbkmswznvbm00z15gj"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "http://github.com/sjakobi/newtype-generics")
+    (synopsis "Typeclass and set of functions for working with newtypes")
+    (description "The @code{Newtype} typeclass represents the packing and
+unpacking of a newtype, and allows you to operate under that newtype with
+functions such as @code{ala}.  Generics support was added in version 0.4,
+making this package a full replacement for the original newtype package,
+and an alternative to newtype-th.")
+    (license license:bsd-3)))
+
+(define-public ghc-objectname
+  (package
+    (name "ghc-objectname")
+    (version "1.1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/ObjectName/ObjectName-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "046jm94rmm46cicd31pl54vdvfjvhd9ffbfycy2lxzc0fliyznvj"))))
+    (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 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
+             "https://hackage.haskell.org/package/old-locale/old-locale-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "04b9vn007hlvsrx4ksd3r8r3kbyaj2kvwxchdrmd4370qzi8p6gs")))
+    (home-page "https://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 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
+             "https://hackage.haskell.org/package/old-time/old-time-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "1j6ln1dkvhdvnwl33bp0xf9lhc4sybqk0aw42p8cq81xwwzbn7y9")))
+    (inputs
+     `(("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "https://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{https://hackage.haskell.org/package/time, time library} is recommended.")
+    (license license:bsd-3)))
+
+(define-public ghc-opengl
+  (package
+    (name "ghc-opengl")
+    (version "3.0.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/OpenGL/OpenGL-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "19vxwvx2n8zq2klj176l25n2b64ybp0b8mhm4p46gvpcivz41fjc"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-objectname" ,ghc-objectname)
+       ("ghc-gluraw" ,ghc-gluraw)
+       ("ghc-statevar" ,ghc-statevar)
+       ("ghc-openglraw" ,ghc-openglraw)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-openglraw
+  (package
+    (name "ghc-openglraw")
+    (version "3.3.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1x8w3x308jldj2c1xqcq3a3sc2jc06pdpgqkgjsmixi1skv4a1vb"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-half" ,ghc-half)
+       ("ghc-fixed" ,ghc-fixed)
+       ("glu" ,glu)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-operational
+  (package
+    (name "ghc-operational")
+    (version "0.2.3.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/operational/"
+                           "operational-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1x2abg2q9d26h1vzj40r6k7k3gqgappbs4g9d853vvg77837km4i"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-random" ,ghc-random)))
+    (home-page "http://wiki.haskell.org/Operational")
+    (synopsis "Implementation of difficult monads made easy with operational semantics")
+    (description
+     "This library makes it easy to implement monads with tricky control
+flow. This is useful for: writing web applications in a sequential style,
+programming games with a uniform interface for human and AI players and easy
+replay capababilities, implementing fast parser monads, designing monadic
+DSLs, etc.")
+    (license license:bsd-3)))
+
+(define-public ghc-options
+  (package
+    (name "ghc-options")
+    (version "1.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/options/options-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-monads-tf" ,ghc-monads-tf)
+       ("ghc-chell" ,ghc-chell)
+       ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)))
+    (home-page "https://john-millikin.com/software/haskell-options/")
+    (synopsis "Powerful and easy-to-use command-line option parser")
+    (description
+     "The @code{options} package lets library and application developers
+easily work with command-line options.")
+    (license license:expat)))
+
+;; See ghc-system-filepath-bootstrap, chell and chell-quickcheck are required for tests.
+(define ghc-options-bootstrap
+  (package
+    (name "ghc-options-bootstrap")
+    (version "1.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/options/options-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f))
+    (inputs
+     `(("ghc-monads-tf" ,ghc-monads-tf)))
+    (home-page "https://john-millikin.com/software/haskell-options/")
+    (synopsis "Powerful and easy-to-use command-line option parser")
+    (description
+     "The @code{options} package lets library and application developers
+easily work with command-line options.")
+    (license license:expat)))
+
+
+(define-public ghc-optparse-applicative
+  (package
+    (name "ghc-optparse-applicative")
+    (version "0.14.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/optparse-applicative"
+             "/optparse-applicative-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0c3z1mvynlyv1garjbdmdd3npm40dabgm75js4r07cf766c1wd71"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (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 license:bsd-3)))
+
+(define-public ghc-pandoc
+  (package
+    (name "ghc-pandoc")
+    (version "2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1dqin92w513l7whg5wdgrngnxsj5mb8gppfvn7kjgyv2pdgpy0zy"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "pandoc.cabal"
+               (("tasty >= 0\\.11 && < 1\\.1")
+                "tasty >= 0.11 && < 1.1.1"))))
+         (add-before 'configure 'patch-tests
+           (lambda _
+             ;; These tests fail benignly and have been adjusted upstream:
+             ;; <https://github.com/commercialhaskell/stackage/issues/3719>.
+             (substitute* "test/Tests/Old.hs"
+               (("lhsWriterTests \"html\"") "[]")))))))
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-aeson-pretty" ,ghc-aeson-pretty)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)
+       ("ghc-cmark-gfm" ,ghc-cmark-gfm)
+       ("ghc-data-default" ,ghc-data-default)
+       ("ghc-deepseq-generics" ,ghc-deepseq-generics)
+       ("ghc-diff" ,ghc-diff)
+       ("ghc-doctemplates" ,ghc-doctemplates)
+       ("ghc-executable-path" ,ghc-executable-path)
+       ("ghc-glob" ,ghc-glob)
+       ("ghc-haddock-library" ,ghc-haddock-library)
+       ("ghc-hslua" ,ghc-hslua)
+       ("ghc-hslua-module-text" ,ghc-hslua-module-text)
+       ("ghc-http" ,ghc-http)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-http-client-tls" ,ghc-http-client-tls)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-juicypixels" ,ghc-juicypixels)
+       ("ghc-network" ,ghc-network)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-pandoc-types" ,ghc-pandoc-types)
+       ("ghc-random" ,ghc-random)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-sha" ,ghc-sha)
+       ("ghc-skylighting" ,ghc-skylighting)
+       ("ghc-split" ,ghc-split)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-tagsoup" ,ghc-tagsoup)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-texmath" ,ghc-texmath)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-xml" ,ghc-xml)
+       ("ghc-yaml" ,ghc-yaml)
+       ("ghc-zip-archive" ,ghc-zip-archive)
+       ("ghc-zlib" ,ghc-zlib)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://pandoc.org")
+    (synopsis "Conversion between markup formats")
+    (description
+     "Pandoc is a Haskell library for converting from one markup format to
+another, and a command-line tool that uses this library.  It can read and
+write Markdown and (subsets of) other formats, such as HTML, reStructuredText,
+LaTeX, DocBook, and many more.
+
+Pandoc extends standard Markdown syntax with footnotes, embedded LaTeX,
+definition lists, tables, and other features.  A compatibility mode is
+provided for those who need a drop-in replacement for Markdown.pl.")
+    (license license:gpl2+)))
+
+(define-public ghc-pandoc-citeproc
+  (package
+    (name "ghc-pandoc-citeproc")
+    (version "0.14.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "pandoc-citeproc/pandoc-citeproc-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0yj6rckwsc9vig40cm15ry0j3d01xpk04qma9n4byhal6v4b5h22"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         ;; Many YAML tests (44) are failing do to changes in ghc-yaml:
+         ;; <https://github.com/jgm/pandoc-citeproc/issues/342>.
+         (add-before 'configure 'patch-tests
+           (lambda _
+             (substitute* "tests/test-pandoc-citeproc.hs"
+               (("let allTests = citeprocTests \\+\\+ biblio2yamlTests")
+                "let allTests = citeprocTests"))))
+         ;; Tests need to be run after installation.
+         (delete 'check)
+         (add-after 'install 'post-install-check
+           (assoc-ref %standard-phases 'check)))))
+    (inputs
+     `(("ghc-pandoc-types" ,ghc-pandoc-types)
+       ("ghc-pandoc" ,ghc-pandoc)
+       ("ghc-tagsoup" ,ghc-tagsoup)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-xml-conduit" ,ghc-xml-conduit)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-data-default" ,ghc-data-default)
+       ("ghc-setenv" ,ghc-setenv)
+       ("ghc-split" ,ghc-split)
+       ("ghc-yaml" ,ghc-yaml)
+       ("ghc-hs-bibutils" ,ghc-hs-bibutils)
+       ("ghc-rfc5051" ,ghc-rfc5051)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-aeson-pretty" ,ghc-aeson-pretty)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://github.com/jgm/pandoc-citeproc")
+    (synopsis "Library for using pandoc with citeproc")
+    (description
+     "The @code{pandoc-citeproc} library exports functions for using the
+citeproc system with pandoc.  It relies on @code{citeproc-hs}, a library for
+rendering bibliographic reference citations into a variety of styles using a
+macro language called @dfn{Citation Style Language} (CSL).  This package also
+contains an executable @code{pandoc-citeproc}, which works as a pandoc filter,
+and also has a mode for converting bibliographic databases a YAML format
+suitable for inclusion in pandoc YAML metadata.")
+    (license license:bsd-3)))
+
+(define-public ghc-pandoc-types
+  (package
+    (name "ghc-pandoc-types")
+    (version "1.17.5.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "pandoc-types/pandoc-types-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1q6v2bynij724fv347mhqxdscwifzrx5jb9mq80608qf638fn717"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-syb" ,ghc-syb)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-string-qq" ,ghc-string-qq)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "http://johnmacfarlane.net/pandoc")
+    (synopsis "Types for representing a structured document")
+    (description
+     "This module defines the @code{Pandoc} data structure, which is used by
+pandoc to represent structured documents.  It also provides functions for
+building up, manipulating and serialising @code{Pandoc} structures.")
+    (license license:bsd-3)))
+
+(define-public ghc-parallel
+  (package
+    (name "ghc-parallel")
+    (version "3.2.2.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/parallel/parallel-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1xkfi96w6yfpppd0nw1rnszdxmvifwzm699ilv6332ra3akm610p"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/parallel")
+    (synopsis "Parallel programming library")
+    (description
+     "This package provides a library for parallel programming.")
+    (license license:bsd-3)))
+
+(define-public ghc-parsec-numbers
+  (package
+    (name "ghc-parsec-numbers")
+    (version "0.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "parsec-numbers/parsec-numbers-" version ".tar.gz"))
+       (sha256
+        (base32 "1gzy4v3r02kvdxvgg1nj83mmb6aph2v4ilf9c7y6nbvi2x49l0bp"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/parsec-numbers")
+    (synopsis "Utilities for parsing numbers from strings")
+    (description
+     "This package provides the number parsers without the need to use a large
+(and unportable) token parser.")
+    (license license:bsd-3)))
+
+(define-public ghc-parser-combinators
+  (package
+    (name "ghc-parser-combinators")
+    (version "1.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "parser-combinators/parser-combinators-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1pwfdsklqwvaynwpdzmx1bs35mp6dpsyaqdnzxnqcrxwf5h8sk75"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/mrkkrp/parser-combinators")
+    (synopsis "Commonly useful parser combinators")
+    (description
+     "This is a lightweight package providing commonly useful parser
+combinators.")
+    (license license:bsd-3)))
+
+(define-public ghc-parsers
+  (package
+    (name "ghc-parsers")
+    (version "0.12.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/parsers/parsers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1r05sc1mcglk8w596kq9a1brfn9c2vll8lq16j07ln0vsz4jzrc1"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
+                               ; -package attoparsec-0.13.0.1"
+    (inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-charset" ,ghc-charset)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-path
+  (package
+    (name "ghc-path")
+    (version "0.6.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/path/path-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0nayla4k1gb821k8y5b9miflv1bi8f0czf9rqr044nrr2dddi2sb"))))
+    (build-system haskell-build-system)
+    (arguments
+     ;; TODO: There are some Windows-related tests and modules that need to be
+     ;; danced around.
+     `(#:tests? #f
+       #:cabal-revision
+       ("1" "05b1zwx2a893h4h5wvgpc5g5pyx71hfmx409rqisd8s1bq1hn463")))
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-hashable" ,ghc-hashable)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-genvalidity" ,ghc-genvalidity)
+       ("ghc-genvalidity-property" ,ghc-genvalidity-property)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-validity" ,ghc-validity)))
+    (home-page
+     "http://hackage.haskell.org/package/path")
+    (synopsis "Support for well-typed paths")
+    (description "This package introduces a type for paths upholding useful
+invariants.")
+    (license license:bsd-3)))
+
+(define-public ghc-path-io
+  (package
+    (name "ghc-path-io")
+    (version "1.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/path-io/path-io-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1g9m3qliqjk1img894wsb89diym5zrq51qkkrwhz4sbm9a8hbv1a"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-dlist" ,ghc-dlist)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-path" ,ghc-path)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-temporary" ,ghc-temporary)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (arguments
+    `(#:cabal-revision
+      ("3" "1h9hsibbflkxpjl2fqamqiv3x3gasf51apnmklrs9l9x8r32hzcc")))
+    (home-page
+     "https://github.com/mrkkrp/path-io")
+    (synopsis "Functions for manipulating well-typed paths")
+    (description "This package provides an interface to the @code{directory}
+package for users of @code{path}.  It also implements some missing stuff like
+recursive scanning and copying of directories, working with temporary
+files/directories, and more.")
+    (license license:bsd-3)))
+
+(define-public ghc-paths
+  (package
+    (name "ghc-paths")
+    (version "0.1.0.9")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/ghc-paths/ghc-paths-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/simonmar/ghc-paths")
+    (synopsis
+     "Knowledge of GHC's installation directories")
+    (description
+     "Knowledge of GHC's installation directories.")
+    (license license:bsd-3)))
+
+(define-public ghc-patience
+  (package
+    (name "ghc-patience")
+    (version "0.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/patience/patience-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/patience")
+    (synopsis "Patience diff and longest increasing subsequence")
+    (description
+     "This library implements the 'patience diff' algorithm, as well as the
+patience algorithm for the longest increasing subsequence problem.
+Patience diff computes the difference between two lists, for example the lines
+of two versions of a source file.  It provides a good balance between
+performance, nice output for humans, and simplicity of implementation.")
+    (license license:bsd-3)))
+
+(define-public ghc-pcre-light
+  (package
+    (name "ghc-pcre-light")
+    (version "0.4.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/pcre-light/pcre-light-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0xcyi1fivwg7a92mch5bcqzmrfxzqj42rmb3m8kgs61x4qwpxj82"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("pcre" ,pcre)))
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (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 license:bsd-3)))
+
+(define-public ghc-persistent
+  (package
+    (name "ghc-persistent")
+    (version "2.8.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "persistent-" version "/"
+                           "persistent-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-old-locale" ,ghc-old-locale)
+              ("ghc-conduit" ,ghc-conduit)
+              ("ghc-resourcet" ,ghc-resourcet)
+              ("ghc-exceptions" ,ghc-exceptions)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-lifted-base" ,ghc-lifted-base)
+              ("ghc-resource-pool" ,ghc-resource-pool)
+              ("ghc-path-pieces" ,ghc-path-pieces)
+              ("ghc-http-api-data" ,ghc-http-api-data)
+              ("ghc-aeson" ,ghc-aeson)
+              ("ghc-monad-logger" ,ghc-monad-logger)
+              ("ghc-transformers-base" ,ghc-transformers-base)
+              ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-attoparsec" ,ghc-attoparsec)
+              ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
+              ("ghc-blaze-html" ,ghc-blaze-html)
+              ("ghc-blaze-markup" ,ghc-blaze-markup)
+              ("ghc-silently" ,ghc-silently)
+              ("ghc-fast-logger" ,ghc-fast-logger)
+              ("ghc-scientific" ,ghc-scientific)
+              ("ghc-tagged" ,ghc-tagged)
+              ("ghc-void" ,ghc-void)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://www.yesodweb.com/book/persistent")
+    (synopsis "Type-safe, multi-backend data serialization for Haskell")
+    (description "This Haskell package allows Haskell programs to access data
+storage systems like PostgreSQL, SQLite, MySQL and MongoDB in a type-safe
+way.")
+    (license license:expat)))
+
+(define-public ghc-persistent-sqlite
+  (package
+    (name "ghc-persistent-sqlite")
+    (version "2.8.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "persistent-sqlite-" version "/"
+                           "persistent-sqlite-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1chbmvjz46smhgnzhha3bbkhys3fys6dip1jr4v7xp1jf78zbyp6"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-persistent" ,ghc-persistent)
+              ("ghc-unliftio-core" ,ghc-unliftio-core)
+              ("ghc-aeson" ,ghc-aeson)
+              ("ghc-conduit" ,ghc-conduit)
+              ("ghc-monad-logger" ,ghc-monad-logger)
+              ("ghc-microlens-th" ,ghc-microlens-th)
+              ("ghc-resourcet" ,ghc-resourcet)
+              ("ghc-old-locale" ,ghc-old-locale)
+              ("ghc-resource-pool" ,ghc-resource-pool)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-persistent-template" ,ghc-persistent-template)
+                     ("ghc-temporary" ,ghc-temporary)))
+    (home-page
+     "https://www.yesodweb.com/book/persistent")
+    (synopsis "Backend for the persistent library using sqlite3")
+    (description "This Haskell package includes a thin sqlite3 wrapper based
+on the direct-sqlite package, as well as the entire C library, so there are no
+system dependencies.")
+    (license license:expat)))
+
+(define-public ghc-persistent-template
+  (package
+    (name "ghc-persistent-template")
+    (version "2.5.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "persistent-template-" version "/"
+                           "persistent-template-" version ".tar.gz"))
+       (sha256
+        (base32
+         "008afcy7zbw7bzp9jww8gdldb51kfm0fg4p0x4xcp61gx4679bjc"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "03qgwk32krldph3blw5agiqcpccr3649hajyn8wm9k71zz82dpn6")))
+    (inputs `(("ghc-persistent" ,ghc-persistent)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-aeson" ,ghc-aeson)
+              ("ghc-aeson-compat" ,ghc-aeson-compat)
+              ("ghc-monad-logger" ,ghc-monad-logger)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-tagged" ,ghc-tagged)
+              ("ghc-path-pieces" ,ghc-path-pieces)
+              ("ghc-http-api-data" ,ghc-http-api-data)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://www.yesodweb.com/book/persistent")
+    (synopsis "Type-safe, non-relational, multi-backend persistence")
+    (description "This Haskell package provides interfaces and helper
+functions for the ghc-persistent package.")
+    (license license:expat)))
+
+(define-public ghc-polyparse
+  (package
+    (name "ghc-polyparse")
+    (version "1.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/polyparse/polyparse-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "05dya1vdvq29hkhkdlsglzhw7bdn51rvs1javs0q75nf99c66k7m"))))
+    (build-system haskell-build-system)
+    (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 license:lgpl2.1)))
+
+(define-public ghc-pqueue
+  (package
+    (name "ghc-pqueue")
+    (version "1.4.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "pqueue/pqueue-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1zvwm1zcqqq5n101s1brjhgbay8rf9fviq6gxbplf40i63m57p1x"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/pqueue")
+    (synopsis "Reliable, persistent, fast priority queues")
+    (description
+     "This package provides a fast, reliable priority queue implementation
+based on a binomial heap.")
+    (license license:bsd-3)))
+
+(define-public ghc-prelude-extras
+  (package
+    (name "ghc-prelude-extras")
+    (version "0.4.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/prelude-extras/prelude-extras-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0xzqdf3nl2h0ra4gnslm1m1nsxlsgc0hh6ky3vn578vh11zhifq9"))))
+    (build-system haskell-build-system)
+    (home-page "https://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 license:bsd-3)))
+
 (define-public ghc-prettyclass
   (package
     (name "ghc-prettyclass")
@@ -191,6 +7598,219 @@ provides the pretty printing class and instances for the Prelude
 types.")
     (license license:bsd-3)))
 
+(define-public ghc-pretty-hex
+  (package
+    (name "ghc-pretty-hex")
+    (version "1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "pretty-hex-" version "/"
+                           "pretty-hex-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0ylwkvvjvmpprha9nx83xb8gkhyanhk5fffc0r7lb96n4ch5z6pz"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/GaloisInc/hexdump")
+    (synopsis "Haskell library for hex dumps of ByteStrings")
+    (description "This Haskell library generates pretty hex dumps of
+ByteStrings in the style of other common *nix hex dump tools.")
+    (license license:bsd-3)))
+
+(define-public ghc-pretty-show
+  (package
+    (name "ghc-pretty-show")
+    (version "1.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/pretty-show/"
+                           "pretty-show-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0br7pkxqqqhby2j2v1g847lgqsrasx56g1jw3dhmjh4flzs6warq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-haskell-lexer" ,ghc-haskell-lexer)
+       ("ghc-happy" ,ghc-happy)))
+    (home-page "http://wiki.github.com/yav/pretty-show")
+    (synopsis "Tools for working with derived `Show` instances")
+    (description
+     "This package provides a library and an executable for working with
+derived @code{Show} instances.  By using the library, derived @code{Show}
+instances can be parsed into a generic data structure.  The @code{ppsh} tool
+uses the library to produce human-readable versions of @code{Show} instances,
+which can be quite handy for debugging Haskell programs.  We can also render
+complex generic values into an interactive Html page, for easier
+examination.")
+    (license license:expat)))
+
+(define-public ghc-primitive
+  (package
+    (name "ghc-primitive")
+    (version "0.6.4.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/primitive/primitive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0r0cda7acvplgwaxy69kviv4jp7kkfi038by68gj4yfx4iwszgjc"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://github.com/haskell/primitive")
+    (synopsis "Primitive memory-related operations")
+    (description
+     "This package provides various primitive memory-related operations.")
+    (license license:bsd-3)))
+
+(define-public ghc-profunctors
+  (package
+    (name "ghc-profunctors")
+    (version "5.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/profunctors/profunctors-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0s1pwjidbn761xk43pmzyvn99hm3psdifjd78ylki7f97aiyd0g9"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "1ywlg9z8nlhd2avgb8c6gbkv8zyk7hvc25926bafyg0m0k8y1amq")))
+    (inputs
+     `(("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-contravariant" ,ghc-contravariant)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page "https://github.com/ekmett/profunctors/")
+    (synopsis "Profunctors for Haskell")
+    (description "This library provides profunctors for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-psqueues
+  (package
+    (name "ghc-psqueues")
+    (version "0.2.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "psqueues-" version "/"
+                           "psqueues-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1sjgc9bxh63kkdp59nbirx3xazr02ia5yhp4f4a0jnq1hj465wsc"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/jaspervdj/psqueues")
+    (synopsis "Pure priority search queues")
+    (description "The psqueues package provides
+@uref{https://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in
+three different flavors:
+
+@itemize
+@item @code{OrdPSQ k p v}, which uses the @code{Ord k} instance to provide
+fast insertion, deletion and lookup.  This implementation is based on Ralf
+Hinze's @uref{http://citeseer.ist.psu.edu/hinze01simple.html, A Simple
+Implementation Technique for Priority Search Queues}.
+
+Hence, it is similar to the @uref{https://hackage.haskell.org/package/PSQueue,
+PSQueue} library, although it is considerably faster and provides a slightly
+different API.
+
+@item @code{IntPSQ p v} is a far more efficient implementation.  It fixes the
+key type to @code{Int} and uses a
+@code{https://en.wikipedia.org/wiki/Radix_tree, radix tree} (like @code{IntMap})
+with an additional min-heap property.
+
+@item @code{HashPSQ k p v} is a fairly straightforward extension
+of @code{IntPSQ}: it simply uses the keys' hashes as indices in the
+@code{IntPSQ}.  If there are any hash collisions, it uses an
+@code{OrdPSQ} to resolve those.  The performance of this implementation
+is comparable to that of @code{IntPSQ}, but it is more widely
+applicable since the keys are not restricted to @code{Int},
+but rather to any @code{Hashable} datatype.
+@end itemize
+
+Each of the three implementations provides the same API, so they can
+be used interchangeably.
+
+Typical applications of Priority Search Queues include:
+
+@itemize
+@item Caches, and more specifically LRU Caches;
+@item Schedulers;
+@item Pathfinding algorithms, such as Dijkstra's and A*.
+@end itemize")
+    (license license:bsd-3)))
+
+(define-public ghc-random
+  (package
+    (name "ghc-random")
+    (version "1.1")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/random/random-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/random")
+    (synopsis "Random number library")
+    (description "This package provides a basic random number generation
+library, including the ability to split random number generators.")
+    (license license:bsd-3)))
+
+(define-public ghc-raw-strings-qq
+  (package
+    (name "ghc-raw-strings-qq")
+    (version "1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "raw-strings-qq/raw-strings-qq-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1lxy1wy3awf52968iy5y9r5z4qgnn2sxkdrh7js3m9gadb11w09f"))))
+    (build-system haskell-build-system)
+    (native-inputs `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/23Skidoo/raw-strings-qq")
+    (synopsis "Raw string literals for Haskell")
+    (description
+     "This package provides a quasiquoter for raw string literals, i.e. string
+literals that don't recognise the standard escape sequences.  Basically, they
+make your code more readable by freeing you from the responsibility to escape
+backslashes.  They are useful when working with regular expressions,
+DOS/Windows paths and markup languages (such as XML).")
+    (license license:bsd-3)))
+
 (define-public ghc-readable
   (package
     (name "ghc-readable")
@@ -211,6 +7831,2084 @@ reading data types from @code{ByteString} and @code{Text}.  It also
 includes efficient implementations for common data types.")
     (license license:bsd-3)))
 
+(define-public ghc-rebase
+  (package
+    (name "ghc-rebase")
+    (version "1.2.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "rebase-" version "/"
+                           "rebase-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1gah2qwfpzwamnikbc5h4nv6dgvv9h16di9ka7946za3nibyasya"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-hashable" ,ghc-hashable)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-scientific" ,ghc-scientific)
+              ("ghc-uuid" ,ghc-uuid)
+              ("ghc-dlist" ,ghc-dlist)
+              ("ghc-void" ,ghc-void)
+              ("ghc-bifunctors" ,ghc-bifunctors)
+              ("ghc-profunctors" ,ghc-profunctors)
+              ("ghc-contravariant" ,ghc-contravariant)
+              ("ghc-contravariant-extras" ,ghc-contravariant-extras)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-either" ,ghc-either)
+              ("ghc-fail" ,ghc-fail)
+              ("ghc-base-prelude" ,ghc-base-prelude)))
+    (home-page "https://github.com/nikita-volkov/rebase")
+    (synopsis "Progressive alternative to the base package
+for Haskell")
+    (description "This Haskell package is intended for those who are
+tired of keeping long lists of dependencies to the same essential libraries
+in each package as well as the endless imports of the same APIs all over again.
+
+It also supports the modern tendencies in the language.
+
+To solve those problems this package does the following:
+
+@itemize
+@item Reexport the original APIs under the @code{Rebase} namespace.
+
+@item Export all the possible non-conflicting symbols from the
+@code{Rebase.Prelude} module.
+
+@item Give priority to the modern practices in the conflicting cases.
+@end itemize
+
+The policy behind the package is only to reexport the non-ambiguous and
+non-controversial APIs, which the community has obviously settled on.
+The package is intended to rapidly evolve with the contribution from
+the community, with the missing features being added with pull-requests.")
+    (license license:expat)))
+
+(define-public ghc-reducers
+  (package
+    (name "ghc-reducers")
+    (version "3.12.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/reducers/reducers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09wf8pl9ycglcv6qj5ba26gkg2s5iy81hsx9xp0q8na0cwvp71ki"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-fingertree" ,ghc-fingertree)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-refact
+  (package
+    (name "ghc-refact")
+    (version "0.3.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "refact/refact-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/refact")
+    (synopsis "Specify refactorings to perform with apply-refact")
+    (description
+     "This library provides a datatype which can be interpreted by
+@code{apply-refact}.  It exists as a separate library so that applications can
+specify refactorings without depending on GHC.")
+    (license license:bsd-3)))
+
+(define-public ghc-reflection
+  (package
+    (name "ghc-reflection")
+    (version "2.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/reflection/reflection-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0kf4a5ijw6jfnfibjcrpdy9vzh1n6v2pxia8dhyyqdissiwc8bzj"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-tagged" ,ghc-tagged)))
+    (home-page "https://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
+propagating 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 license:bsd-3)))
+
+(define-public ghc-regex
+  (package
+    (name "ghc-regex")
+    (version "1.0.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/regex/"
+                           "regex-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'relax-dependencies
+           (lambda _
+             (substitute* "regex.cabal"
+               (("base-compat.*>=.*0.6.*")
+                "base-compat >= 0.6\n")
+               (("template-haskell.*>=.*2.7.*")
+                "template-haskell >= 2.7\n"))
+             #t)))))
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-regex-base" ,ghc-regex-base)
+       ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
+       ("ghc-regex-tdfa" ,ghc-regex-tdfa)
+       ("ghc-regex-tdfa-text" ,ghc-regex-tdfa-text)
+       ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (home-page "http://regex.uk")
+    (synopsis "Toolkit for regex-base")
+    (description
+     "This package provides a regular expression toolkit for @code{regex-base}
+with compile-time checking of regular expression syntax, data types for
+matches and captures, a text replacement toolkit, portable options, high-level
+AWK-like tools for building text processing apps, regular expression macros
+with parsers and test bench, comprehensive documentation, tutorials and
+copious examples.")
+    (license license:bsd-3)))
+
+(define-public ghc-regex-applicative
+  (package
+    (name "ghc-regex-applicative")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/regex-applicative/"
+             "regex-applicative-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1riv7jqf26lbv4rm54sd6mrx8xdh4dvh4xbzymzdfdw13k6a4nb6"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/feuerbach/regex-applicative")
+    (synopsis "Regex-based parsing with applicative interface")
+    (description
+     "@code{regex-applicative} is a Haskell library for parsing using
+regular expressions.  Parsers can be built using Applicative interface.")
+    (license license:expat)))
+
+(define-public ghc-regex-base
+  (package
+    (name "ghc-regex-base")
+    (version "0.93.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/regex-base/regex-base-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://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 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
+             "https://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 "https://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 license:bsd-3)))
+
+(define-public ghc-regex-compat-tdfa
+  (package
+    (name "ghc-regex-compat-tdfa")
+    (version "0.95.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/regex-compat-tdfa/regex-compat-tdfa-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-base" ,ghc-regex-base)
+       ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
+    (home-page "https://hub.darcs.net/shelarcy/regex-compat-tdfa")
+    (synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
+    (description
+     "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
+@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
+This is not good for Unicode users.  This modified regex-compat uses regex-tdfa to solve
+this problem.")
+    (license license:bsd-3)))
+
+(define-public ghc-regex-pcre-builtin
+  (package
+    (name "ghc-regex-pcre-builtin")
+    (version "0.94.4.8.8.35")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "regex-pcre-builtin/regex-pcre-builtin-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-base" ,ghc-regex-base)))
+    (home-page "https://hackage.haskell.org/package/regex-pcre")
+    (synopsis "Enhancement of the builtin Text.Regex library")
+    (description
+     "This package is an enhancement of the @code{Text.Regex} library,
+providing the PCRE backend to accompany regex-base, with bundled code from
+@url{https://www.pcre.org}.")
+    (license 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
+             "https://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 "https://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 license:bsd-3)))
+
+(define-public ghc-regex-tdfa
+  (package
+    (name "ghc-regex-tdfa")
+    (version "1.2.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/regex-tdfa/regex-tdfa-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0l7ajnh4hpgggf2a1r9dg0hx2fy679vd2kada5y7r02hy3nfxala"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-base" ,ghc-regex-base)))
+    (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
+    (synopsis "POSIX extended regular expressions in Haskell.")
+    (description
+     "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
+extended regular expressions.  It is a \"tagged\" DFA regex engine. It is
+inspired by libtre.")
+    (license license:bsd-3)))
+
+(define-public ghc-regex-tdfa-text
+  (package
+    (name "ghc-regex-tdfa-text")
+    (version "1.0.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/regex-tdfa-text/"
+             "regex-tdfa-text-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0090g6lgbdm9lywpqm2d3724nnnh24nx3vnlqr96qc2w486pmmrq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-base" ,ghc-regex-base)
+       ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
+    (home-page
+     "http://hackage.haskell.org/package/regex-tdfa-text")
+    (synopsis "Text interface for regex-tdfa")
+    (description
+     "This provides an extra text interface for regex-tdfa.")
+    (license license:bsd-3)))
+
+(define-public ghc-rerebase
+  (package
+    (name "ghc-rerebase")
+    (version "1.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/rerebase/rerebase-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "11v6rmz7ql2rdx6mhb3lsal952lwihclfhh0m7fcnii5br0906ks"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-rebase" ,ghc-rebase)))
+    (home-page "https://github.com/nikita-volkov/rerebase")
+    (synopsis "Reexports from ``base'' with many other standard libraries")
+    (description "A rich drop-in replacement for @code{base}.  For details and
+documentation please visit @uref{https://github.com/nikita-volkov/rerebase,
+the project's home page}.")
+    (license license:expat)))
+
+(define-public ghc-resolv
+  (package
+    (name "ghc-resolv")
+    (version "0.1.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/resolv/resolv-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0wh7wj56l3f2bylz563g5g04a4nydj8acv60hpwa7k3mn792xca9"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "15ay4n3x8c09cb3h4z1nan84yd3n9zpgvi6h114hk98bq10k8mma")
+       #:tests? #f)) ; The required test frameworks are too old.
+    (inputs
+     `(("ghc-base16-bytestring" ,ghc-base16-bytestring)))
+    (home-page "https://github.com/haskell/hackage-security")
+    (synopsis "Domain Name Service (DNS) lookup via @code{libresolv}")
+    (description "This package implements an API for accessing the
+@uref{https://tools.ietf.org/html/rfc1035, Domain Name Service (DNS)}
+resolver service via the standard @code{libresolv} system library (whose
+API is often available directly via the standard @code{libc} C library) on
+Unix systems.")
+    (license license:gpl3)))
+
+(define-public ghc-resource-pool
+  (package
+    (name "ghc-resource-pool")
+    (version "0.2.3.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "resource-pool-" version "/"
+                           "resource-pool-" version ".tar.gz"))
+       (sha256
+        (base32
+         "04mw8b9djb14zp4rdi6h7mc3zizh597ffiinfbr4m0m8psifw9w6"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-hashable" ,ghc-hashable)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-transformers-base" ,ghc-transformers-base)
+              ("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/bos/pool")
+    (synopsis "Striped resource pooling implementation in Haskell")
+    (description "This Haskell package provides striped pooling abstraction
+for managing flexibly-sized collections of resources such as database
+connections.")
+    (license license:bsd-3)))
+
+(define-public ghc-resourcet
+  (package
+    (name "ghc-resourcet")
+    (version "1.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/resourcet/"
+                           "resourcet-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0rzjzh34s36ssign7akqjnwnjxf11c3511wk7ky0xxy0dqmc2rg7"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-mmorph" ,ghc-mmorph)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)))
+    (native-inputs
+     `(("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-rfc5051
+  (package
+    (name "ghc-rfc5051")
+    (version "0.1.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/rfc5051/"
+                           "rfc5051-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/rfc5051")
+    (synopsis "Simple unicode collation as per RFC5051")
+    (description
+     "This library implements @code{unicode-casemap}, the simple, non
+locale-sensitive unicode collation algorithm described in RFC 5051.  Proper
+unicode collation can be done using @code{text-icu}, but that is a big
+dependency that depends on a large C library, and @code{rfc5051} might be
+better for some purposes.")
+    (license license:bsd-3)))
+
+(define-public ghc-rio
+  (package
+    (name "ghc-rio")
+    (version "0.1.5.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/rio/rio-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "064h8a4hp53a479d3ak0vmqbx8hi0cpg7zn4wp23rjy26dka8p7g"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-microlens" ,ghc-microlens)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-typed-process" ,ghc-typed-process)
+       ("ghc-unliftio" ,ghc-unliftio)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/commercialhaskell/rio#readme")
+    (synopsis "A standard library for Haskell")
+    (description "This package works as a prelude replacement for Haskell,
+providing more functionality and types out of the box than the standard
+prelude (such as common data types like @code{ByteString} and
+@code{Text}), as well as removing common ``gotchas'', like partial
+functions and lazy I/O.  The guiding principle here is:
+@itemize
+@item If something is safe to use in general and has no expected naming
+conflicts, expose it.
+@item If something should not always be used, or has naming conflicts,
+expose it from another module in the hierarchy.
+@end itemize")
+    (license license:expat)))
+
+(define-public ghc-safe
+  (package
+    (name "ghc-safe")
+    (version "0.3.17")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/safe/safe-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0p3yaf5slvyz1cyy51jq64c5rlp8yzwim8iy2dlnk42if4gc9ibr"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (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 license:bsd-3)))
+
+(define-public ghc-safe-exceptions
+  (package
+    (name "ghc-safe-exceptions")
+    (version "0.1.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "safe-exceptions/safe-exceptions-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0sd0zfsm9pcll5bzzj523rbn45adjrnavdkz52hgmdjjgdcdrk8q"))))
+    (build-system haskell-build-system)
+    (arguments
+     '(#:cabal-revision
+       ("4" "0fid41gishzsyb47wzxhd5falandfirqcp760hcja81qjpfmqd32")))
+    (inputs `(("ghc-exceptions" ,ghc-exceptions)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-void" ,ghc-void)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/fpco/safe-exceptions")
+    (synopsis "Safe, consistent, and easy exception handling")
+    (description "Runtime exceptions - as exposed in @code{base} by the
+@code{Control.Exception} module - have long been an intimidating part of the
+Haskell ecosystem.  This package is intended to overcome this.  It provides a
+safe and simple API on top of the existing exception handling machinery.  The
+API is equivalent to the underlying implementation in terms of power but
+encourages best practices to minimize the chances of getting the exception
+handling wrong.")
+    (license license:expat)))
+
+(define-public ghc-safeio
+  (package
+    (name "ghc-safeio")
+    (version "0.0.5.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/safeio/"
+                           "safeio-" version ".tar.gz"))
+       (sha256
+        (base32
+         "04g3070cbjdqj0h9l9ii6470xcbn40xfv4fr89a8yvnkdim9nyfm"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-combinators" ,ghc-conduit-combinators)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-resourcet" ,ghc-resourcet)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-th" ,ghc-test-framework-th)))
+    (home-page "https://github.com/luispedro/safeio")
+    (synopsis "Write output to disk atomically")
+    (description
+     "This package implements utilities to perform atomic output so as to
+avoid the problem of partial intermediate files.")
+    (license license:expat)))
+
+(define-public ghc-safesemaphore
+  (package
+    (name "ghc-safesemaphore")
+    (version "0.10.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "SafeSemaphore/SafeSemaphore-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/ChrisKuklewicz/SafeSemaphore")
+    (synopsis "Exception safe semaphores")
+    (description "This library provides exception safe semaphores that can be
+used in place of @code{QSem}, @code{QSemN}, and @code{SampleVar}, all of which
+are not exception safe and can be broken by @code{killThread}.")
+    (license license:bsd-3)))
+
+(define-public ghc-sandi
+  (package
+    (name "ghc-sandi")
+    (version "0.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/sandi/sandi-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0dvkpk91n9kz2ha04rvp231ra9sgd1ilyc1qkzf9l03iir7zrh9b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-stringsearch" ,ghc-stringsearch)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-th" ,ghc-tasty-th)))
+    (home-page "https://hackage.haskell.org/package/sandi")
+    (synopsis "Data encoding library")
+    (description "Reasonably fast data encoding library.")
+    (license license:bsd-3)))
+
+(define-public ghc-scientific
+  (package
+    (name "ghc-scientific")
+    (version "0.3.6.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/scientific/scientific-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "03ql2f0ac8bsl524idy9xxa3kxisb2sj3avflzw580j5hzy0m397"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-integer-logarithms" ,ghc-integer-logarithms)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-primitive" ,ghc-primitive)))
+    (native-inputs
+     `(("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{https://en.wikipedia.org/wiki/Scientific_notation, scientific
+notation}.")
+    (license license:bsd-3)))
+
+(define-public ghc-scientific-bootstrap
+  (package
+    (inherit ghc-scientific)
+    (name "ghc-scientific-bootstrap")
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-integer-logarithms" ,ghc-integer-logarithms-bootstrap)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-primitive" ,ghc-primitive)))
+    (native-inputs '())
+    (properties '(hidden? #t))))
+
+(define-public ghc-sdl
+  (package
+    (name "ghc-sdl")
+    (version "0.6.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/SDL/SDL-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "00y67v80a8l09i3k76z09lg25kw72ivl09nag8ckdlk4a0cfnzfq"))))
+    (build-system haskell-build-system)
+    (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 license:bsd-3)))
+
+(define-public ghc-sdl-image
+  (package
+    (name "ghc-sdl-image")
+    (version "0.6.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/SDL-image/SDL-image-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1gxwrvswgwjw6g7ym52gik22l9l3ljy592phv97jdmcf3gi6qcg1"))))
+    (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)))))
+    (inputs
+     `(("ghc-sdl" ,ghc-sdl)
+       ("sdl-image" ,sdl-image)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-sdl-mixer
+  (package
+    (name "ghc-sdl-mixer")
+    (version "0.6.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0k26hqgdh789ka3mv4dsk6rin6x6vwcs6hjmnsqq7j3mnrh1342r"))))
+    (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)))))
+    (inputs
+     `(("ghc-sdl" ,ghc-sdl)
+       ("sdl-mixer" ,sdl-mixer)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-securemem
+  (package
+    (name "ghc-securemem")
+    (version "0.1.10")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "securemem-" version "/"
+                           "securemem-" version ".tar.gz"))
+       (sha256
+        (base32
+         "19hnw2cfbsfjynxq1bq9f6djbxhsc1k751ml0y1ab3ah913mm29j"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-byteable" ,ghc-byteable)
+              ("ghc-memory" ,ghc-memory)))
+    (home-page "https://github.com/vincenthz/hs-securemem")
+    (synopsis "Auto-scrubbing and const-time-eq memory chunk abstraction for
+Haskell")
+    (description "SecureMem is similar to ByteString, except that it provides
+a memory chunk that will be auto-scrubbed after it run out of scope.")
+    (license license:bsd-3)))
+
+(define-public ghc-semigroupoids
+  (package
+    (name "ghc-semigroupoids")
+    (version "5.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/semigroupoids/semigroupoids-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "17i96y4iqj8clcs090lf6k0ij3j16nj14vsfwz0mm9nd6i4gbpp4"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("4" "0pqfrxzypjq6z8lgdkzq4vhcyqkpk5326hny0r6snpc3gm78r4ij")))
+    (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)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-semigroups
+  (package
+    (name "ghc-semigroups")
+    (version "0.18.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/semigroups/semigroups-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "17g29h62g1k51ghhvzkw72zksjgi6vs6bfipkj81pqw1dsprcamb"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-nats" ,ghc-nats)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-hashable" ,ghc-hashable)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-semigroups-bootstrap
+  (package
+    (inherit ghc-semigroups)
+    (name "ghc-semigroups-bootstrap")
+    (inputs
+     `(("ghc-nats" ,ghc-nats-bootstrap)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers-bootstrap)
+       ("ghc-hashable" ,ghc-hashable-bootstrap)))
+    (properties '(hidden? #t))))
+
+(define-public ghc-setenv
+  (package
+    (name "ghc-setenv")
+    (version "0.1.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/setenv/setenv-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/setenv")
+    (synopsis "Library for setting environment variables")
+    (description "This package provides a Haskell library for setting
+environment variables.")
+    (license license:expat)))
+
+(define-public ghc-setlocale
+  (package
+    (name "ghc-setlocale")
+    (version "1.0.0.8")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/setlocale-"
+                    version "/setlocale-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0sdrsmkhw08483d73ysgm2926fdbhii61br03lqpqw0lfzj4ilbd"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/setlocale")
+    (synopsis "Haskell bindings to setlocale")
+    (description "This package provides Haskell bindings to the
+@code{setlocale} C function.")
+    (license license:bsd-3)))
+
+(define-public ghc-shakespeare
+  (package
+    (name "ghc-shakespeare")
+    (version "2.0.15")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "shakespeare-" version "/"
+                           "shakespeare-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1vk4b19zvwy4mpwaq9z3l3kfmz75gfyf7alhh0y112gspgpccm23"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-aeson" ,ghc-aeson)
+              ("ghc-blaze-markup" ,ghc-blaze-markup)
+              ("ghc-blaze-html" ,ghc-blaze-html)
+              ("ghc-exceptions" ,ghc-exceptions)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-scientific" ,ghc-scientific)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("hspec-discover" ,hspec-discover)))
+    (home-page "https://www.yesodweb.com/book/shakespearean-templates")
+    (synopsis "Family of type-safe template languages for Haskell")
+    (description "This Haskell package provides a family of type-safe
+templates with simple variable interpolation.  Shakespeare templates can
+be used inline with a quasi-quoter or in an external file and it
+interpolates variables according to the type being inserted.")
+    (license license:expat)))
+
+(define-public ghc-shelly
+  (package
+    (name "ghc-shelly")
+    (version "1.8.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/shelly/shelly-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "023fbvbqs5gdwm30j5517gbdcc7fvz0md70dgwgpypkskj3i926y"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
+       ("ghc-system-fileio-bootstrap" ,ghc-system-fileio-bootstrap)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-lifted-async" ,ghc-lifted-async)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
+       ("ghc-async" ,ghc-async)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hspec-contrib" ,ghc-hspec-contrib)))
+    (home-page "https://github.com/yesodweb/Shelly.hs")
+    (synopsis "Shell-like (systems) programming in Haskell")
+    (description
+     "Shelly provides convenient systems programming in Haskell, similar in
+spirit to POSIX shells.  Shelly is originally forked  from the Shellish package.")
+    (license license:bsd-3)))
+
+(define-public ghc-silently
+  (package
+    (name "ghc-silently")
+    (version "1.2.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://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 license:bsd-3)))
+
+(define-public ghc-simple-reflect
+  (package
+    (name "ghc-simple-reflect")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/simple-reflect/simple-reflect-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ayvrx5cm8n6db21jiyjmk5h93pw7cz1707hih09hlhk9jh5x0h7"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://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 license:bsd-3)))
+
+(define-public ghc-simple-sendfile
+  (package
+    (name "ghc-simple-sendfile")
+    (version "0.2.27")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "simple-sendfile-" version "/"
+                           "simple-sendfile-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1bwwqzcm56m2w4ymsa054sxmpbj76h9pvb0jf8zxp8lr41cp51gn"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-network" ,ghc-network)
+       ("ghc-resourcet" ,ghc-resourcet)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/kazu-yamamoto/simple-sendfile")
+    (synopsis "Cross platform library for the sendfile system call")
+    (description "This library tries to call minimum system calls which
+are the bottleneck of web servers.")
+    (license license:bsd-3)))
+
+(define-public ghc-skylighting-core
+  (package
+    (name "ghc-skylighting-core")
+    (version "0.7.2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "skylighting-core/skylighting-core-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "066fwmwsd7xcvwlinfk2izlzq0xp8697i6lnbgsbl71jdybyackq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-colour" ,ghc-colour)
+       ("ghc-hxt" ,ghc-hxt)
+       ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (native-inputs
+     `(("ghc-diff" ,ghc-diff)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-pretty-show" ,ghc-pretty-show)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://github.com/jgm/skylighting")
+    (synopsis "Syntax highlighting library")
+    (description "Skylighting is a syntax highlighting library with support
+for over one hundred languages.  It derives its tokenizers from XML syntax
+definitions used by KDE's @code{KSyntaxHighlighting} framework, so any syntax
+supported by that framework can be added.  An optional command-line program is
+provided.  Skylighting is intended to be the successor to highlighting-kate.")
+    (license license:gpl2)))
+
+(define-public ghc-skylighting
+  (package
+    (inherit ghc-skylighting-core)
+    (name "ghc-skylighting")
+    (version "0.7.2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/skylighting-"
+                                  version "/skylighting-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1rh3z1a7a4clvksdw1qlpmhxqkfahwypi70k91whgfamzsqpxdch"))))
+    (inputs
+     `(("ghc-skylighting-core" ,ghc-skylighting-core)
+       ,@(package-inputs ghc-skylighting-core)))))
+
+(define-public ghc-smallcheck
+  (package
+    (name "ghc-smallcheck")
+    (version "1.1.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/smallcheck/smallcheck-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "195fj7w3v03d1y1nm2ylavzrwxjcdbq0lb6zsw1dwyx5jmwfc84h"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-logict" ,ghc-logict)))
+    (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 license:bsd-3)))
+
+(define-public ghc-socks
+  (package
+    (name "ghc-socks")
+    (version "0.5.6")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "socks/socks-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0f44qy74i0n6ll3jym0a2ipafkpw1h67amcpqmj8iq95h21wsqzs"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-cereal" ,ghc-cereal)
+       ("ghc-network" ,ghc-network)))
+    (home-page "https://github.com/vincenthz/hs-socks")
+    (synopsis "SOCKS proxy (version 5) implementation")
+    (description
+     "This library provides a SOCKS proxy (version 5) implementation.")
+    (license license:bsd-3)))
+
+(define-public ghc-split
+  (package
+    (name "ghc-split")
+    (version "0.2.3.3")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/split/split-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "04qlmkcyklznl03gsjg95b4nzb6i96gdapqg60rny9szgi7ngk8x"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/split")
+    (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 license:bsd-3)))
+
+(define-public ghc-statevar
+  (package
+    (name "ghc-statevar")
+    (version "1.1.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/StateVar/StateVar-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "08r2iw0gdmfs4f6wraaq19vfmkjdbics3dbhw39y7mdjd98kcr7b"))))
+    (build-system haskell-build-system)
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-statistics
+  (package
+    (name "ghc-statistics")
+    (version "0.14.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "statistics-" version "/"
+                           "statistics-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0y27gafkib0x0fn39qfn2rkgsfrm09ng35sbb5dwr7rclhnxz59l"))))
+    (build-system haskell-build-system)
+    (arguments
+     '(#:cabal-revision
+       ("2" "1bx70yqkn62ii17fjv3pig4hklrzkqd09zj67zzjiyjzmn04fir3")
+       ;; Two tests fail: "Discrete CDF is OK" and "Quantile is CDF inverse".
+       #:tests? #f))
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-erf" ,ghc-erf)
+       ("ghc-math-functions" ,ghc-math-functions)
+       ("ghc-monad-par" ,ghc-monad-par)
+       ("ghc-mwc-random" ,ghc-mwc-random)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-vector-algorithms" ,ghc-vector-algorithms)
+       ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)
+       ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-ieee754" ,ghc-ieee754)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/mwc-random")
+    (synopsis "Haskell library of statistical types, data, and functions")
+    (description "This library provides a number of common functions
+and types useful in statistics.  We focus on high performance, numerical
+robustness, and use of good algorithms.  Where possible, we provide references
+to the statistical literature.
+
+The library's facilities can be divided into four broad categories:
+
+@itemize
+@item Working with widely used discrete and continuous probability
+distributions.  (There are dozens of exotic distributions in use; we focus
+on the most common.)
+
+@item Computing with sample data: quantile estimation, kernel density
+estimation, histograms, bootstrap methods, significance testing,
+and regression and autocorrelation analysis.
+
+@item Random variate generation under several different distributions.
+
+@item Common statistical tests for significant differences between samples.
+@end itemize")
+    (license license:bsd-2)))
+
+(define-public ghc-stm-chans
+  (package
+    (name "ghc-stm-chans")
+    (version "3.0.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "stm-chans-" version "/"
+                           "stm-chans-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0f27sp09yha43xk9q55sc185jyjs5h7gq2dhsyx6bm9kz9dzqi13"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/stm-chans")
+    (synopsis "Additional types of channels for ghc-stm")
+    (description "This Haskell package offers a collection of channel types,
+similar to @code{Control.Concurrent.STM.@{TChan,TQueue@}} but with additional
+features.")
+    (license license:bsd-3)))
+
+(define-public ghc-stm-conduit
+  (package
+    (name "ghc-stm-conduit")
+    (version "4.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/stm-conduit/"
+                           "stm-conduit-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-stm-chans" ,ghc-stm-chans)
+       ("ghc-cereal" ,ghc-cereal)
+       ("ghc-cereal-conduit" ,ghc-cereal-conduit)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-async" ,ghc-async)
+       ("ghc-monad-loops" ,ghc-monad-loops)
+       ("ghc-unliftio" ,ghc-unliftio)))
+    (native-inputs
+     `(("ghc-doctest" ,ghc-doctest)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/cgaebel/stm-conduit")
+    (synopsis "Introduces conduits to channels and promotes using conduits concurrently")
+    (description
+     "This package provides two simple conduit wrappers around STM channels: a
+source and a sink.")
+    (license license:bsd-3)))
+
+(define-public ghc-stmonadtrans
+  (package
+    (name "ghc-stmonadtrans")
+    (version "0.4.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/STMonadTrans"
+                           "/STMonadTrans-" version ".tar.gz"))
+       (sha256
+        (base32 "1nr26fnmi5fdjc6d00w13kjhmfyvb5b837d0006w4dj0yxndaksp"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/STMonadTrans")
+    (synopsis "Monad transformer version of the ST monad")
+    (description
+     "This package provides a monad transformer version of the @code{ST} monad
+for strict state threads.")
+    (license license:bsd-3)))
+
+(define-public ghc-storable-complex
+  (package
+    (name "ghc-storable-complex")
+    (version "0.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/storable-complex/storable-complex-"
+             version ".tar.gz"))
+       (sha256
+        (base32 "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/cartazio/storable-complex")
+    (synopsis "Haskell Storable instance for Complex")
+    (description "This package provides a Haskell library including a
+Storable instance for Complex which is binary compatible with C99, C++
+and Fortran complex data types.")
+    (license license:bsd-3)))
+
+(define-public ghc-streaming-commons
+  (package
+    (name "ghc-streaming-commons")
+    (version "0.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "streaming-commons/streaming-commons-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1lmyx3wkjsayhy5yilzvy0kf8qwmycwlk26r1d8f3cxbfhkr7s52"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-random" ,ghc-random)
+       ("ghc-zlib" ,ghc-zlib)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://hackage.haskell.org/package/streaming-commons")
+    (synopsis "Conduit and pipes needed by some streaming data libraries")
+    (description "This package provides low-dependency functionality commonly
+needed by various Haskell streaming data libraries, such as @code{conduit} and
+@code{pipe}s.")
+    (license license:expat)))
+
+(define-public ghc-strict
+  (package
+    (name "ghc-strict")
+    (version "0.3.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/strict/strict-"
+                           version ".tar.gz"))
+       (sha256
+        (base32 "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/strict")
+    (synopsis "Strict data types and String IO")
+    (description
+     "This package provides strict versions of some standard Haskell data
+types, such as pairs, @code{Maybe} and @code{Either}.  It also contains strict
+IO operations.")
+    (license license:bsd-3)))
+
+(define-public ghc-stringbuilder
+  (package
+    (name "ghc-stringbuilder")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/stringbuilder/stringbuilder-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1fh3csx1wcssn8xyvl4ip4aprh9l4qyz2kk8mgjvqvc0vb2bsy6q"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
+                               ; enabled
+    (home-page "https://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 license:expat)))
+
+(define-public ghc-string-qq
+  (package
+    (name "ghc-string-qq")
+    (version "0.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/string-qq/string-qq-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0662m3i5xrdrr95w829bszkhp88mj9iy1zya54vk2sl5hz9wlmwp"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/string-qq")
+    (synopsis
+     "QuasiQuoter for non-interpolated strings, texts and bytestrings.")
+    (description
+     "This package provides a quasiquoter for non-interpolated strings, texts
+and bytestrings.")
+    (license license:public-domain)))
+
+(define-public ghc-stringsearch
+  (package
+    (name "ghc-stringsearch")
+    (version "0.3.6.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://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 license:bsd-3)))
+
+(define-public ghc-stylish-haskell
+  (package
+    (name "ghc-stylish-haskell")
+    (version "0.9.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (string-append
+               "mirror://hackage/package/stylish-haskell/stylish-haskell-"
+               version
+               ".tar.gz"))
+        (sha256
+          (base32
+            "1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w"))))
+    (build-system haskell-build-system)
+    (inputs
+      `(("ghc-aeson" ,ghc-aeson)
+        ("ghc-file-embed" ,ghc-file-embed)
+        ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+        ("ghc-semigroups" ,ghc-semigroups)
+        ("ghc-syb" ,ghc-syb)
+        ("ghc-yaml" ,ghc-yaml)
+        ("ghc-strict" ,ghc-strict)
+        ("ghc-optparse-applicative"
+         ,ghc-optparse-applicative)))
+    (native-inputs
+      `(("ghc-hunit" ,ghc-hunit)
+        ("ghc-test-framework" ,ghc-test-framework)
+        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://github.com/jaspervdj/stylish-haskell")
+    (synopsis "Haskell code prettifier")
+    (description "Stylish-haskell is a Haskell code prettifier.  The goal is
+not to format all of the code in a file, to avoid \"getting in the way\".
+However, this tool can e.g. clean up import statements and help doing various
+tasks that get tedious very quickly.  It can
+@itemize
+@item
+Align and sort @code{import} statements
+@item
+Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant
+pragmas
+@item
+Remove trailing whitespaces
+@item
+Align branches in @code{case} and fields in records
+@item
+Convert line endings (customisable)
+@item
+Replace tabs by four spaces (turned off by default)
+@item
+Replace some ASCII sequences by their Unicode equivalent (turned off by
+default)
+@end itemize")
+    (license license:bsd-3)))
+
+(define-public ghc-syb
+  (package
+    (name "ghc-syb")
+    (version "0.7")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/syb/syb-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1da2zz7gqm4xbkx5vpd74dayx1svaxyl145fl14mq15lbb77sxdq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page
+     "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
+    (synopsis "Scrap Your Boilerplate")
+    (description "This package contains the generics system described in the
+/Scrap Your Boilerplate/ papers (see
+@uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}).  It
+defines the @code{Data} class of types permitting folding and unfolding of
+constructor applications, instances of this class for primitive types, and a
+variety of traversals.")
+    (license license:bsd-3)))
+
+(define-public ghc-system-fileio
+  (package
+    (name "ghc-system-fileio")
+    (version "0.3.16.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/system-fileio/system-fileio-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-system-filepath" ,ghc-system-filepath)
+       ("ghc-chell" ,ghc-chell)
+       ("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://github.com/fpco/haskell-filesystem")
+    (synopsis "Consistent file system interaction across GHC versions")
+    (description
+     "This is a small wrapper around the directory, unix, and Win32 packages,
+for use with system-filepath.  It provides a consistent API to the various
+versions of these packages distributed with different versions of GHC.
+In particular, this library supports working with POSIX files that have paths
+which can't be decoded in the current locale encoding.")
+    (license license:expat)))
+
+;; See ghc-system-filepath-bootstrap. In addition this package depends on
+;; ghc-system-filepath.
+(define ghc-system-fileio-bootstrap
+  (package
+    (name "ghc-system-fileio-bootstrap")
+    (version "0.3.16.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/system-fileio/system-fileio-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f))
+    (inputs
+     `(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
+       ("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://github.com/fpco/haskell-filesystem")
+    (synopsis "Consistent file system interaction across GHC versions")
+    (description
+     "This is a small wrapper around the directory, unix, and Win32 packages,
+for use with system-filepath.  It provides a consistent API to the various
+versions of these packages distributed with different versions of GHC.
+In particular, this library supports working with POSIX files that have paths
+which can't be decoded in the current locale encoding.")
+    (license license:expat)))
+
+
+(define-public ghc-system-filepath
+  (package
+    (name "ghc-system-filepath")
+    (version "0.4.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/system-filepath/system-filepath-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn"))))
+    (build-system haskell-build-system)
+    ;; FIXME: One of the tests fails:
+    ;; [ FAIL  ] tests.validity.posix
+    ;; note: seed=7310214548328823169
+    ;; *** Failed! Falsifiable (after 24 tests):
+    ;; FilePath "/r2\ENQ52\t ;$/o\US=/okG\146\&6\n<u\DC3/5\182\223a\DELN\EOT#\NUL/`[m/\USEKV\ETX([)b6/\ACK\SOo\245\ETBO/f\128\STX`|\EM\"/*\EMA\USD3/\143\&4/\CAN?\SUBee\CANR/9/B0\187Kx4/Vqr\232'b:/\a\234\DLE.\"\179/\ENQ{J/|/G)@^\237/\219ml/\DC3pd\ESC"
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-chell" ,ghc-chell)
+       ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/fpco/haskell-filesystem")
+    (synopsis "High-level, byte-based file and directory path manipulations")
+    (description
+     "Provides a FilePath datatype and utility functions for operating on it.
+Unlike the filepath package, this package does not simply reuse String,
+increasing type safety.")
+    (license license:expat)))
+
+;; Ghc-shelly depends on ghc-system-filepath and ghc-system-fileio, who in turn depend on
+;; ghc-chell and ghc-chell-quickcheck for the test phase. Ghc-chell depends on ghc-options
+;; which depends on ghc-chell and ghc-chell-quickcheck.
+;; Therefore we bootstrap it with tests disabled.
+(define ghc-system-filepath-bootstrap
+  (package
+    (name "ghc-system-filepath-bootstrap")
+    (version "0.4.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/system-filepath/system-filepath-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f))
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/fpco/haskell-filesystem")
+    (synopsis "High-level, byte-based file and directory path manipulations")
+    (description
+     "Provides a FilePath datatype and utility functions for operating on it.
+Unlike the filepath package, this package does not simply reuse String,
+increasing type safety.")
+    (license license:expat)))
+
+
+(define-public ghc-tagged
+  (package
+    (name "ghc-tagged")
+    (version "0.8.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tagged/tagged-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "16cdzh0bw16nvjnyyy5j9s60malhz4nnazw96vxb0xzdap4m2z74"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "0r2knfcq0b4s652vlvlnfwxlc2mkc2ra9kl8bp4zdn1awmfy0ia5")))
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (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 license:bsd-3)))
+
+(define-public ghc-tar
+  (package
+    (name "ghc-tar")
+    (version "0.5.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tar/tar-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0s2brvaxg5fki2jdkccmnpssiy6a3wjh24p6a3dkkdvjcixnk7f8"))))
+    (build-system haskell-build-system)
+    ;; FIXME: 2/24 tests fail.
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-bytestring-handle" ,ghc-bytestring-handle)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/tar")
+    (synopsis "Reading, writing and manipulating \".tar\" archive files")
+    (description
+     "This library is for working with \\\"@.tar@\\\" archive files.
+It can read and write a range of common variations of the tar archive format
+including V7, POSIX USTAR and GNU formats.  It provides support for packing and
+unpacking portable archives.  This makes it suitable for distribution but not
+backup because details like file ownership and exact permissions are not
+preserved.  It also provides features for random access to archive content using
+an index.")
+    (license license:bsd-3)))
+
+(define-public ghc-temporary
+  (package
+    (name "ghc-temporary")
+    (version "1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/temporary/temporary-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "144qhwfwg37l3k313raf4ssiz16jbgwlm1nf4flgqpsbd69jji4c"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-random" ,ghc-random)))
+    (native-inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://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 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
+             "https://hackage.haskell.org/package/temporary-rc/temporary-rc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-exceptions" ,ghc-exceptions)))
+    (home-page
+     "https://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 license:bsd-3)))
+
+(define-public ghc-terminal-size
+  (package
+    (name "ghc-terminal-size")
+    (version "0.3.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/terminal-size/"
+                    "terminal-size-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/terminal-size")
+    (synopsis "Get terminal window height and width")
+    (description "Get terminal window height and width without ncurses
+dependency.")
+    (license license:bsd-3)))
+
+(define-public ghc-texmath
+  (package
+    (name "ghc-texmath")
+    (version "0.11.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "texmath/texmath-" version ".tar.gz"))
+              (sha256
+               (base32
+                "11dc09hfnyfsz20ch2c867w0zdgjkzq41506lm61i3dk87ngdisf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-syb" ,ghc-syb)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-split" ,ghc-split)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-xml" ,ghc-xml)
+       ("ghc-pandoc-types" ,ghc-pandoc-types)))
+    (home-page "https://github.com/jgm/texmath")
+    (synopsis "Conversion between formats used to represent mathematics")
+    (description
+     "The texmath library provides functions to read and write TeX math,
+presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
+Office).  Support is also included for converting math formats to pandoc's
+native format (allowing conversion, via pandoc, to a variety of different
+markup formats).  The TeX reader supports basic LaTeX and AMS extensions, and
+it can parse and apply LaTeX macros.")
+    (license license:gpl2+)))
+
+(define-public ghc-text-binary
+  (package
+    (name "ghc-text-binary")
+    (version "0.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "text-binary/text-binary-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "18gl10pwg3qwsk0za3c70j4n6a9129wwf1b7d3a461h816yv55xn"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/kawu/text-binary")
+    (synopsis "Binary instances for text types")
+    (description
+     "This package provides a compatibility layer providing @code{Binary}
+instances for strict and lazy text types for versions older than 1.2.1 of the
+text package.")
+    (license license:bsd-2)))
+
+(define-public ghc-tf-random
+  (package
+    (name "ghc-tf-random")
+    (version "0.5")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tf-random/tf-random-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-primitive" ,ghc-primitive)
+       ("ghc-random" ,ghc-random)))
+    (home-page "https://hackage.haskell.org/package/tf-random")
+    (synopsis "High-quality splittable pseudorandom number generator")
+    (description "This package contains an implementation of a high-quality
+splittable pseudorandom number generator.  The generator is based on a
+cryptographic hash function built on top of the ThreeFish block cipher.  See
+the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
+Hashing\" by Claessen, Pałka for details and the rationale of the design.")
+    (license license:bsd-3)))
+
+(define-public ghc-th-abstraction
+  (package
+    (name "ghc-th-abstraction")
+    (version "0.2.8.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "th-abstraction/th-abstraction-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0n17w4q2ykd0nica4sck2wng6md56rfad8x0icl0l8vnzb9nn4ya"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/glguy/th-abstraction")
+    (synopsis "Nicer interface for reified information about data types")
+    (description
+     "This package normalizes variations in the interface for inspecting
+datatype information via Template Haskell so that packages and support a
+single, easier to use informational datatype while supporting many versions of
+Template Haskell.")
+    (license license:isc)))
+
+(define-public ghc-th-expand-syns
+  (package
+    (name "ghc-th-expand-syns")
+    (version "0.4.4.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "th-expand-syns/th-expand-syns-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "01prlvh3py5hq5ccjidfyp9ixq2zd88dkbsidyjrpkja6v8m43yc"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-syb" ,ghc-syb)))
+    (home-page "https://hackage.haskell.org/package/th-expand-syns")
+    (synopsis "Expands type synonyms in Template Haskell ASTs")
+    (description
+     "This package enables users to expand type synonyms in Template Haskell
+@dfn{abstract syntax trees} (ASTs).")
+    (license license:bsd-3)))
+
+(define-public ghc-th-lift
+  (package
+    (name "ghc-th-lift")
+    (version "0.7.11")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "th-lift/th-lift-" version ".tar.gz"))
+              (sha256
+               (base32
+                "131360zxb0hazbqwbkk6ab2p77jkxr79bwwm618mrwrwkm3x2g6m"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-th-abstraction" ,ghc-th-abstraction)))
+    (home-page "https://github.com/mboes/th-lift")
+    (synopsis "Derive Template Haskell's Lift class for datatypes")
+    (description
+     "This is a Haskell library to derive Template Haskell's Lift class for
+datatypes.")
+    (license license:bsd-3)))
+
+(define-public ghc-th-lift-instances
+  (package
+    (name "ghc-th-lift-instances")
+    (version "0.1.11")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "th-lift-instances/th-lift-instances-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1f56cp6ckcalld5jchv0kxpjkwcsixd7smd0g7r8cg67ppx6m90x"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-th-lift" ,ghc-th-lift)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/bennofs/th-lift-instances/")
+    (synopsis "Lift instances for template-haskell for common data types.")
+    (description "Most data types in the Haskell platform do not have Lift
+instances.  This package provides orphan instances for @code{containers},
+@code{text}, @code{bytestring} and @code{vector}.")
+    (license license:bsd-3)))
+
+(define-public ghc-th-orphans
+  (package
+    (name "ghc-th-orphans")
+    (version "0.13.6")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "th-orphans/th-orphans-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0sfl3pn9kq9da3ji3lsgzgzy82vz6yvsg80dmakc1jvk7awycibp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-th-lift" ,ghc-th-lift)
+       ("ghc-th-lift-instances" ,ghc-th-lift-instances)
+       ("ghc-th-reify-many" ,ghc-th-reify-many)
+       ("ghc-generic-deriving" ,ghc-generic-deriving)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/th-orphans")
+    (synopsis "Orphan instances for TH datatypes")
+    (description
+     "This package provides orphan instances for Template Haskell datatypes.  In particular,
+instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
+and @code{Eq} instances.  These instances used to live in the haskell-src-meta
+package, and that's where the version number started.")
+    (license license:bsd-3)))
+
 (define-public ghc-threads
   (package
     (name "ghc-threads")
@@ -248,6 +9946,1403 @@ package is similar to the @code{threadmanager}, @code{async} and
 @end itemize")
     (license license:bsd-3)))
 
+(define-public ghc-th-reify-many
+  (package
+    (name "ghc-th-reify-many")
+    (version "0.1.8")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "th-reify-many/th-reify-many-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "0hzy6hvhvcd6i60vx5cp2b7ggmnnjh9rx4h8bm8xw4grglcaxjnf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-safe" ,ghc-safe)
+       ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
+    (home-page "https://github.com/mgsloan/th-reify-many")
+    (synopsis "Recurseively reify template haskell datatype info")
+    (description
+     "th-reify-many provides functions for recursively reifying top level
+declarations.  The main intended use case is for enumerating the names of
+datatypes reachable from an initial datatype, and passing these names to some
+function which generates instances.")
+    (license license:bsd-3)))
+
+(define-public ghc-time-locale-compat
+  (package
+    (name "ghc-time-locale-compat")
+    (version "0.1.1.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "time-locale-compat/time-locale-compat-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0b2hmj8wwrfkndwzgm11qr496ca2ahwdxcj3m0ii91bxvrk1bzq7"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "https://github.com/khibino/haskell-time-locale-compat")
+    (synopsis "Compatibility of TimeLocale between old-locale and time-1.5")
+    (description "This package contains a wrapped name module for
+@code{TimeLocale}.")
+    (license license:bsd-3)))
+
+(define-public ghc-tldr
+  (package
+    (name "ghc-tldr")
+    (version "0.4.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tldr/tldr-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0nc581y9jjzwd8l88g48c72mla7k6q1w102akl7gl5jsk9ljamd3"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-cmark" ,ghc-cmark)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-typed-process" ,ghc-typed-process)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)))
+    (home-page "https://github.com/psibi/tldr-hs#readme")
+    (synopsis "Haskell tldr client")
+    (description "This package provides the @command{tldr} command and a
+Haskell client library allowing users to update and view @code{tldr} pages
+from a shell.  The @code{tldr} pages are a community effort to simplify the
+man pages with practical examples.")
+    (license license:bsd-3)))
+
+(define-public ghc-transformers-base
+  (package
+    (name "ghc-transformers-base")
+    (version "0.4.5.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/transformers-base/transformers-base-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page
+     "https://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 license:bsd-3)))
+
+(define-public ghc-transformers-compat
+  (package
+    (name "ghc-transformers-compat")
+    (version "0.6.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/transformers-compat"
+             "/transformers-compat-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1gp4a8kvniwgm8947ghb4iwv4b7wd6ry4kvv4nfnym4agf5j41nw"))))
+    (build-system haskell-build-system)
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-tree-diff
+  (package
+    (name "ghc-tree-diff")
+    (version "0.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tree-diff/tree-diff-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "049v44c520jy3icxlnrvbdblh3mjmvd7m6qmkzxbzkf02x63xqmz"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("4" "1rqxxyj6hqllahs11693g855cxz8mgnb490s7j1ksd300i5xgjsp")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "tree-diff.cabal"
+               (("trifecta             >=1\\.7\\.1\\.1  && <1\\.8")
+                "trifecta             >=1.7.1.1  && <=2")))))))
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-generics-sop" ,ghc-generics-sop)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-memotrie" ,ghc-memotrie)
+       ("ghc-parsers" ,ghc-parsers)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-uuid-types" ,ghc-uuid-types)
+       ("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+       ("ghc-trifecta" ,ghc-trifecta)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://github.com/phadej/tree-diff")
+    (synopsis "Compute difference between (expression) trees")
+    (description "This Haskell library provides a function for computing
+the difference between (expression) trees.  It also provides a way to
+compute the difference between arbitrary abstract datatypes (ADTs) using
+@code{Generics}-derivable helpers.")
+    (license license:bsd-3)))
+
+(define-public ghc-trifecta
+  (package
+    (name "ghc-trifecta")
+    (version "2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/trifecta/"
+                    "trifecta-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0hznd8i65s81xy13i2qc7cvipw3lfb2yhkv53apbdsh6sbljz5sk"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; doctest suite fails to build on i686
+    (inputs
+     `(("ghc-reducers" ,ghc-reducers)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("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-charset" ,ghc-charset)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-fingertree" ,ghc-fingertree)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-parsers" ,ghc-parsers)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-utf8-string" ,ghc-utf8-string)))
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-tuple-th
+  (package
+    (name "ghc-tuple-th")
+    (version "0.2.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "tuple-th-" version "/"
+                           "tuple-th-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1mrl4vvxmby7sf1paf7hklzidnr6wq55822i73smqyz0xpf3gsjn"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/DanielSchuessler/tuple-th")
+    (synopsis "Generate utility functions for tuples of statically known size
+for Haskell")
+    (description "This Haskell package contains Template Haskell functions for
+generating functions similar to those in @code{Data.List} for tuples of
+statically known size.")
+    (license license:bsd-3)))
+
+(define-public ghc-typed-process
+  (package
+    (name "ghc-typed-process")
+    (version "0.2.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "typed-process/typed-process-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0j36vrc9w841m5qbwqra1lwiznx31xfnhin1sm8x2c2739csbpn0"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)))
+    (native-inputs
+     `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://haskell-lang.org/library/typed-process")
+    (synopsis "Run external processes with strong typing of streams")
+    (description
+     "This library provides the ability to launch and interact with external
+processes.  It wraps around the @code{process} library, and intends to improve
+upon it.")
+    (license license:expat)))
+
+(define-public ghc-unbounded-delays
+  (package
+    (name "ghc-unbounded-delays")
+    (version "0.1.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ir9fghbrc214c97bwafk5ck6cacxz1pdnq4i18p604d1b8zg9wa"))))
+    (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 license:bsd-3)))
+
+(define-public ghc-unexceptionalio
+  (package
+    (name "ghc-unexceptionalio")
+    (version "0.4.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "unexceptionalio-" version "/" "unexceptionalio-"
+                           version ".tar.gz"))
+       (sha256 (base32 "09gynk472l7nn5l2w320n4dwigwp0wh0shfp6dyw6r5h2jdxz18p"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/singpolyma/unexceptionalio")
+    (synopsis "IO without any non-error, synchronous exceptions")
+    (description "When you've caught all the exceptions that can be
+handled safely, this is what you're left with.")
+    (license license:isc)))
+
+(define-public ghc-union-find
+  (package
+    (name "ghc-union-find")
+    (version "0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/union-find/union-find-"
+                    version ".tar.gz"))
+              (sha256
+               (base32
+                "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/nominolo/union-find")
+    (synopsis "Efficient union and equivalence testing of sets")
+    (description
+     "The Union/Find algorithm implements these operations in (effectively)
+constant-time:
+@enumerate
+@item Check whether two elements are in the same equivalence class.
+@item Create a union of two equivalence classes.
+@item Look up the descriptor of the equivalence class.
+@end enumerate\n")
+    (license license:bsd-3)))
+
+(define-public ghc-uniplate
+  (package
+    (name "ghc-uniplate")
+    (version "1.6.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/uniplate/uniplate-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
+    (build-system haskell-build-system)
+    (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 license:bsd-3)))
+
+(define-public ghc-unix-compat
+  (package
+    (name "ghc-unix-compat")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/unix-compat/unix-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0llwl7rp63fy2ychwdclz1afj45pbin5pfl01dvn6rwhvmwhr7d3"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://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 license:bsd-3)))
+
+(define-public ghc-unix-time
+  (package
+    (name "ghc-unix-time")
+    (version "0.3.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/unix-time/unix-time-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "051slgpid5cxiaw203ky0ql3823h28fcjs08axkzd4265wrvv8fw"))))
+    (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.
+    (inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-unliftio
+  (package
+    (name "ghc-unliftio")
+    (version "0.2.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/unliftio/unliftio-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0qql93lq5w7qghl454cc3s1i8v1jb4h08n82fqkw0kli4g3g9njs"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://github.com/fpco/unliftio")
+    (synopsis "Provides MonadUnliftIO typecplass for unlifting monads to
+IO (batteries included)")
+    (description "This Haskell package provides the core @code{MonadUnliftIO}
+typeclass, a number of common instances, and a collection of common functions
+working with it.")
+    (license license:expat)))
+
+(define-public ghc-unliftio-core
+  (package
+    (name "ghc-unliftio-core")
+    (version "0.1.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "unliftio-core-" version "/"
+                           "unliftio-core-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1193fplsjm1lcr05xwvkj1rsyzx74i755f6kw3ikmxbsv0bv0l3m"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "16bjwcsaghqqmyi69rq65dn3ydifyfaabq3ns37apdm00mwqbcj2")))
+    (home-page
+     "https://github.com/fpco/unliftio/tree/master/unliftio-core#readme")
+    (synopsis "The MonadUnliftIO typeclass for unlifting monads to IO")
+    (description "This Haskell package provides the core @code{MonadUnliftIO}
+typeclass, instances for base and transformers, and basic utility
+functions.")
+    (license license:expat)))
+
+(define-public ghc-unordered-containers
+  (package
+    (name "ghc-unordered-containers")
+    (version "0.2.9.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/unordered-containers"
+             "/unordered-containers-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0l4264p0av12cc6i8gls13q8y27x12z2ar4x34n3x59y99fcnc37"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ("ghc-hashable" ,ghc-hashable)))
+    (home-page
+     "https://github.com/tibbe/unordered-containers")
+    (synopsis
+     "Efficient hashing-based container types")
+    (description
+     "Efficient hashing-based container types.  The containers have been
+optimized for performance critical use, both in terms of large data quantities
+and high speed.")
+    (license license:bsd-3)))
+
+(define-public ghc-unordered-containers-bootstrap
+  (package
+    (inherit ghc-unordered-containers)
+    (name "ghc-unordered-containers-bootstrap")
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable-bootstrap)))
+    (properties '(hidden? #t))))
+
+(define-public ghc-uri-bytestring
+  (package
+    (name "ghc-uri-bytestring")
+    (version "0.3.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "uri-bytestring-" version "/"
+                           "uri-bytestring-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1q04j5ybvk37zk2m0bkjwyhblz0ymdj0cn4rvsvdca1ikn5xdv5c"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+              ("ghc-fail" ,ghc-fail)
+              ("ghc-blaze-builder" ,ghc-blaze-builder)
+              ("ghc-th-lift-instances" ,ghc-th-lift-instances)))
+    (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+                     ("ghc-base-compat" ,ghc-base-compat)
+                     ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+                     ("ghc-semigroups" ,ghc-semigroups)
+                     ("ghc-generics-sop" ,ghc-generics-sop)))
+    (home-page "https://github.com/Soostone/uri-bytestring")
+    (synopsis "Haskell URI parsing as ByteStrings")
+    (description "This Haskell package aims to be an RFC3986 compliant URI
+parser that uses ByteStrings for parsing and representing the URI data.")
+    (license license:bsd-3)))
+
+(define-public ghc-utf8-string
+  (package
+    (name "ghc-utf8-string")
+    (version "1.0.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/utf8-string/utf8-string-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("3" "02vhj5gykkqa2dyn7s6gn8is1b5fdn9xcqqvlls268g7cpv6rk38")))
+    (home-page "https://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
+for encoding UTF8 strings to Word8 lists and back, and for reading and writing
+UTF8 without truncation.")
+    (license license:bsd-3)))
+
+(define-public ghc-utility-ht
+  (package
+    (name "ghc-utility-ht")
+    (version "0.0.14")
+    (home-page "https://hackage.haskell.org/package/utility-ht")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append home-page "/utility-ht-" version ".tar.gz"))
+       (sha256
+        (base32 "1a7bgk7wv7sqbxbiv7kankiimr3wij7zdm7s83zwsf886ghyxhk9"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (synopsis "Haskell helper functions for Lists, Maybes, Tuples, Functions")
+    (description "This package includes Hakell modules providing various
+helper functions for Lists, Maybes, Tuples, Functions.")
+    (license license:bsd-3)))
+
+(define-public ghc-uuid
+  (package
+    (name "ghc-uuid")
+    (version "1.3.13")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "uuid-" version "/"
+                           "uuid-" version ".tar.gz"))
+       (sha256
+        (base32
+         "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("2" "0m185q62jkfb5jsv358nxbnrkv8y8hd0qqvgvh22wvc5g9ipz0r9")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'strip-test-framework-constraints
+           (lambda _
+             (substitute* "uuid.cabal"
+               (("HUnit            >= 1\\.2   && < 1\\.4") "HUnit")
+               (("QuickCheck       >= 2\\.4   && < 2\\.10") "QuickCheck")
+               (("tasty            >= 0\\.10  && < 0\\.12") "tasty")
+               (("tasty-hunit      == 0\\.9\\.\\*") "tasty-hunit")
+               (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+    (inputs `(("ghc-cryptohash-sha1" ,ghc-cryptohash-sha1)
+              ("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
+              ("ghc-entropy" ,ghc-entropy)
+              ("ghc-network-info" ,ghc-network-info)
+              ("ghc-random" ,ghc-random)
+              ("ghc-uuid-types" ,ghc-uuid-types)))
+    (native-inputs `(("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 "https://github.com/hvr/uuid")
+    (synopsis "Haskell library to create, compare, parse, and print UUIDs")
+    (description "This Haskell library provides utilities creating, comparing,
+parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.")
+    (license license:bsd-3)))
+
+(define-public ghc-uuid-types
+  (package
+    (name "ghc-uuid-types")
+    (version "1.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "uuid-types-" version "/"
+                           "uuid-types-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'strip-test-framework-constraints
+           (lambda _
+             (substitute* "uuid-types.cabal"
+               (("HUnit >=1\\.2 && < 1\\.4") "HUnit")
+               (("QuickCheck >=2\\.4 && < 2\\.9") "QuickCheck")
+               (("tasty >= 0\\.10 && < 0\\.12") "tasty")
+               (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit")
+               (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+    (inputs `(("ghc-hashable" ,ghc-hashable)
+              ("ghc-random" ,ghc-random)))
+    (native-inputs `(("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 "https://github.com/hvr/uuid")
+    (synopsis "Haskell type definitions for UUIDs")
+    (description "This Haskell library contains type definitions for
+@dfn{Universally Unique Identifiers} or
+@uref{https://en.wikipedia.org/wiki/UUID, UUIDs}, and basic conversion
+functions.")
+    (license license:bsd-3)))
+
+(define-public ghc-validation
+  (package
+    (name "ghc-validation")
+    (version "1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/validation/validation-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "08drmdvyzg2frbb26icy1mlz52xv0l6gi3v8gb7xp0vrcci5libh"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "1x1g4nannz81j1h64l1m3ancc96zc57d1bjhj1wk7bwn1xxbi5h3")))
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-lens" ,ghc-lens)))
+    (native-inputs
+     `(("ghc-hedgehog" ,ghc-hedgehog)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/qfpl/validation")
+    (synopsis
+     "Data-type like Either but with an accumulating Applicative")
+    (description
+     "A data-type like Either but with differing properties and type-class
+instances.
+
+Library support is provided for this different representation, including
+@code{lens}-related functions for converting between each and abstracting over
+their similarities.
+
+The @code{Validation} data type is isomorphic to @code{Either}, but has an
+instance of @code{Applicative} that accumulates on the error side.  That is to
+say, if two (or more) errors are encountered, they are appended using a
+@{Semigroup} operation.
+
+As a consequence of this @code{Applicative} instance, there is no
+corresponding @code{Bind} or @code{Monad} instance.  @code{Validation} is an
+example of, \"An applicative functor that is not a monad.\"")
+    (license license:bsd-3)))
+
+(define-public ghc-validity
+  (package
+    (name "ghc-validity")
+    (version "0.7.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/validity/validity-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0xribw98amafihw87ddajk6vlirp7w9b26lrnjgq7jfm4710j95f"))))
+    (build-system haskell-build-system)
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("hspec-discover" ,hspec-discover)))
+    (home-page
+     "https://github.com/NorfairKing/validity")
+    (synopsis "Validity typeclass")
+    (description
+     "Values of custom types usually have invariants imposed upon them.  This
+package provides the @code{Validity} type class, which makes these invariants
+explicit by providing a function to check whether the invariants hold.")
+    (license license:expat)))
+
+(define-public ghc-vault
+  (package
+    (name "ghc-vault")
+    (version "0.3.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/vault/vault-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "072mbrihsdsb8c6xvg6lvk0rqjgvxvi8qkg4n6wwym5hq0pfa04y"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)))
+    (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 license:bsd-3)))
+
+(define-public ghc-vector
+  (package
+    (name "ghc-vector")
+    (version "0.12.0.1")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/vector/vector-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0yrx2ypiaxahvaz84af5bi855hd3107kxkbqc8km29nsp5wyw05i"))))
+    (build-system haskell-build-system)
+    ;; FIXME: To simplify upgrading all Haskell packages, we leave the tests
+    ;; disabled for now.
+    (arguments
+     `(#:cabal-revision
+       ("3" "0y5rh8k710i2a3p1h2rghvr5cfg78p5h0kbfi7ifxqqf6pzlyr1x")
+       #:tests? #f))
+    (inputs
+     `(("ghc-primitive" ,ghc-primitive)
+       ("ghc-random" ,ghc-random)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ;; ("ghc-hunit" ,ghc-hunit)
+       ;; ("ghc-test-framework" ,ghc-test-framework)
+       ;; ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ;; ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ))
+    (home-page "https://github.com/haskell/vector")
+    (synopsis "Efficient Arrays")
+    (description "This library provides an efficient implementation of
+Int-indexed arrays (both mutable and immutable), with a powerful loop
+optimisation framework.")
+    (license license:bsd-3)))
+
+(define-public ghc-vector-algorithms
+  (package
+    (name "ghc-vector-algorithms")
+    (version "0.7.0.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "vector-algorithms-" version "/"
+                           "vector-algorithms-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0mfa8ig9v69l41p2vb5jl4qmaln5y1rlzarr2mlgm8g1nvq8qqdg"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/bos/math-functions")
+    (synopsis "Algorithms for vector arrays in Haskell")
+    (description "This Haskell library algorithms for vector arrays.")
+    (license license:bsd-3)))
+
+(define-public ghc-vector-binary-instances
+  (package
+    (name "ghc-vector-binary-instances")
+    (version "0.2.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "vector-binary-instances/vector-binary-instances-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1y236jb72iab9ska1mc48z6yb0xgwmj45laaqdyjxksd84z7hbrb"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:cabal-revision
+       ("1" "196frl4akhfk7xf1nxzn8lmq99dxhzhsimanswn9yy7ym8zhki4i")))
+    (inputs
+     `(("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (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 license:bsd-3)))
+
+(define-public ghc-vector-builder
+  (package
+    (name "ghc-vector-builder")
+    (version "0.3.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "vector-builder-" version "/"
+                           "vector-builder-" version ".tar.gz"))
+       (sha256
+        (base32
+         "06d2pa1fb3ydrl7l6rjazqyxv5i73v65x2f5fp0ypjxfbm6jsmn8"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-vector" ,ghc-vector)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-base-prelude" ,ghc-base-prelude)))
+    (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+                     ("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+                     ("ghc-rerebase" ,ghc-rerebase)))
+    (home-page "https://github.com/nikita-volkov/vector-builder")
+    (synopsis "Vector builder for Haskell")
+    (description "This Haskell package provides an API for constructing vectors.
+It provides the composable @code{Builder} abstraction, which has instances of the
+@code{Monoid} and @code{Semigroup} classes.
+
+You would first use the @code{Builder} abstraction to specify the structure of
+the vector; then you can execute the builder to actually produce the
+vector. ")
+    (license license:expat)))
+
+(define-public ghc-vector-th-unbox
+  (package
+    (name "ghc-vector-th-unbox")
+    (version "0.2.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "vector-th-unbox-" version "/"
+                           "vector-th-unbox-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0d82x55f5vvr1jvaia382m23rs690lg55pvavv8f4ph0y6kd91xy"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-data-default" ,ghc-data-default)))
+    (home-page "https://github.com/liyang/vector-th-unbox")
+    (synopsis "Deriver for Data.Vector.Unboxed using Template Haskell")
+    (description "This Haskell library provides a Template Haskell
+deriver for unboxed vectors, given a pair of coercion functions to
+and from some existing type with an Unbox instance.")
+    (license license:bsd-3)))
+
+(define-public ghc-void
+  (package
+    (name "ghc-void")
+    (version "0.7.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/void/void-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0aygw0yb1h3yhmfl3bkwh5d3h0l4mmsxz7j53vdm6jryl1kgxzyk"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-hashable" ,ghc-hashable)))
+    (home-page "https://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 license:bsd-3)))
+
+(define-public ghc-wave
+  (package
+    (name "ghc-wave")
+    (version "0.1.5")
+    (source (origin
+      (method url-fetch)
+      (uri (string-append
+             "https://hackage.haskell.org/package/wave/wave-"
+             version
+             ".tar.gz"))
+      (sha256
+        (base32
+          "03zycmwrchhqvi37fdvlzz2d1vl4hy0i8xyys1zznw38qfq0h2i5"))))
+    (build-system haskell-build-system)
+    (arguments
+     '(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "wave.cabal"
+               (("temporary.* < 1\\.3")
+                "temporary >= 1.1 && < 1.4")))))))
+    (inputs
+     `(("ghc-cereal" ,ghc-cereal)
+       ("ghc-data-default-class"
+        ,ghc-data-default-class)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-temporary" ,ghc-temporary)))
+    (native-inputs
+     `(("hspec-discover" ,hspec-discover)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://github.com/mrkkrp/wave")
+    (synopsis "Work with WAVE and RF64 files in Haskell")
+    (description "This package allows you to work with WAVE and RF64
+files in Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-wcwidth
+  (package
+    (name "ghc-wcwidth")
+    (version "0.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/wcwidth/wcwidth-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1n1fq7v64b59ajf5g50iqj9sa34wm7s2j3viay0kxpmvlcv8gipz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-setlocale" ,ghc-setlocale)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-attoparsec" ,ghc-attoparsec)))
+    (home-page "https://github.com/solidsnack/wcwidth/")
+    (synopsis "Haskell bindings to wcwidth")
+    (description "This package provides Haskell bindings to your system's
+native wcwidth and a command line tool to examine the widths assigned by it.
+The command line tool can compile a width table to Haskell code that assigns
+widths to the Char type.")
+    (license license:bsd-3)))
+
+(define-public ghc-wcwidth-bootstrap
+  (package
+    (inherit ghc-wcwidth)
+    (name "ghc-wcwidth-bootstrap")
+    (inputs
+     `(("ghc-setlocale" ,ghc-setlocale)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-attoparsec" ,ghc-attoparsec-bootstrap)))
+    (properties '(hidden? #t))))
+
+(define-public ghc-weigh
+  (package
+    (name "ghc-weigh")
+    (version "0.0.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/weigh/"
+                           "weigh-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0zw2a997gxgdzqmd7j730kxgynzmjvvlkw84dajmfzf1v9pbij7x"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-split" ,ghc-split)
+       ("ghc-temporary" ,ghc-temporary)))
+    (home-page "https://github.com/fpco/weigh#readme")
+    (synopsis "Measure allocations of a Haskell functions/values")
+    (description "This package provides tools to measure the memory usage of a
+Haskell value or function.")
+    (license license:bsd-3)))
+
+(define-public ghc-wl-pprint
+  (package
+    (name "ghc-wl-pprint")
+    (version "1.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/wl-pprint/wl-pprint-"
+                    version ".tar.gz"))
+              (sha256
+               (base32
+                "0kn7y8pdrv8f87zhd5mifcl8fy3b2zvnzmzwhdqhxxlyzwiq6z0c"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/wl-pprint")
+    (synopsis "Wadler/Leijen pretty printer")
+    (description
+     "This is a pretty printing library based on Wadler's paper @i{A Prettier
+Printer}.  This version allows the library user to declare overlapping
+instances of the @code{Pretty} class.")
+    (license license:bsd-3)))
+
+(define-public ghc-wl-pprint-annotated
+  (package
+    (name "ghc-wl-pprint-annotated")
+    (version "0.1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/wl-pprint-annotated/wl-pprint-annotated-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1br7qyf27iza213inwhf9bm2k6in0zbmfw6w4clqlc9f9cj2nrkb"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page
+     "https://github.com/minad/wl-pprint-annotated#readme")
+    (synopsis
+     "Wadler/Leijen pretty printer with annotation support")
+    (description
+     "Annotations are useful for coloring.  This is a limited version of
+@code{wl-pprint-extras} without support for point effects and without the free
+monad.  Like in @code{annotated-wl-pprint}, only annotations are supported.
+Compared to @code{annotated-wl-pprint} this library provides a slightly
+modernized interface.")
+    (license license:bsd-3)))
+
+(define-public ghc-wl-pprint-text
+  (package
+    (name "ghc-wl-pprint-text")
+    (version "1.2.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/wl-pprint-text/wl-pprint-text-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0g3w92rad6x5appfb22rbzcas2ix2h0hy91sdxhq8a4a5cnlrpa0"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)))
+    (home-page "https://hackage.haskell.org/package/wl-pprint-text")
+    (synopsis "Wadler/Leijen Pretty Printer for Text values")
+    (description
+     "A clone of wl-pprint for use with the text library.")
+    (license license:bsd-3)))
+
+(define-public ghc-word8
+  (package
+    (name "ghc-word8")
+    (version "0.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/word8/word8-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "12jx7f13d2h1djq4fh4dyrab61sm49mj1w61j3rzp2vjfm696c16"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://hackage.haskell.org/package/word8")
+    (synopsis "Word8 library for Haskell")
+    (description "Word8 library to be used with @code{Data.ByteString}.")
+    (license license:bsd-3)))
+
+(define-public ghc-x11
+  (package
+    (name "ghc-x11")
+    (version "1.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/X11/"
+                           "X11-" version ".tar.gz"))
+       (sha256
+        (base32 "1f8dy6ckkyvpcv7zlniyv01cqjb9lgqscm8pml58cvwc7n38w4qh"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("libx11" ,libx11)
+       ("libxrandr" ,libxrandr)
+       ("libxinerama" ,libxinerama)
+       ("libxscrnsaver" ,libxscrnsaver)
+       ("ghc-data-default" ,ghc-data-default)))
+    (home-page "https://github.com/haskell-pkg-janitors/X11")
+    (synopsis "Bindings to the X11 graphics library")
+    (description
+     "This package provides Haskell bindings to the X11 graphics library.  The
+bindings are a direct translation of the C bindings.")
+    (license license:bsd-3)))
+
+(define-public ghc-x11-xft
+  (package
+    (name "ghc-x11-xft")
+    (version "0.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/X11-xft/"
+                           "X11-xft-" version ".tar.gz"))
+       (sha256
+        (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
+    (inputs
+     `(("ghc-x11" ,ghc-x11)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("libx11" ,libx11)
+       ("libxft" ,libxft)
+       ("xorgproto" ,xorgproto)))
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/X11-xft")
+    (synopsis "Bindings to Xft")
+    (description
+     "Bindings to the Xft, X Free Type interface library, and some Xrender
+parts.")
+    (license license:lgpl2.1)))
+
+(define-public ghc-xdg-basedir
+  (package
+    (name "ghc-xdg-basedir")
+    (version "0.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/xdg-basedir/"
+             "xdg-basedir-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0azlzaxp2dn4l1nr7shsxah2magk1szf6fx0mv75az00qsjw6qg4"))))
+    (build-system haskell-build-system)
+    (home-page "http://github.com/willdonnelly/xdg-basedir")
+    (synopsis "XDG Base Directory library for Haskell")
+    (description "This package provides a library implementing the XDG Base Directory spec.")
+    (license license:bsd-3)))
+
+(define-public ghc-xml
+  (package
+    (name "ghc-xml")
+    (version "1.3.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/xml/xml-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
+    (build-system haskell-build-system)
+    (home-page "http://code.galois.com")
+    (synopsis "Simple XML library for Haskell")
+    (description "This package provides a simple XML library for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-xml-conduit
+  (package
+    (name "ghc-xml-conduit")
+    (version "1.8.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/xml-conduit/"
+                           "xml-conduit-" version ".tar.gz"))
+       (sha256
+        (base32
+         "177gmyigxql1pn3ncz0r8annwv5cbxnihbgrrg1dhm4gmc9jy2wq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-xml-types" ,ghc-xml-types)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/snoyberg/xml")
+    (synopsis "Utilities for dealing with XML with the conduit package")
+    (description
+     "This package provides pure-Haskell utilities for dealing with XML with
+the @code{conduit} package.")
+    (license license:expat)))
+
+(define-public ghc-xml-types
+  (package
+    (name "ghc-xml-types")
+    (version "0.3.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/xml-types/"
+                           "xml-types-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1jgqxsa9p2q3h6nymbfmvhldqrqlwrhrzmwadlyc0li50x0d8dwr"))))
+    (build-system haskell-build-system)
+    (home-page "https://john-millikin.com/software/haskell-xml/")
+    (synopsis "Basic types for representing XML")
+    (description "This package provides basic types for representing XML
+documents.")
+    (license license:expat)))
+
+(define-public ghc-yaml
+  (package
+    (name "ghc-yaml")
+    (version "0.8.32")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "yaml/yaml-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0cbsyh4ilvjzq1q7pxls43k6pdqxg1l85xzibcwpbvmlvrizh86w"))))
+    (build-system haskell-build-system)
+    ;; The tests are broken on i686.  They are fixed in 0.10.3.0.
+    ;; See https://github.com/snoyberg/yaml/issues/158
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
+       ("ghc-base-compat" ,ghc-base-compat)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-mockery" ,ghc-mockery)))
+    (home-page "https://github.com/snoyberg/yaml/")
+    (synopsis "Parsing and rendering YAML documents")
+    (description
+     "This package provides a library to parse and render YAML documents.")
+    (license license:bsd-3)))
+
+(define-public ghc-zip-archive
+  (package
+    (name "ghc-zip-archive")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/zip-archive/zip-archive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0kf8xyac168bng8a0za2jwrbss7a4ralvci9g54hnvl0gkkxx2lq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-digest" ,ghc-digest)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-zlib" ,ghc-zlib)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("unzip" ,unzip)))
+    (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 license:bsd-3)))
+
+(define-public ghc-zlib
+  (package
+    (name "ghc-zlib")
+    (version "0.6.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/zlib/zlib-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1vbzf0awb6zb456xf48za1kl22018646cfzq4frvxgb9ay97vk0d"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'strip-test-framework-constraints
+           (lambda _
+             (substitute* "zlib.cabal"
+               (("tasty            >= 0\\.8 && < 0\\.12") "tasty")
+               (("tasty-hunit      >= 0\\.8 && < 0\\.10") "tasty-hunit")
+               (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+    (inputs `(("zlib" ,zlib)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/zlib")
+    (synopsis
+     "Compression and decompression in the gzip and zlib formats")
+    (description
+     "This package provides a pure interface for compressing and decompressing
+streams of data represented as lazy @code{ByteString}s.  It uses the zlib C
+library so it has high performance.  It supports the @code{zlib}, @code{gzip}
+and @code{raw} compression formats.  It provides a convenient high level API
+suitable for most tasks and for the few cases where more control is needed it
+provides access to the full zlib feature set.")
+    (license license:bsd-3)))
+
 (define-public ghc-zlib-bindings
   (package
     (name "ghc-zlib-bindings")