Merge branch 'master' into staging

20 files changed, 887 insertions, 478 deletions

diff --git a/gnu/local.mk b/gnu/local.mk
index d6f64d372a..e4730aafcd 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -238,6 +238,7 @@ GNU_SYSTEM_MODULES =				\
   %D%/packages/haskell-check.scm		\
   %D%/packages/haskell-crypto.scm		\
   %D%/packages/haskell-web.scm			\
+  %D%/packages/haskell-xyz.scm			\
   %D%/packages/ham-radio.scm			\
   %D%/packages/hexedit.scm			\
   %D%/packages/hugs.scm				\
diff --git a/gnu/packages/agda.scm b/gnu/packages/agda.scm
index 646595705b..0f9b4299c3 100644
--- a/gnu/packages/agda.scm
+++ b/gnu/packages/agda.scm
@@ -64,9 +64,7 @@
        ("ghc-uri-encode" ,ghc-uri-encode)
        ("ghc-parallel" ,ghc-parallel)
        ("ghc-regex-tdfa" ,ghc-regex-tdfa)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-strict" ,ghc-strict)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-zlib" ,ghc-zlib)))
     (arguments
diff --git a/gnu/packages/bioinformatics.scm b/gnu/packages/bioinformatics.scm
index 956257d7bb..e860b5b881 100644
--- a/gnu/packages/bioinformatics.scm
+++ b/gnu/packages/bioinformatics.scm
@@ -7691,13 +7691,13 @@ powerful online queries from gene annotation to database mining.")
 (define-public r-biocparallel
   (package
     (name "r-biocparallel")
-    (version "1.18.0")
+    (version "1.18.1")
     (source (origin
               (method url-fetch)
               (uri (bioconductor-uri "BiocParallel" version))
               (sha256
                (base32
-                "0v8rhf3hbgb3v32h2pmsv1y6q2x4airmpp50fk7z6ardcn4aza7x"))))
+                "1j6wbls4qgvi5gj99c51r00jhxrzxk3x3258wg7dcjzbfqypvyw3"))))
     (properties
      `((upstream-name . "BiocParallel")))
     (build-system r-build-system)
@@ -10425,14 +10425,14 @@ provided.")
 (define-public r-hdf5array
   (package
     (name "r-hdf5array")
-    (version "1.12.1")
+    (version "1.12.2")
     (source
      (origin
        (method url-fetch)
        (uri (bioconductor-uri "HDF5Array" version))
        (sha256
         (base32
-         "0n8zc1x582vwb0zfhrjmnqbnpqky9zbhjc2j836i0a4yisklwdcp"))))
+         "0afradisrr5gn0lf2kxjw55vdm3lm9mlgx53qlr9r40c1hrydpf5"))))
     (properties `((upstream-name . "HDF5Array")))
     (build-system r-build-system)
     (inputs
@@ -13964,13 +13964,11 @@ datasets.")
        ("ghc-intervalmap" ,ghc-intervalmap)
        ("ghc-missingh" ,ghc-missingh)
        ("ghc-optparse-applicative" ,ghc-optparse-applicative)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-regex" ,ghc-regex)
        ("ghc-safe" ,ghc-safe)
        ("ghc-safeio" ,ghc-safeio)
        ("ghc-strict" ,ghc-strict)
        ("ghc-tar" ,ghc-tar)
-       ("ghc-text" ,ghc-text)
        ("ghc-unliftio" ,ghc-unliftio)
        ("ghc-unliftio-core" ,ghc-unliftio-core)
        ("ghc-vector" ,ghc-vector)
@@ -14829,3 +14827,171 @@ trees by inserting random mutations.  The tbsp package implements an
 alternative method to detect significant, cell type specific sequence
 mutations from scRNA-Seq data.")
       (license license:expat))))
+
+(define-public tabixpp
+  (package
+   (name "tabixpp")
+   (version "1.0.0")
+   (source (origin
+     (method git-fetch)
+     (uri (git-reference
+           (url "https://github.com/ekg/tabixpp")
+           (commit (string-append "v" version))))
+     (file-name (git-file-name name version))
+     (sha256
+      (base32 "08vx6nsipk971cyr8z53rnzwkvlld63kcn1fw0pwddynz91xfny8"))))
+   (build-system gnu-build-system)
+   (inputs
+    `(("htslib" ,htslib)
+      ("zlib" ,zlib)))
+   (arguments
+    `(#:tests? #f ; There are no tests to run.
+      #:phases
+      (modify-phases %standard-phases
+        (delete 'configure) ; There is no configure phase.
+        ;; The build phase needs overriding the location of htslib.
+        (replace 'build
+          (lambda* (#:key inputs #:allow-other-keys)
+            (let ((htslib-ref (assoc-ref inputs "htslib")))
+              (invoke "make"
+                      (string-append "HTS_LIB=" htslib-ref "/lib/libhts.a")
+                      "HTS_HEADERS="    ; No need to check for headers here.
+                      (string-append "LIBPATH=-L. -L" htslib-ref "/include")))))
+        (replace 'install
+          (lambda* (#:key outputs #:allow-other-keys)
+            (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+              (install-file "tabix++" bin))
+            #t)))))
+   (home-page "https://github.com/ekg/tabixpp")
+   (synopsis "C++ wrapper around tabix project")
+   (description "This is a C++ wrapper around the Tabix project which abstracts
+some of the details of opening and jumping in tabix-indexed files.")
+   (license license:expat)))
+
+(define-public smithwaterman
+  ;; TODO: Upgrading smithwaterman breaks FreeBayes.
+  (let ((commit "203218b47d45ac56ef234716f1bd4c741b289be1"))
+    (package
+      (name "smithwaterman")
+      (version (string-append "0-1." (string-take commit 7)))
+      (source (origin
+        (method git-fetch)
+        (uri (git-reference
+              (url "https://github.com/ekg/smithwaterman/")
+              (commit commit)))
+        (file-name (git-file-name name version))
+        (sha256
+         (base32 "0z9xsmsv452kgdfbbwydyc6nymg3fwyv8zswls8qjin3r4ia4415"))))
+      (build-system gnu-build-system)
+      (arguments
+       `(#:tests? #f ; There are no tests to run.
+         #:phases
+         (modify-phases %standard-phases
+           (delete 'configure) ; There is no configure phase.
+           (replace 'install
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+                 (install-file "smithwaterman" bin))
+               #t)))))
+      (home-page "https://github.com/ekg/smithwaterman")
+      (synopsis "Implementation of the Smith-Waterman algorithm")
+      (description "Implementation of the Smith-Waterman algorithm.")
+      ;; The licensing terms are unclear: https://github.com/ekg/smithwaterman/issues/9.
+      (license (list license:gpl2 license:expat)))))
+
+(define-public multichoose
+  (package
+    (name "multichoose")
+    (version "1.0.3")
+    (source (origin
+      (method git-fetch)
+      (uri (git-reference
+            (url "https://github.com/ekg/multichoose/")
+            (commit (string-append "v" version))))
+      (file-name (git-file-name name version))
+      (sha256
+       (base32 "0ci5fqvmpamwgxvmyd79ygj6n3bnbl3vc7b6h1sxz58186sm3pfs"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:tests? #f ; Tests require node.
+       #:phases
+       (modify-phases %standard-phases
+         (delete 'configure) ; There is no configure phase.
+         (replace 'install
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+               ;; TODO: There are Python modules for these programs too.
+               (install-file "multichoose" bin)
+               (install-file "multipermute" bin))
+             #t)))))
+    (home-page "https://github.com/ekg/multichoose")
+    (synopsis "Efficient loopless multiset combination generation algorithm")
+    (description "This library implements an efficient loopless multiset
+combination generation algorithm which is (approximately) described in
+\"Loopless algorithms for generating permutations, combinations, and other
+combinatorial configurations.\", G. Ehrlich - Journal of the ACM (JACM),
+1973. (Algorithm 7.)")
+    (license license:expat)))
+
+(define-public fsom
+  (let ((commit "a6ef318fbd347c53189384aef7f670c0e6ce89a3"))
+    (package
+      (name "fsom")
+      (version (git-version "0.0.0" "1" commit))
+      (source (origin
+        (method git-fetch)
+        (uri (git-reference
+              (url "https://github.com/ekg/fsom/")
+              (commit commit)))
+        (file-name (git-file-name name version))
+        (sha256
+         (base32 "0gw1lpvr812pywg9y546x0h1hhj261xwls41r6kqhddjlrcjc0pi"))))
+      (build-system gnu-build-system)
+      (arguments
+       `(#:tests? #f ; There are no tests to run.
+         #:phases
+         (modify-phases %standard-phases
+           (delete 'configure) ; There is no configure phase.
+           (replace 'install
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+                 (install-file "fsom" bin))
+               #t)))))
+      (home-page "https://github.com/ekg/fsom")
+      (synopsis "Manage SOM (Self-Organizing Maps) neural networks")
+      (description "A tiny C library for managing SOM (Self-Organizing Maps)
+neural networks.")
+      (license license:gpl3))))
+
+(define-public fastahack
+  (let ((commit "c68cebb4f2e5d5d2b70cf08fbdf1944e9ab2c2dd"))
+    (package
+      (name "fastahack")
+      (version (git-version "0.0.0" "1" commit))
+      (source (origin
+        (method git-fetch)
+        (uri (git-reference
+              (url "https://github.com/ekg/fastahack/")
+              (commit commit)))
+        (file-name (git-file-name name version))
+        (sha256
+         (base32 "0hfdv67l9g611i2ck4l92pd6ygmsp9g1ph4zx1ni7qkpsikf0l19"))))
+      (build-system gnu-build-system)
+      (arguments
+       `(#:tests? #f ; Unclear how to run tests: https://github.com/ekg/fastahack/issues/15
+         #:phases
+         (modify-phases %standard-phases
+           (delete 'configure) ; There is no configure phase.
+           (replace 'install
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+                 (install-file "fastahack" bin))
+               #t)))))
+      (home-page "https://github.com/ekg/fastahack")
+      (synopsis "Indexing and sequence extraction from FASTA files")
+      (description "Fastahack is a small application for indexing and
+extracting sequences and subsequences from FASTA files.  The included library
+provides a FASTA reader and indexer that can be embedded into applications
+which would benefit from directly reading subsequences from FASTA files.  The
+library automatically handles index file generation and use.")
+      (license (list license:expat license:gpl2)))))
diff --git a/gnu/packages/cran.scm b/gnu/packages/cran.scm
index 4b998eb1fb..d928f971d0 100644
--- a/gnu/packages/cran.scm
+++ b/gnu/packages/cran.scm
@@ -420,21 +420,21 @@ the embedded @code{RapidXML} C++ library.")
 (define-public r-modelr
   (package
     (name "r-modelr")
-    (version "0.1.4")
+    (version "0.1.5")
     (source
      (origin
        (method url-fetch)
        (uri (cran-uri "modelr" version))
        (sha256
         (base32
-         "1ngxphbjkv7yl1rg30sj36mfwhc76g452drjrq9abgab4k0pgnml"))))
+         "0nnfhlzz75ihs8azy963cc4cwg1kx81rybk4z3wm98bbghwfxfs5"))))
     (build-system r-build-system)
     (propagated-inputs
      `(("r-broom" ,r-broom)
        ("r-dplyr" ,r-dplyr)
-       ("r-lazyeval" ,r-lazyeval)
        ("r-magrittr" ,r-magrittr)
        ("r-purrr" ,r-purrr)
+       ("r-rlang" ,r-rlang)
        ("r-tibble" ,r-tibble)
        ("r-tidyr" ,r-tidyr)))
     (home-page "https://github.com/tidyverse/modelr")
@@ -5544,14 +5544,14 @@ movies, and TV shows.")
 (define-public r-ggsignif
   (package
     (name "r-ggsignif")
-    (version "0.5.0")
+    (version "0.6.0")
     (source
      (origin
        (method url-fetch)
        (uri (cran-uri "ggsignif" version))
        (sha256
         (base32
-         "0z04g5kqdj66fyfxb5d2m7njkqd7idbiy4xgsnxdh5pbh3cr643x"))))
+         "17j9hg967k1wp9xw3x84mqss58jkb8pvlrnlchz4i1hklgykxqbg"))))
     (build-system r-build-system)
     (propagated-inputs
      `(("r-ggplot2" ,r-ggplot2)))
diff --git a/gnu/packages/databases.scm b/gnu/packages/databases.scm
index 665e5a5c05..30e27dcea2 100644
--- a/gnu/packages/databases.scm
+++ b/gnu/packages/databases.scm
@@ -853,27 +853,27 @@ pictures, sounds, or video.")
   (package
     (inherit postgresql)
     (name "postgresql")
-    (version "11.4")
+    (version "11.5")
     (source (origin
               (method url-fetch)
               (uri (string-append "https://ftp.postgresql.org/pub/source/v"
                                   version "/postgresql-" version ".tar.bz2"))
               (sha256
                (base32
-                "12ycjlqncijgmd5z078ybwda8ilas96lc7nxxmdq140mzpgjv002"))))))
+                "106ikalvrilihlvhq7xj7snq98hgbgq6qsgjrd252wgw1c327pvz"))))))
 
 (define-public postgresql-9.6
   (package
     (inherit postgresql)
     (name "postgresql")
-    (version "9.6.14")
+    (version "9.6.15")
     (source (origin
               (method url-fetch)
               (uri (string-append "https://ftp.postgresql.org/pub/source/v"
                                   version "/postgresql-" version ".tar.bz2"))
               (sha256
                (base32
-                "08hsqczy1ixkjyf2vr3s9x69agfz9yr8lh31fir4z0dfr5jw421z"))))))
+                "02hp69h2p02asfblkaahblzdz2zmawd2r11h6237y5j7yadgxn9w"))))))
 
 (define-public python-pymysql
   (package
diff --git a/gnu/packages/freedesktop.scm b/gnu/packages/freedesktop.scm
index d77d6c58c4..9cfdbca3fb 100644
--- a/gnu/packages/freedesktop.scm
+++ b/gnu/packages/freedesktop.scm
@@ -718,7 +718,7 @@ multiplexer to the KMS/DRM Linux kernel devices.")
 (define-public exempi
   (package
     (name "exempi")
-    (version "2.5.0")
+    (version "2.5.1")
     (source (origin
              (method url-fetch)
              (uri (string-append
@@ -726,7 +726,7 @@ multiplexer to the KMS/DRM Linux kernel devices.")
                    name "-" version ".tar.bz2"))
              (sha256
               (base32
-               "06vi7dc2gappwqm3xpfyy5ihxq14bmvj3bd47yk482jlq0jgr0nw"))))
+               "1j4vx054l1c2cggw4aka4iw48jkcf68qk5y064pbqw1k3ddks2qh"))))
     (build-system gnu-build-system)
     (arguments
      `(#:configure-flags (list (string-append "--with-boost="
@@ -736,7 +736,7 @@ multiplexer to the KMS/DRM Linux kernel devices.")
     (inputs
      `(("expat" ,expat)
        ("zlib" ,zlib)))
-    (home-page "https://wiki.freedesktop.org/libopenraw/Exempi")
+    (home-page "https://libopenraw.freedesktop.org/exempi/")
     (synopsis "XMP metadata handling library")
     (description "Exempi is an implementation of the Extensible Metadata
 Platform (@dfn{XMP}), which enables embedding metadata in PDF and image
diff --git a/gnu/packages/games.scm b/gnu/packages/games.scm
index 07ed02ba18..92df556970 100644
--- a/gnu/packages/games.scm
+++ b/gnu/packages/games.scm
@@ -4977,6 +4977,10 @@ Crowther & Woods, its original authors, in 1995.  It has been known as
        ("luajit" ,luajit)))
     (arguments
      `(#:make-flags '("CC=gcc" "config=release")
+       ;; XXX: Building in parallel occasionally causes this build failure:
+       ;;   ../src/luajit2/src/host/buildvm.c:73:10: fatal error: buildvm_arch.h:
+       ;;   No such file or directory
+       #:parallel-build? #f
        #:phases (modify-phases %standard-phases
                   (delete 'bootstrap)
                   (replace 'configure
diff --git a/gnu/packages/gnome.scm b/gnu/packages/gnome.scm
index 601248b7f5..da6cbf2a05 100644
--- a/gnu/packages/gnome.scm
+++ b/gnu/packages/gnome.scm
@@ -5535,6 +5535,57 @@ Compatible with Cisco VPN concentrators configured to use IPsec.")
     (license license:gpl2+)
     (properties `((upstream-name . "NetworkManager-vpnc")))))
 
+(define-public network-manager-openconnect
+  (package
+    (name "network-manager-openconnect")
+    (version "1.2.6")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "mirror://gnome/sources/NetworkManager-openconnect/"
+                    (version-major+minor version)
+                    "/NetworkManager-openconnect-" version ".tar.xz"))
+              (sha256
+               (base32
+                "0nlp290nkawc4wqm978n4vhzg3xdqi8kpjjx19l855vab41rh44m"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:configure-flags '("--enable-absolute-paths" "--localstatedir=/var")
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'configure 'patch-path
+           (lambda* (#:key inputs outputs #:allow-other-keys #:rest args)
+             (let* ((openconnect (string-append (assoc-ref inputs "openconnect")
+                                         "/sbin/openconnect"))
+                    (modprobe (string-append (assoc-ref inputs "kmod")
+                                             "/bin/modprobe"))
+                    (pretty-ovpn (string-append "\"" openconnect "\"")))
+               (substitute* "src/nm-openconnect-service.c"
+                 (("\"/usr/local/sbin/openconnect\"") pretty-ovpn)
+                 (("\"/usr/sbin/openconnect\"") pretty-ovpn)
+                 (("/sbin/modprobe") modprobe)))
+             #t)))))
+    (native-inputs
+     `(("intltool" ,intltool)
+       ("network-manager-applet" ,network-manager-applet) ;for libnma
+       ("pkg-config" ,pkg-config)))
+    (inputs
+     `(("gcr" ,gcr)
+       ("gtk+" ,gtk+)
+       ("kmod" ,kmod)
+       ("libsecret" ,libsecret)
+       ("libxml2" ,libxml2)
+       ("network-manager" ,network-manager)
+       ("openconnect" ,openconnect)))
+    (home-page "https://wiki.gnome.org/Projects/NetworkManager/VPN")
+    (synopsis "OpenConnect plug-in for NetworkManager")
+    (description
+     "This extension of NetworkManager allows it to take care of connections
+to @acronym{VPNs, virtual private networks} via OpenConnect, an open client for
+Cisco's AnyConnect SSL VPN.")
+    (license license:gpl2+)
+    (properties `((upstream-name . "NetworkManager-openconnect")))))
+
 (define-public mobile-broadband-provider-info
   (package
     (name "mobile-broadband-provider-info")
diff --git a/gnu/packages/haskell-apps.scm b/gnu/packages/haskell-apps.scm
index d675863090..e01f796178 100644
--- a/gnu/packages/haskell-apps.scm
+++ b/gnu/packages/haskell-apps.scm
@@ -99,7 +99,6 @@
        ("ghc-html" ,ghc-html)
        ("ghc-mmap" ,ghc-mmap)
        ("ghc-old-time" ,ghc-old-time)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-random" ,ghc-random)
        ("ghc-regex-applicative" ,ghc-regex-applicative)
        ("ghc-regex-compat-tdfa" ,ghc-regex-compat-tdfa)
@@ -242,10 +241,8 @@ unique algebra of patches called @url{http://darcs.net/Theory,Patchtheory}.
        ("ghc-securemem" ,ghc-securemem)
        ("ghc-socks" ,ghc-socks)
        ("ghc-split" ,ghc-split)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-stm-chans" ,ghc-stm-chans)
        ("ghc-tagsoup" ,ghc-tagsoup)
-       ("ghc-text" ,ghc-text)
        ("ghc-unix-compat" ,ghc-unix-compat)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-utf8-string" ,ghc-utf8-string)
@@ -285,7 +282,6 @@ used to keep a folder in sync between computers.")
      `(("ghc-exceptions" ,ghc-exceptions)
        ("ghc-linear" ,ghc-linear)
        ("ghc-statevar" ,ghc-statevar)
-       ("ghc-text" ,ghc-text)
        ("ghc-vector" ,ghc-vector)
        ("sdl2" ,sdl2)))
     (native-inputs
@@ -347,7 +343,6 @@ programming.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-sdl2" ,ghc-sdl2)
-       ("ghc-text" ,ghc-text)
        ("sdl2-image" ,sdl2-image)))
     (native-inputs
      `(("pkg-config" ,pkg-config)))
diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm
index 3c10a5284e..589eee74d9 100644
--- a/gnu/packages/haskell-check.scm
+++ b/gnu/packages/haskell-check.scm
@@ -54,7 +54,6 @@
     (inputs
      `(("ghc-generic-deriving" ,ghc-generic-deriving)
        ("ghc-xml" ,ghc-xml)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-tagged" ,ghc-tagged)
        ("ghc-tasty" ,ghc-tasty)))
     (home-page
@@ -170,8 +169,7 @@ contains the correct result for the test.")
          "14riid753hjqr6lca1kgxpnvq0wykf0k3qc5jpag42hh8bszav22"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-tagged" ,ghc-tagged)
+     `(("ghc-tagged" ,ghc-tagged)
        ("ghc-regex-tdfa" ,ghc-regex-tdfa)
        ("ghc-optparse-applicative" ,ghc-optparse-applicative)
        ("ghc-unbounded-delays" ,ghc-unbounded-delays)
@@ -277,7 +275,6 @@ test-framework.")
      `(("ghc-optparse-applicative" ,ghc-optparse-applicative)
        ("ghc-reducers" ,ghc-reducers)
        ("ghc-split" ,ghc-split)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-tagged" ,ghc-tagged)
        ("ghc-tasty" ,ghc-tasty)))
     (home-page "https://github.com/ocharles/tasty-rerun")
@@ -340,7 +337,6 @@ development.")
        ("ghc-old-time" ,ghc-old-time)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-tagged" ,ghc-tagged)
-       ("ghc-text" ,ghc-text)
        ("ghc-transformers-compat" ,ghc-transformers-compat)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-uuid-types" ,ghc-uuid-types)
@@ -815,7 +811,7 @@ implementations of cryptographic ciphers.")
          "0xz10ycdm5vk9nrcym1fi83k19frfwqz18bz8bnpzwvaj0j41yfj"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-ansi-terminal" ,ghc-ansi-terminal-0.8)
+     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
        ("ghc-async" ,ghc-async)
        ("ghc-concurrent-output" ,ghc-concurrent-output)
        ("ghc-exceptions" ,ghc-exceptions)
@@ -827,7 +823,6 @@ implementations of cryptographic ciphers.")
        ("ghc-random" ,ghc-random)
        ("ghc-resourcet" ,ghc-resourcet)
        ("ghc-semigroups" ,ghc-semigroups)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-th-lift" ,ghc-th-lift)
        ("ghc-transformers-base" ,ghc-transformers-base)
        ("ghc-wl-pprint-annotated"
diff --git a/gnu/packages/haskell-crypto.scm b/gnu/packages/haskell-crypto.scm
index 8d28a77fc1..882773ab68 100644
--- a/gnu/packages/haskell-crypto.scm
+++ b/gnu/packages/haskell-crypto.scm
@@ -25,6 +25,8 @@
   #:use-module (gnu packages compression)
   #:use-module (gnu packages haskell)
   #:use-module (gnu packages haskell-check)
+  #:use-module (gnu packages haskell-xyz)
+  #:use-module (gnu packages tls)
   #:use-module (guix build-system haskell)
   #:use-module (guix download)
   #:use-module ((guix licenses) #:prefix license:)
@@ -69,8 +71,7 @@ format.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-hourglass" ,ghc-hourglass)
-       ("ghc-asn1-types" ,ghc-asn1-types)
-       ("ghc-text" ,ghc-text)))
+       ("ghc-asn1-types" ,ghc-asn1-types)))
     (native-inputs
      `(("ghc-tasty" ,ghc-tasty)
        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
@@ -776,3 +777,64 @@ Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many
 extensions.")
     (license license:bsd-3)))
 
+(define-public ghc-hsopenssl
+  (package
+    (name "ghc-hsopenssl")
+    (version "0.11.4.15")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "HsOpenSSL/HsOpenSSL-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0idmak6d8mpbxphyq9hkxkmby2wnzhc1phywlgm0zw6q47pwxgff"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-network" ,ghc-network)
+       ("openssl" ,openssl)))
+    (arguments
+     `(#:cabal-revision
+       ("1" "0bkcw2pjfgv1bhgkrpncvwq9czfr7cr4ak14n0v8c2y33i33wk5z")))
+    (home-page "https://github.com/vshabanov/HsOpenSSL")
+    (synopsis "Partial OpenSSL binding for Haskell")
+    (description "HsOpenSSL is an OpenSSL binding for Haskell.  It can
+generate RSA and DSA keys, read and write PEM files, generate message
+digests, sign and verify messages, encrypt and decrypt messages.  It has
+also some capabilities of creating SSL clients and servers.  This
+package is in production use by a number of Haskell based systems and
+stable.  You may also be interested in the tls package,
+@uref{http://hackage.haskell.org/package/tls}, which is a pure Haskell
+implementation of SSL.")
+    (license license:public-domain)))
+
+(define-public ghc-openssl-streams
+  (package
+    (name "ghc-openssl-streams")
+    (version "1.2.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "openssl-streams/openssl-streams-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0pwghr7ygv59k572xsj1j97rilkbjz66qaiyj0ra2wfg6pl70wfw"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hsopenssl" ,ghc-hsopenssl)
+       ("ghc-io-streams" ,ghc-io-streams)
+       ("ghc-network" ,ghc-network)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (arguments
+     `(#:cabal-revision
+       ("2" "1004kgdryflpkp19dv4ikilhcn0xbfc5dsp6v3ib34580pcfj7wy")))
+    (home-page "http://hackage.haskell.org/package/openssl-streams")
+    (synopsis "OpenSSL network support for io-streams")
+    (description "This library contains io-streams routines for secure
+networking using OpenSSL (by way of HsOpenSSL).")
+    (license license:bsd-3)))
diff --git a/gnu/packages/haskell-web.scm b/gnu/packages/haskell-web.scm
index 6b7103562f..7cbf8932e6 100644
--- a/gnu/packages/haskell-web.scm
+++ b/gnu/packages/haskell-web.scm
@@ -28,6 +28,7 @@
   #:use-module (gnu packages haskell)
   #:use-module (gnu packages haskell-check)
   #:use-module (gnu packages haskell-crypto)
+  #:use-module (gnu packages haskell-xyz)
   #:use-module (guix build-system haskell)
   #:use-module (guix download)
   #:use-module ((guix licenses) #:prefix license:)
@@ -47,7 +48,6 @@
         (base32
          "1yv3dbyb0i1yqm796jgc4jj5kxkla1sxb3b2klw5ks182kdx8kjb"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-text" ,ghc-text)))
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "http://community.haskell.org/~ndm/tagsoup/")
@@ -80,7 +80,6 @@ for screen-scraping.")
     (inputs
      `(("ghc-old-locale" ,ghc-old-locale)
        ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-text" ,ghc-text)
        ("ghc-data-default-class" ,ghc-data-default-class)
        ("ghc-hunit" ,ghc-hunit)
        ("ghc-quickcheck" ,ghc-quickcheck)
@@ -136,8 +135,7 @@ requests, and the library is intended for implementing Ajax APIs.")
        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
        ("hspec-discover" ,hspec-discover)))
     (inputs
-     `(("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-text" ,ghc-text)))
+     `(("ghc-case-insensitive" ,ghc-case-insensitive)))
     (home-page "https://github.com/aristidb/http-types")
     (synopsis "Generic HTTP types for Haskell")
     (description "This package provides generic HTTP types for Haskell (for
@@ -169,7 +167,6 @@ both client and server code).")
        ("ghc-conduit-extra" ,ghc-conduit-extra)
        ("ghc-http-types" ,ghc-http-types)
        ("ghc-old-time" ,ghc-old-time)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-puremd5" ,ghc-puremd5)
        ("ghc-network" ,ghc-network)
        ("ghc-network-uri" ,ghc-network-uri)
@@ -215,7 +212,6 @@ responses coming back.")
        ("ghc-network-uri" ,ghc-network-uri)
        ("ghc-random" ,ghc-random)
        ("ghc-streaming-commons" ,ghc-streaming-commons)
-       ("ghc-text" ,ghc-text)
        ("ghc-zlib" ,ghc-zlib)))
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)))
@@ -308,13 +304,12 @@ Date in Haskell.")
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-vector" ,ghc-vector)
        ("ghc-word8" ,ghc-word8)
-       ("ghc-psqueues" ,ghc-psqueues)
-       ("ghc-stm" ,ghc-stm)))
-       (native-inputs
-        `(("ghc-glob" ,ghc-glob)
-         ("ghc-hspec" ,ghc-hspec)
-         ("ghc-doctest" ,ghc-doctest)
-         ("hspec-discover" ,hspec-discover)))
+       ("ghc-psqueues" ,ghc-psqueues)))
+    (native-inputs
+     `(("ghc-glob" ,ghc-glob)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-doctest" ,ghc-doctest)
+       ("hspec-discover" ,hspec-discover)))
     (home-page "https://github.com/kazu-yamamoto/http2")
     (synopsis "HTTP/2 library including frames, priority queues and HPACK")
     (description "This package provides a HTTP/2.0 library including frames
@@ -358,7 +353,6 @@ and HPACK.  Currently HTTP/2 16 framing and HPACK 10 is supported.")
        ("ghc-connection" ,ghc-connection)
        ("ghc-warp-tls" ,ghc-warp-tls)
        ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-text" ,ghc-text)
        ("ghc-conduit" ,ghc-conduit)
        ("ghc-utf8-string" ,ghc-utf8-string)
        ("ghc-case-insensitive" ,ghc-case-insensitive)
@@ -402,7 +396,6 @@ which allow you to avoid direct usage of conduits.")
        ("ghc-vault" ,ghc-vault)
        ("ghc-blaze-builder" ,ghc-blaze-builder)
        ("ghc-network" ,ghc-network)
-       ("ghc-text" ,ghc-text)
        ("ghc-http-types" ,ghc-http-types)))
     (native-inputs
      `(("hspec-discover" ,hspec-discover)
@@ -482,7 +475,6 @@ communication between web applications and web servers.")
        ("ghc-void" ,ghc-void)
        ("ghc-wai" ,ghc-wai)
        ("ghc-http-types" ,ghc-http-types)
-       ("ghc-text" ,ghc-text)
        ("ghc-case-insensitive" ,ghc-case-insensitive)
        ("ghc-data-default-class" ,ghc-data-default-class)
        ("ghc-unix-compat" ,ghc-unix-compat)
@@ -569,9 +561,7 @@ transfers.")
        ("ghc-http-types" ,ghc-http-types)
        ("ghc-iproute" ,ghc-iproute)
        ("ghc-network" ,ghc-network)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-streaming-commons" ,ghc-streaming-commons)
-       ("ghc-text" ,ghc-text)
        ("ghc-unix-compat" ,ghc-unix-compat)
        ("ghc-vault" ,ghc-vault)
        ("ghc-wai" ,ghc-wai)
@@ -670,8 +660,7 @@ a WAI handler, via the native Haskell TLS implementation.")
        ("ghc-css-text" ,ghc-css-text)
        ("ghc-network-uri" ,ghc-network-uri)))
     (native-inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-attoparsec" ,ghc-attoparsec)
+     `(("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-hunit" ,ghc-hunit)))
     (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
@@ -697,8 +686,7 @@ attacks.")
          "0ynd9f4hn2sfwqzbsa0y7phmxq8za7jiblpjwx0ry8b372zhgxaz"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-attoparsec" ,ghc-attoparsec)
+     `(("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "http://www.yesodweb.com/")
@@ -720,8 +708,6 @@ Haskell.")
                (base32
                 "14ccl2842ya17zyj0bpc7vzklbyqvvydpbypn69h2fmhgji192x8"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-text" ,ghc-text)))
     (home-page "https://github.com/yesodweb/wai")
     (synopsis "Basic MIME type handling types and functions")
     (description
@@ -751,28 +737,6 @@ Haskell.")
 documents.")
     (license license:bsd-3)))
 
-(define-public ghc-xhtml
-  (package
-    (name "ghc-xhtml")
-    (version "3000.2.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/xhtml/xhtml-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0939kwpinq6l4n3nyvd1gzyl7f83gymw0wzqndlgy1yc7q0nkj2w"))))
-    (build-system haskell-build-system)
-    (home-page "https://github.com/haskell/xhtml")
-    (synopsis "XHTML combinator library")
-    (description
-     "This package provides combinators for producing XHTML 1.0, including the
-Strict, Transitional and Frameset variants.")
-    (license license:bsd-3)))
-
 (define-public ghc-blaze-html
   (package
     (name "ghc-blaze-html")
@@ -789,7 +753,6 @@ Strict, Transitional and Frameset variants.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-text" ,ghc-text)
        ("ghc-blaze-markup" ,ghc-blaze-markup)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)
@@ -825,7 +788,6 @@ Strict, Transitional and Frameset variants.")
        ("ghc-hashable" ,ghc-hashable)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-tagged" ,ghc-tagged)
-       ("ghc-text" ,ghc-text)
        ("ghc-th-abstraction" ,ghc-th-abstraction)
        ("ghc-time-locale-compat" ,ghc-time-locale-compat)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
@@ -867,7 +829,6 @@ naming: in Greek mythology, Aeson was the father of Jason.)")
        ("ghc-base-compat" ,ghc-base-compat)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-vector" ,ghc-vector)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-cmdargs" ,ghc-cmdargs)))
@@ -897,12 +858,10 @@ essentially the opposite of pretty-printing.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-base-compat" ,ghc-base-compat)
-       ("ghc-text" ,ghc-text)
        ("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-vector" ,ghc-vector)
        ("ghc-aeson" ,ghc-aeson)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)
@@ -931,8 +890,7 @@ of a JSON value into a @code{Data.Aeson.Value}.")
          "1x4n4yyva22dhfr1pg5ki112qvvzb4hyd7bwpm189iq4gcp52q4z"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-stringsearch" ,ghc-stringsearch)))
+     `(("ghc-stringsearch" ,ghc-stringsearch)))
     (home-page
      "http://www.github.com/silkapp/multipart")
     (synopsis
@@ -956,8 +914,7 @@ of a JSON value into a @code{Data.Aeson.Value}.")
          "11miwb5vvnn17m92ykz1pzg9x6s8fbpz3mmsyqs2s4b3mn55haz8"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-utf8-string" ,ghc-utf8-string)
+     `(("ghc-utf8-string" ,ghc-utf8-string)
        ("ghc-network-uri" ,ghc-network-uri)))
     (home-page "https://hackage.haskell.org/package/uri-encode")
     (synopsis "Unicode aware uri-encoding")
@@ -978,7 +935,6 @@ of a JSON value into a @code{Data.Aeson.Value}.")
         (base32
          "0vx3sivcsld76058925hym2j6hm3g71f0qjr7v59f1g2afgx82q8"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-text" ,ghc-text)))
     (native-inputs `(("ghc-hunit" ,ghc-hunit)
                      ("ghc-hspec" ,ghc-hspec)
                      ("ghc-quickcheck" ,ghc-quickcheck)))
@@ -1067,7 +1023,6 @@ avoid any issues with characters.")
     (build-system haskell-build-system)
     (inputs `(("ghc-wai" ,ghc-wai)
               ("ghc-extra" ,ghc-extra)
-              ("ghc-text" ,ghc-text)
               ("ghc-shakespeare" ,ghc-shakespeare)
               ("ghc-blaze-builder" ,ghc-blaze-builder)
               ("ghc-clientsession" ,ghc-clientsession)
@@ -1081,7 +1036,6 @@ avoid any issues with characters.")
               ("ghc-cookie" ,ghc-cookie)
               ("ghc-http-types" ,ghc-http-types)
               ("ghc-case-insensitive" ,ghc-case-insensitive)
-              ("ghc-parsec" ,ghc-parsec)
               ("ghc-vector" ,ghc-vector)
               ("ghc-aeson" ,ghc-aeson)
               ("ghc-fast-logger" ,ghc-fast-logger)
@@ -1147,8 +1101,7 @@ functions, widgets, etc.")
     (native-inputs `(("ghc-hspec" ,ghc-hspec)
                      ("ghc-wai-extra" ,ghc-wai-extra)
                      ("ghc-yesod-core" ,ghc-yesod-core)
-                     ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)
-                     ("ghc-text" ,ghc-text)))
+                     ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)))
     (home-page "http://www.yesodweb.com/")
     (synopsis "Helpers for using Persistent from Yesod")
     (description "This Haskell package provides helpers for using Persistent
@@ -1179,7 +1132,6 @@ from Yesod.")
         ("ghc-xss-sanitize" ,ghc-xss-sanitize)
         ("ghc-blaze-builder" ,ghc-blaze-builder)
         ("ghc-email-validate" ,ghc-email-validate)
-        ("ghc-text" ,ghc-text)
         ("ghc-wai" ,ghc-wai)
         ("ghc-blaze-html" ,ghc-blaze-html)
         ("ghc-blaze-markup" ,ghc-blaze-markup)
@@ -1226,7 +1178,6 @@ providing richtext field using Nic editor. ")
        ("ghc-data-default-class" ,ghc-data-default-class)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-yaml" ,ghc-yaml)
-       ("ghc-text" ,ghc-text)
        ("ghc-monad-logger" ,ghc-monad-logger)
        ("ghc-fast-logger" ,ghc-fast-logger)
        ("ghc-conduit" ,ghc-conduit)
@@ -1309,8 +1260,6 @@ ignored.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
-       ("ghc-parsec" ,ghc-parsec)
-       ("ghc-text" ,ghc-text)
        ("ghc-hunit" ,ghc-hunit)))
     (home-page "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema")
     (synopsis "Regular expression library for W3C XML Schema regular expressions")
@@ -1336,8 +1285,7 @@ derivations of regular expressions.")
          "1qq3ykgn355rx242xjcbqqksgvwr6k2fdj5phw4iv28qqxff6m8d"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
+     `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
        ("ghc-hxt-unicode" ,ghc-hxt-unicode)
        ("ghc-hxt-regex-xmlschema" ,ghc-hxt-regex-xmlschema)
        ("ghc-network-uri" ,ghc-network-uri)))
@@ -1347,3 +1295,171 @@ derivations of regular expressions.")
      "The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but
 introduces a more general approach for processing XML with Haskell.")
     (license license:expat)))
+
+(define-public ghc-http-common
+  (package
+    (name "ghc-http-common")
+    (version "0.8.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "http-common/http-common-" version ".tar.gz"))
+       (sha256
+        (base32
+         "14s5a178sb2vm5k00rs21760mds5dz2gs10k9iyn22h01mxyf599"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-network" ,ghc-network)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "https://github.com/afcowie/http-streams/")
+    (synopsis "Common types for HTTP clients and servers")
+    (description "Base types used by a variety of HTTP clients and
+servers.  See http-streams @code{Network.Http.Client} or pipes-http
+@code{Pipes.Http.Client} for full documentation.  You can import
+@code{Network.Http.Types} if you like, but both http-streams and
+pipes-http re-export this package's types and functions.")
+    (license license:bsd-3)))
+
+(define-public ghc-http-streams
+  (package
+    (name "ghc-http-streams")
+    (version "0.8.6.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "http-streams/http-streams-" version ".tar.gz"))
+       (sha256
+        (base32
+         "18vxd35n7s3z4gjvad94bknc8z1w9d7ccgphnhsxlz5cackizmxq"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-io-streams" ,ghc-io-streams)
+       ("ghc-hsopenssl" ,ghc-hsopenssl)
+       ("ghc-openssl-streams" ,ghc-openssl-streams)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-http-common" ,ghc-http-common)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-network" ,ghc-network)))
+    (arguments
+     `(#:tests? #f)) ; tests rely on an outdated version of snap-server
+    (home-page "https://github.com/afcowie/http-streams/")
+    (synopsis "HTTP client using io-streams")
+    (description "An HTTP client using the Snap Framework's io-streams
+library to handle the streaming IO.  The API is optimized for ease of
+use for the rather common case of code needing to query web services and
+deal with the result.")
+    (license license:bsd-3)))
+
+(define-public ghc-snap-core
+  (package
+    (name "ghc-snap-core")
+    (version "1.0.3.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "snap-core/snap-core-" version ".tar.gz"))
+       (sha256
+        (base32
+         "136q7l4hd5yn5hb507q1ziqx124ma1lkzh5dx0n150p8dx3rhhsc"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-io-streams" ,ghc-io-streams)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-random" ,ghc-random)
+       ("ghc-readable" ,ghc-readable)
+       ("ghc-regex-posix" ,ghc-regex-posix)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-network" ,ghc-network)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-parallel" ,ghc-parallel)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+       ("ghc-zlib" ,ghc-zlib)))
+    (arguments
+     `(#:cabal-revision
+       ("3" "0wlhn33r7c9g7j23y006ddq9d87lkmianvvfrbl8jd8mvjvj2gfa")))
+    (home-page "http://snapframework.com/")
+    (synopsis "Haskell Web Framework (core interfaces and types)")
+    (description "Snap is a simple and fast web development framework
+and server written in Haskell.  For more information, you can visit the
+Snap project website at @uref{http://snapframework.com/}.  This library
+contains the core definitions and types for the Snap framework.")
+    (license license:bsd-3)))
+
+(define-public ghc-snap-server
+  (package
+    (name "ghc-snap-server")
+    (version "1.1.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "snap-server/snap-server-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0vvw9n8xs272qdlrf3dxhnva41zh3awi7pf022rrjj75lj8a77i4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-clock" ,ghc-clock)
+       ("ghc-io-streams" ,ghc-io-streams)
+       ("ghc-io-streams-haproxy" ,ghc-io-streams-haproxy)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-network" ,ghc-network)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-snap-core" ,ghc-snap-core)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-vector" ,ghc-vector)))
+    (native-inputs
+     `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-random" ,ghc-random)
+       ("ghc-threads" ,ghc-threads)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-http-streams" ,ghc-http-streams)
+       ("ghc-http-common" ,ghc-http-common)
+       ("ghc-parallel" ,ghc-parallel)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (arguments
+     `(#:cabal-revision
+       ("3" "0a9d3nqb5rvgm25nak68lp6yj9m6cwhbgdbg5l7ib5i2czcg7yjh")))
+    (home-page "http://snapframework.com/")
+    (synopsis "Web server for the Snap Framework")
+    (description "Snap is a simple and fast web development framework
+and server written in Haskell.  For more information, you can visit the
+Snap project website at @uref{http://snapframework.com/}.  The Snap HTTP
+server is a high performance web server library written in Haskell.
+Together with the snap-core library upon which it depends, it provides a
+clean and efficient Haskell programming interface to the HTTP
+protocol.")
+    (license license:bsd-3)))
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
new file mode 100644
index 0000000000..53c4dcc5ff
--- /dev/null
+++ b/gnu/packages/haskell-xyz.scm
@@ -0,0 +1,276 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
+;;;
+;;; This file is part of GNU Guix.
+;;;
+;;; GNU Guix is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3 of the License, or (at
+;;; your option) any later version.
+;;;
+;;; GNU Guix is distributed in the hope that it will be useful, but
+;;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (gnu packages haskell-xyz)
+  #:use-module (gnu packages)
+  #:use-module (gnu packages haskell)
+  #:use-module (gnu packages haskell-check)
+  #:use-module (guix build-system haskell)
+  #:use-module (guix download)
+  #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (guix packages))
+
+(define-public ghc-concurrent-extra
+  (package
+    (name "ghc-concurrent-extra")
+    (version "0.7.0.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "concurrent-extra/concurrent-extra-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1y8xk460fvnw0idzdiylmm874sjny4q9jxb1js9fjz8lw2wns3h4"))))
+    (build-system haskell-build-system)
+    (arguments
+     ;; XXX: The ReadWriteLock 'stressTest' fails.
+     `(#:tests? #f))
+    (inputs
+     `(("ghc-unbounded-delays" ,ghc-unbounded-delays)))
+    (native-inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-random" ,ghc-random)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://github.com/basvandijk/concurrent-extra")
+    (synopsis "Extra concurrency primitives")
+    (description "This Haskell library offers (among other things) the
+following selection of synchronisation primitives:
+
+@itemize
+@item @code{Broadcast}: Wake multiple threads by broadcasting a value.
+@item @code{Event}: Wake multiple threads by signalling an event.
+@item @code{Lock}: Enforce exclusive access to a resource.  Also known
+as a binary semaphore or mutex.  The package additionally provides an
+alternative that works in the STM monad.
+@item @code{RLock}: A lock which can be acquired multiple times by the
+same thread.  Also known as a reentrant mutex.
+@item @code{ReadWriteLock}: Multiple-reader, single-writer locks.  Used
+to protect shared resources which may be concurrently read, but only
+sequentially written.
+@item @code{ReadWriteVar}: Concurrent read, sequential write variables.
+@end itemize
+
+Please consult the API documentation of the individual modules for more
+detailed information.
+
+This package was inspired by the concurrency libraries of Java and
+Python.")
+    (license license:bsd-3)))
+
+(define-public ghc-io-streams
+  (package
+    (name "ghc-io-streams")
+    (version "1.5.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "io-streams/io-streams-" version ".tar.gz"))
+       (sha256
+        (base32
+         "12rcdg2d70644bvn838fxcjkssqj8pssnx5y657si5rijcbkgjsx"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-zlib-bindings" ,ghc-zlib-bindings)))
+    (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)
+       ("ghc-zlib" ,ghc-zlib)))
+    (arguments
+     `(#:cabal-revision
+       ("2" "1mcab95d6hm098myh9gp7sh10srigjphgvm8s9pfs7jg5hzghy14")))
+    (home-page "http://hackage.haskell.org/package/io-streams")
+    (synopsis "Simple and composable stream I/O")
+    (description "This library contains simple and easy-to-use
+primitives for I/O using streams.")
+    (license license:bsd-3)))
+
+(define-public ghc-io-streams-haproxy
+  (package
+    (name "ghc-io-streams-haproxy")
+    (version "1.0.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "io-streams-haproxy/io-streams-haproxy-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "11nh9q158mgnvvb23s5ffg87lkhl5smk039yl43jghxmb214z0bp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-io-streams" ,ghc-io-streams)
+       ("ghc-network" ,ghc-network)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (arguments
+     `(#:cabal-revision
+       ("4" "06c51a057n5bc9xfbp2m4jz5ds4z1xvmsx5mppch6qfwbz7x5i9l")))
+    (home-page "http://snapframework.com/")
+    (synopsis "HAProxy protocol 1.5 support for io-streams")
+    (description "HAProxy protocol version 1.5 support
+(see @uref{http://haproxy.1wt.eu/download/1.5/doc/proxy-protocol.txt})
+for applications using io-streams.  The proxy protocol allows information
+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-language-glsl
+  (package
+    (name "ghc-language-glsl")
+    (version "0.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "language-glsl/language-glsl-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0hdg67ainlqpjjghg3qin6fg4p783m0zmjqh4rd5gyizwiplxkp1"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-prettyclass" ,ghc-prettyclass)))
+    (arguments
+     `(#:tests? #f
+       #:cabal-revision
+       ("1" "10ac9pk4jy75k03j1ns4b5136l4kw8krr2d2nw2fdmpm5jzyghc5")))
+    (home-page "http://hackage.haskell.org/package/language-glsl")
+    (synopsis "GLSL abstract syntax tree, parser, and pretty-printer")
+    (description "This package is a Haskell library for the
+representation, parsing, and pretty-printing of GLSL 1.50 code.")
+    (license license:bsd-3)))
+
+(define-public ghc-prettyclass
+  (package
+    (name "ghc-prettyclass")
+    (version "1.0.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "prettyclass/prettyclass-" version ".tar.gz"))
+       (sha256
+        (base32
+         "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/prettyclass")
+    (synopsis "Pretty printing class similar to Show")
+    (description "This package provides a pretty printing class similar
+to @code{Show}, based on the HughesPJ pretty printing library.  It
+provides the pretty printing class and instances for the Prelude
+types.")
+    (license license:bsd-3)))
+
+(define-public ghc-readable
+  (package
+    (name "ghc-readable")
+    (version "0.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "readable/readable-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1ja39cg26wy2fs00gi12x7iq5k8i366pbqi3p916skfa5jnkfc3h"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/mightybyte/readable")
+    (synopsis "Type class for reading from Text and ByteString")
+    (description "This package provides a @code{Readable} type class for
+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-threads
+  (package
+    (name "ghc-threads")
+    (version "0.5.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "threads/threads-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0bjnjhnq3km6xqk0fn1fgyz5xdw4h6lylbwwbcmkkfzwcz0c76hk"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-concurrent-extra" ,ghc-concurrent-extra)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+    (home-page "https://github.com/basvandijk/threads")
+    (synopsis "Fork threads and wait for their result")
+    (description "This package provides functions to fork threads and
+wait for their result, whether it's an exception or a normal value.
+Besides waiting for the termination of a single thread this package also
+provides functions to wait for a group of threads to terminate.  This
+package is similar to the @code{threadmanager}, @code{async} and
+@code{spawn} packages.  The advantages of this package are:
+
+@itemize
+@item Simpler API.
+@item More efficient in both space and time.
+@item No space-leak when forking a large number of threads.
+@item Correct handling of asynchronous exceptions.
+@item GHC specific functionality like @code{forkOn} and
+@code{forkIOWithUnmask}.
+@end itemize")
+    (license license:bsd-3)))
+
+(define-public ghc-zlib-bindings
+  (package
+    (name "ghc-zlib-bindings")
+    (version "0.1.1.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "zlib-bindings/zlib-bindings-" version ".tar.gz"))
+       (sha256
+        (base32
+         "02ciywlz4wdlymgc3jsnicz9kzvymjw1www2163gxidnz4wb8fy8"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-zlib" ,ghc-zlib)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (arguments
+     `(#:cabal-revision
+       ("2" "0fq49694gqkab8m0vq4i879blswczwd66n7xh4r4gwiahf0ryvqc")))
+    (home-page "https://github.com/snapframework/zlib-bindings")
+    (synopsis "Low-level bindings to the @code{zlib} package")
+    (description "This package provides low-level bindings to the
+@code{zlib} package.")
+    (license license:bsd-3)))
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index bced44579d..8787f10789 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -73,6 +73,7 @@
   #:use-module ((guix licenses) #:prefix license:)
   #:use-module (guix packages)
   #:use-module (guix utils)
+  #:use-module (ice-9 match)
   #:use-module (ice-9 regex)
   #:use-module ((srfi srfi-1) #:select (alist-delete)))
 
@@ -440,7 +441,7 @@ interactive environment for the functional language Haskell.")
 interactive environment for the functional language Haskell.")
     (license license:bsd-3)))
 
-(define-public ghc-8
+(define-public ghc-8.4
   (package (inherit ghc-8.0)
     (name "ghc")
     (version "8.4.3")
@@ -572,6 +573,53 @@ interactive environment for the functional language Haskell.")
                                 (file-pattern ".*\\.conf\\.d$")
                                 (file-type 'directory))))))
 
+(define-public ghc-8.6
+  (package (inherit ghc-8.4)
+    (name "ghc")
+    (version "8.6.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://www.haskell.org/ghc/dist/"
+                           version "/" name "-" version "-src.tar.xz"))
+       (sha256
+        (base32 "0qg3zsmbk4rkwkc3jpas3zs74qaxmw4sp4v1mhsbj0a0dzls2jjd"))))
+    (native-inputs
+     `(;; GHC 8.6.5 must be built with GHC >= 8.2.
+       ("ghc-bootstrap" ,ghc-8.4)
+       ("ghc-testsuite"
+        ,(origin
+           (method url-fetch)
+           (uri (string-append
+                 "https://www.haskell.org/ghc/dist/"
+                 version "/" name "-" version "-testsuite.tar.xz"))
+           (sha256
+            (base32
+             "0pw9r91g2np3i806g2f4f8z4jfdd7mx226cmdizk4swa7av1qf91"))))
+       ,@(filter (match-lambda
+                   (("ghc-bootstrap" . _) #f)
+                   (("ghc-testsuite" . _) #f)
+                   (_ #t))
+                 (package-native-inputs ghc-8.4))))
+    (arguments
+     (substitute-keyword-arguments (package-arguments ghc-8.4)
+       ((#:make-flags make-flags ''())
+        `(cons "EXTRA_RUNTEST_OPTS=--skip-perf-tests"
+               ,make-flags))
+       ((#:phases phases '%standard-phases)
+        `(modify-phases ,phases
+           ;; These two tests refer to the root user, which doesn't exist
+           ;; (see <https://bugs.gnu.org/36692>).
+           (add-after 'unpack-testsuite 'skip-tests
+             (lambda _
+               (substitute* "libraries/unix/tests/all.T"
+                 (("^test\\('T8108'") "# guix skipped: test('T8108'"))
+               (substitute* "libraries/unix/tests/libposix/all.T"
+                 (("^test\\('posix010'") "# guix skipped: test('posix010'"))
+               #t))))))))
+
+(define-public ghc-8 ghc-8.4)
+
 (define-public ghc ghc-8)
 
 (define-public ghc-hostname
@@ -608,8 +656,7 @@ determine the hostname.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-old-time" ,ghc-old-time)
-       ("ghc-old-locale" ,ghc-old-locale)
-       ("ghc-text" ,ghc-text)))
+       ("ghc-old-locale" ,ghc-old-locale)))
     (home-page "https://hackage.haskell.org/package/convertible")
     (synopsis "Typeclasses and instances for converting between types")
     (description
@@ -634,7 +681,6 @@ function performs the conversion you desire.")
         (base32
          "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-text" ,ghc-text)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)
        ("ghc-test-framework" ,ghc-test-framework)
@@ -940,12 +986,10 @@ efficient memo functions using tries.")
        ("ghc-generics-sop" ,ghc-generics-sop)
        ("ghc-hashable" ,ghc-hashable)
        ("ghc-memotrie" ,ghc-memotrie)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-parsers" ,ghc-parsers)
        ("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-tagged" ,ghc-tagged)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-uuid-types" ,ghc-uuid-types)
        ("ghc-vector" ,ghc-vector)))
@@ -954,7 +998,6 @@ efficient memo functions using tries.")
        ("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
        ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-trifecta" ,ghc-trifecta)
        ("ghc-tasty" ,ghc-tasty)
        ("ghc-tasty-golden" ,ghc-tasty-golden)
@@ -1059,28 +1102,6 @@ the ‘haddock’ package.")
 documentation-generation tool for Haskell libraries.")
     (license license:bsd-3)))
 
-(define-public ghc-haddock-test
-  (package
-    (name "ghc-haddock-test")
-    (version "0.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "haddock-test/haddock-test-"
-                           version ".tar.gz"))
-       (sha256
-        (base32
-         "1ax8fnfrwx66csj952f3virxzapipan9da7z5l1zc12nqkifbs7w"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-xml" ,ghc-xml)
-       ("ghc-syb" ,ghc-syb)))
-    (home-page "http://www.haskell.org/haddock/")
-    (synopsis "Test utilities for Haddock")
-    (description "This package provides test utilities for Haddock.")
-    (license license:bsd-3)))
-
 (define-public ghc-haddock
   (package
     (name "ghc-haddock")
@@ -1255,8 +1276,7 @@ tool lex or flex for C/C++.")
                (("QuickCheck >= 2\\.8\\.1 && < 2\\.10")
                 "QuickCheck >= 2.8.1 && < 2.12")))))))
     (inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-exceptions" ,ghc-exceptions)
+     `(("ghc-exceptions" ,ghc-exceptions)
        ("ghc-multipart" ,ghc-multipart)
        ("ghc-network-uri" ,ghc-network-uri)
        ("ghc-network" ,ghc-network)))
@@ -1492,7 +1512,6 @@ specify refactorings without depending on GHC.")
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-yaml" ,ghc-yaml)
        ("ghc-vector" ,ghc-vector)
-       ("ghc-text" ,ghc-text)
        ("ghc-data-default" ,ghc-data-default)
        ("ghc-cmdargs" ,ghc-cmdargs)
        ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
@@ -1710,8 +1729,7 @@ arithmetic.")
     (inputs
      `(("ghc-half" ,ghc-half)
        ("ghc-fixed" ,ghc-fixed)
-       ("glu" ,glu)
-       ("ghc-text" ,ghc-text)))
+       ("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
@@ -1792,8 +1810,7 @@ basis for a nicer interface.")
          "19vxwvx2n8zq2klj176l25n2b64ybp0b8mhm4p46gvpcivz41fjc"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-objectname" ,ghc-objectname)
+     `(("ghc-objectname" ,ghc-objectname)
        ("ghc-gluraw" ,ghc-gluraw)
        ("ghc-statevar" ,ghc-statevar)
        ("ghc-openglraw" ,ghc-openglraw)))
@@ -1823,8 +1840,6 @@ version 1.3).")
        ("ghc-blaze-builder" ,ghc-blaze-builder)
        ("ghc-network" ,ghc-network)
        ("ghc-random" ,ghc-random)
-       ("ghc-stm" ,ghc-stm)
-       ("ghc-text" ,ghc-text)
        ("ghc-zlib" ,ghc-zlib)))
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)
@@ -2058,7 +2073,6 @@ MinTTY and other consoles.")
        ("ghc-ed25519" ,ghc-ed25519)
        ("ghc-network" ,ghc-network)
        ("ghc-network-uri" ,ghc-network-uri)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-tar" ,ghc-tar)
        ("ghc-zlib" ,ghc-zlib)))
     (native-inputs
@@ -2138,7 +2152,6 @@ Unix systems.")
       ("ghc-network" ,ghc-network)
       ("ghc-random" ,ghc-random)
       ("ghc-resolv" ,ghc-resolv)
-      ("ghc-stm" ,ghc-stm)
       ("ghc-tar" ,ghc-tar)
       ("ghc-zlib" ,ghc-zlib)))
    (home-page "https://www.haskell.org/cabal/")
@@ -2186,8 +2199,6 @@ configuration.  This library provides the common bits for writing custom
        (sha256
         (base32 "1gzy4v3r02kvdxvgg1nj83mmb6aph2v4ilf9c7y6nbvi2x49l0bp"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-parsec" ,ghc-parsec)))
     (home-page "https://hackage.haskell.org/package/parsec-numbers")
     (synopsis "Utilities for parsing numbers from strings")
     (description
@@ -2401,34 +2412,6 @@ 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-stm
-  (package
-    (name "ghc-stm")
-    (version "2.4.5.0")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/stm/stm-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "19sr11a0hqikhvf561b38phz6k3zg9s157a0f5ffvghk7wcdpmri"))))
-    (build-system haskell-build-system)
-    (home-page "https://hackage.haskell.org/package/stm")
-    (synopsis "Software Transactional Memory")
-    (description
-     "Software Transactional Memory, or STM, is an abstraction for concurrent
-communication.  The main benefits of STM are composability and modularity.
-That is, using STM you can write concurrent abstractions that can be easily
-composed with any other abstraction built using STM, without exposing the
-details of how your abstraction ensures safety.  This is typically not the
-case with other forms of concurrent communication, such as locks or
-@code{MVar}s.")
-    (license license:bsd-3)))
-
 (define-public ghc-parallel
   (package
     (name "ghc-parallel")
@@ -2464,8 +2447,6 @@ case with other forms of concurrent communication, such as locks or
         (base32
          "0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-stm" ,ghc-stm)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)))
     (home-page "https://github.com/ChrisKuklewicz/SafeSemaphore")
@@ -2475,38 +2456,6 @@ 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-text
-  (package
-    (name "ghc-text")
-    (version "1.2.3.0")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/text/text-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "06iir7q99rnffzxi8gagn8w1k9m49368sbidgz634fv1gxib3q10"))))
-    (build-system haskell-build-system)
-    ;; The test dependencies depend on ghc-text: ghc-test-framework -> ghc-xml -> ghc-text
-    (arguments `(#:tests? #f))
-    (inputs
-     `(("ghc-random" ,ghc-random)))
-    (home-page "https://github.com/bos/text")
-    (synopsis "Efficient packed Unicode text type library")
-    (description
-     "An efficient packed, immutable Unicode text type (both strict and
-lazy), with a powerful loop fusion optimization framework.
-
-The @code{Text} type represents Unicode character strings, in a time and
-space-efficient manner.  This package provides text processing
-capabilities that are optimized for performance critical use, both
-in terms of large data quantities and high speed.")
-    (license license:bsd-3)))
-
 (define-public ghc-text-binary
   (package
     (name "ghc-text-binary")
@@ -2521,7 +2470,6 @@ in terms of large data quantities and high speed.")
         (base32
          "18gl10pwg3qwsk0za3c70j4n6a9129wwf1b7d3a461h816yv55xn"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-text" ,ghc-text)))
     (home-page "https://github.com/kawu/text-binary")
     (synopsis "Binary instances for text types")
     (description
@@ -2567,8 +2515,7 @@ IO operations.")
          "1gra8gq3kb7b2sd845h55yxlrfqx3ii004c6vjhga8v0b30fzdgc"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-random" ,ghc-random)))
+     `(("ghc-random" ,ghc-random)))
     (native-inputs
      `(("ghc-test-framework" ,ghc-test-framework)
        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
@@ -2750,8 +2697,7 @@ Hashing\" by Claessen, Pałka for details and the rationale of the design.")
          "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+     `(("ghc-transformers-compat" ,ghc-transformers-compat)))
     (home-page
      "https://hackage.haskell.org/package/transformers-compat")
     (synopsis
@@ -2851,8 +2797,7 @@ isn't available, portable implementations are used.")
     ;; This package needs an older version of tasty.
     (arguments '(#:tests? #f))
     (inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-concatenative" ,ghc-concatenative)))
+     `(("ghc-concatenative" ,ghc-concatenative)))
     (native-inputs
      `(("ghc-tasty" ,ghc-tasty)
        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
@@ -2984,31 +2929,6 @@ Haskell library @code{regex-base}.")
 @code{regex-posix} to replace @code{Text.Regex}.")
     (license license:bsd-3)))
 
-(define-public ghc-regex-tdfa-rc
-  (package
-    (name "ghc-regex-tdfa-rc")
-    (version "1.1.8.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-regex-base" ,ghc-regex-base)
-       ("ghc-parsec" ,ghc-parsec)))
-    (home-page
-     "https://hackage.haskell.org/package/regex-tdfa")
-    (synopsis "Tagged DFA regex engine for Haskell")
-    (description "A new all-Haskell \"tagged\" DFA regex engine, inspired by
-@code{libtre} (fork by Roman Cheplyaka).")
-    (license license:bsd-3)))
-
 (define-public ghc-regex-tdfa-text
   (package
     (name "ghc-regex-tdfa-text")
@@ -3024,8 +2944,7 @@ Haskell library @code{regex-base}.")
          "0090g6lgbdm9lywpqm2d3724nnnh24nx3vnlqr96qc2w486pmmrq"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-regex-base" ,ghc-regex-base)
+     `(("ghc-regex-base" ,ghc-regex-base)
        ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
     (home-page
      "http://hackage.haskell.org/package/regex-tdfa-text")
@@ -3065,7 +2984,6 @@ Haskell library @code{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-text" ,ghc-text)
        ("ghc-time-locale-compat" ,ghc-time-locale-compat)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-utf8-string" ,ghc-utf8-string)))
@@ -3100,10 +3018,8 @@ copious examples.")
     (inputs
      `(("ghc-base-orphans" ,ghc-base-orphans)
        ("ghc-attoparsec" ,ghc-attoparsec)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-charset" ,ghc-charset)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)))
     (home-page "https://github.com/ekmett/parsers/")
     (synopsis "Parsing combinators")
@@ -3127,6 +3043,7 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
                (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)
@@ -3204,8 +3121,7 @@ with slicing and Clang-style colored diagnostics.")
                ((", testProperty \"satisfyWith\" satisfyWith")
                 "")))))))
     (inputs
-     `(("ghc-scientific" ,ghc-scientific)
-       ("ghc-text" ,ghc-text)))
+     `(("ghc-scientific" ,ghc-scientific)))
     (native-inputs
      `(("ghc-tasty" ,ghc-tasty)
        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
@@ -3225,8 +3141,7 @@ complicated text/binary file formats.")
     (name "ghc-attoparsec-bootstrap")
     (arguments `(#:tests? #f))
     (inputs
-     `(("ghc-scientific" ,ghc-scientific-bootstrap)
-       ("ghc-text" ,ghc-text)))
+     `(("ghc-scientific" ,ghc-scientific-bootstrap)))
     (native-inputs '())
     (properties '(hidden? #t))))
 
@@ -3248,7 +3163,6 @@ complicated text/binary file formats.")
     (inputs
      `(("ghc-digest" ,ghc-digest)
        ("ghc-temporary" ,ghc-temporary)
-       ("ghc-text" ,ghc-text)
        ("ghc-zlib" ,ghc-zlib)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)
@@ -3389,8 +3303,6 @@ and mIRC chat codes.")
         (base32
          "05dya1vdvq29hkhkdlsglzhw7bdn51rvs1javs0q75nf99c66k7m"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-text" ,ghc-text)))
     (home-page
      "http://code.haskell.org/~malcolm/polyparse/")
     (synopsis
@@ -3479,7 +3391,6 @@ this package makes them available back to GHC 7.2.")
     (inputs
      `(("ghc-fingertree" ,ghc-fingertree)
        ("ghc-hashable" ,ghc-hashable)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-semigroupoids" ,ghc-semigroupoids)
        ("ghc-semigroups" ,ghc-semigroups)))
@@ -3627,8 +3538,6 @@ online}.")
         (base32
          "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-text" ,ghc-text)))
     (home-page "http://code.galois.com")
     (synopsis "Simple XML library for Haskell")
     (description "This package provides a simple XML library for Haskell.")
@@ -3655,7 +3564,6 @@ online}.")
        ("ghc-old-locale" ,ghc-old-locale)
        ("ghc-old-time" ,ghc-old-time)
        ("ghc-safe" ,ghc-safe)
-       ("ghc-text" ,ghc-text)
        ("ghc-time-locale-compat" ,ghc-time-locale-compat)
        ("ghc-utf8-string" ,ghc-utf8-string)
        ("ghc-xml-conduit" ,ghc-xml-conduit)
@@ -3691,8 +3599,7 @@ consuming feeds in both RSS (Really Simple Syndication) and Atom format.")
        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
     (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+     `(("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
@@ -3826,8 +3733,7 @@ writing to stdout and other handles.")
     (build-system haskell-build-system)
     ;; these inputs are necessary to use this library
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-hashable" ,ghc-hashable)))
+     `(("ghc-hashable" ,ghc-hashable)))
     (arguments
      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
     (home-page
@@ -4087,7 +3993,7 @@ instances of the @code{Pretty} class.")
          "0gnb4mkqryv08vncxnj0bzwcnd749613yw3cxfzw6y3nsldp4c56"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-ansi-terminal" ,ghc-ansi-terminal-0.8)))
+     `(("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
@@ -4120,36 +4026,6 @@ splitting lists into parts, akin to the @code{split} function found in several
 mainstream languages.")
     (license license:bsd-3)))
 
-(define-public ghc-parsec
-  (package
-    (name "ghc-parsec")
-    (version "3.1.13.0")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/parsec/parsec-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32 "1wc09pyn70p8z6llink10c8pqbh6ikyk554911yfwxv1g91swqbq"))))
-    (build-system haskell-build-system)
-    (native-inputs
-     `(("ghc-hunit" ,ghc-hunit)))
-    (inputs
-     `(("ghc-text" ,ghc-text)))
-    (arguments
-     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
-    (home-page
-     "https://github.com/aslatter/parsec")
-    (synopsis "Monadic parser combinators")
-    (description "Parsec is a parser library.  It is simple, safe, well
-documented, has extensive libraries, good error messages, and is fast.  It is
-defined as a monad transformer that can be stacked on arbitrary monads, and it
-is also parametric in the input stream type.")
-    (license license:bsd-3)))
-
 (define-public ghc-parser-combinators
   (package
     (name "ghc-parser-combinators")
@@ -4191,8 +4067,7 @@ combinators.")
     (inputs
      `(("ghc-case-insensitive" ,ghc-case-insensitive)
        ("ghc-parser-combinators" ,ghc-parser-combinators)
-       ("ghc-scientific" ,ghc-scientific)
-       ("ghc-text" ,ghc-text)))
+       ("ghc-scientific" ,ghc-scientific)))
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-hspec" ,ghc-hspec)
@@ -4348,11 +4223,10 @@ interface.")
     (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)))
-    (inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-network" ,ghc-network)))
     (home-page
      "https://github.com/haskell/network-uri")
     (synopsis "Library for URI manipulation")
@@ -4364,7 +4238,7 @@ interface.")
 (define-public ghc-ansi-terminal
   (package
     (name "ghc-ansi-terminal")
-    (version "0.9.1")
+    (version "0.8.0.4")
     (source
      (origin
        (method url-fetch)
@@ -4374,7 +4248,7 @@ interface.")
              ".tar.gz"))
        (sha256
         (base32
-         "1yr0ld0kqns3w3j9gl62bdwshvyazidx4dv1qkvq19ivnf08w23l"))))
+         "0428gq8m3fdnb7ldcsyk97qcch76hcxbgh2666p6f76fs2qbhg7b"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-colour" ,ghc-colour)))
@@ -4385,21 +4259,6 @@ allows cursor movement, screen clearing, color output showing or hiding the
 cursor, and changing the title.")
     (license license:bsd-3)))
 
-(define-public ghc-ansi-terminal-0.8
-  (package (inherit ghc-ansi-terminal)
-           (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"))))))
-
 (define-public ghc-vault
   (package
     (name "ghc-vault")
@@ -4536,8 +4395,7 @@ monads with anaphoric variants on @code{if} and @code{when} and a C-like
          "1c92833gr6cadidjdp8mlznkpp8lyxl0w3y7d19y8yi3klc3843c"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-transformers-base" ,ghc-transformers-base)
+     `(("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
@@ -4659,8 +4517,7 @@ pragmas in your code.")
     (build-system haskell-build-system)
     (arguments `(#:tests? #f))          ; FIXME: Missing test libraries.
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-utf8-string" ,ghc-utf8-string)))
+     `(("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
@@ -4693,8 +4550,7 @@ interoperate with code that uses the new implementation.")
                (("tasty            >= 1\\.0  && < 1\\.1")
                 "tasty            >= 1.0  && < 1.2")))))))
     (inputs
-     `(("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-text" ,ghc-text)))
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)
        ("ghc-quickcheck" ,ghc-quickcheck)
@@ -4744,8 +4600,7 @@ library for Haskell.")
          "09whscli1q5z7lzyq9rfk0bq1ydplh6pjmc6qv0x668k5818c2wg"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-hashable" ,ghc-hashable)
+     `(("ghc-hashable" ,ghc-hashable)
        ("ghc-hunit" ,ghc-hunit)
        ("ghc-test-framework" ,ghc-test-framework)
        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
@@ -5063,7 +4918,6 @@ given term should not exist.")
        ("ghc-profunctors" ,ghc-profunctors)
        ("ghc-semigroups" ,ghc-semigroups)
        ("ghc-statevar" ,ghc-statevar)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-tagged" ,ghc-tagged)
        ("ghc-th-abstraction" ,ghc-th-abstraction)
        ("ghc-transformers-compat" ,ghc-transformers-compat)
@@ -5155,8 +5009,6 @@ call stacks with different versions of the compiler.")
         (base32
          "08r2iw0gdmfs4f6wraaq19vfmkjdbics3dbhw39y7mdjd98kcr7b"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-stm" ,ghc-stm)))
     (home-page "https://hackage.haskell.org/package/StateVar")
     (synopsis "State variables for Haskell")
     (description "This package provides state variables, which are references
@@ -5197,7 +5049,6 @@ in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
        ("ghc-profunctors" ,ghc-profunctors)
        ("ghc-semigroups" ,ghc-semigroups)
        ("ghc-tagged" ,ghc-tagged)
-       ("ghc-text" ,ghc-text)
        ("ghc-transformers-compat" ,ghc-transformers-compat)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-void" ,ghc-void)
@@ -5238,8 +5089,7 @@ indexed variants.")
          "1hiqi7h76shjzs2zj0j8g6wnq2hbiq1hmfafdazr97fba2zl2432"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-blaze-html" ,ghc-blaze-html)
+     `(("ghc-blaze-html" ,ghc-blaze-html)
        ("ghc-xss-sanitize" ,ghc-xss-sanitize)
        ("ghc-data-default" ,ghc-data-default)
        ("ghc-syb" ,ghc-syb)
@@ -5373,7 +5223,6 @@ just a @code{Semigroup} are added.")
      `(("ghc-nats" ,ghc-nats)
        ("ghc-tagged" ,ghc-tagged)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
-       ("ghc-text" ,ghc-text)
        ("ghc-hashable" ,ghc-hashable)))
     (home-page "https://github.com/ekmett/semigroups/")
     (synopsis "Semigroup operations for Haskell")
@@ -5394,7 +5243,6 @@ semigroup.")
      `(("ghc-nats" ,ghc-nats-bootstrap)
        ("ghc-tagged" ,ghc-tagged)
        ("ghc-unordered-containers" ,ghc-unordered-containers-bootstrap)
-       ("ghc-text" ,ghc-text)
        ("ghc-hashable" ,ghc-hashable-bootstrap)))
     (properties '(hidden? #t))))
 
@@ -5517,7 +5365,6 @@ monad transformer (instead of the IO monad).")
     (inputs
      `(("ghc-auto-update" ,ghc-auto-update)
        ("ghc-easy-file" ,ghc-easy-file)
-       ("ghc-text" ,ghc-text)
        ("ghc-unix-time" ,ghc-unix-time)))
     (native-inputs
      `(("hspec-discover" ,hspec-discover)
@@ -5703,7 +5550,6 @@ in migrated modules.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-integer-logarithms" ,ghc-integer-logarithms)
-       ("ghc-text" ,ghc-text)
        ("ghc-hashable" ,ghc-hashable)
        ("ghc-primitive" ,ghc-primitive)))
     (native-inputs
@@ -5730,7 +5576,6 @@ notation}.")
     (arguments `(#:tests? #f))
     (inputs
      `(("ghc-integer-logarithms" ,ghc-integer-logarithms-bootstrap)
-       ("ghc-text" ,ghc-text)
        ("ghc-hashable" ,ghc-hashable)
        ("ghc-primitive" ,ghc-primitive)))
     (native-inputs '())
@@ -5859,7 +5704,6 @@ building up, manipulating and serialising @code{Pandoc} structures.")
        ("ghc-temporary" ,ghc-temporary)
        ("ghc-utf8-string" ,ghc-utf8-string)
        ("ghc-xml" ,ghc-xml)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-pandoc-types" ,ghc-pandoc-types)))
     (home-page "https://github.com/jgm/texmath")
     (synopsis "Conversion between formats used to represent mathematics")
@@ -5935,8 +5779,7 @@ and utilities for pretty printing.")
      `(("ghc-diff" ,ghc-diff)
        ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
     (native-inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-blaze-html" ,ghc-blaze-html)
+     `(("ghc-blaze-html" ,ghc-blaze-html)
        ("ghc-utf8-string" ,ghc-utf8-string)))
     (home-page "https://github.com/jgm/highlighting-kate")
     (synopsis "Syntax highlighting library")
@@ -5963,8 +5806,6 @@ descriptions.")
                (base32
                 "1c1j3a8b9qx5zk9myqm3gap8ymz7fipwrdmyfsq9wkkdr9x4np45"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-text" ,ghc-text)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)))
     (home-page "https://github.com/jgm/commonmark-hs")
@@ -5990,8 +5831,6 @@ sources, and does not require prior installation of the C library.")
         (base32
          "13b0mqks5c1q989slgsa3ixr5vvkfyic4ynzgv00kgl5qrs7hqk7"))))
     (build-system haskell-build-system)
-    (inputs
-     `(("ghc-text" ,ghc-text)))
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)))
     (home-page "https://github.com/kivikakk/cmark-gfm-hs")
@@ -6058,35 +5897,6 @@ within an enclosed computation, while remaining responsive to (external)
 asynchronous exceptions.")
     (license license:expat)))
 
-(define-public ghc-packedstring
-  (package
-    (name "ghc-packedstring")
-    (version "0.1.0.1")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "packedstring/packedstring-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8"))))
-    (build-system haskell-build-system)
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'enable-extension
-          (lambda _
-            ;; This package won't compile without the StandaloneDeriving
-            ;; extension.
-            (substitute* "packedstring.cabal"
-              (("CPP") "CPP, StandaloneDeriving"))
-            #t)))))
-    (home-page "https://hackage.haskell.org/package/packedstring")
-    (synopsis "Library for packed strings")
-    (description
-     "This deprecated library provides an implementation of packed strings.")
-    (license license:bsd-3)))
-
 (define-public ghc-th-abstraction
   (package
     (name "ghc-th-abstraction")
@@ -6148,7 +5958,6 @@ datatypes.")
     (inputs
      `(("ghc-th-lift" ,ghc-th-lift)
        ("ghc-vector" ,ghc-vector)
-       ("ghc-text" ,ghc-text)
        ("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "https://github.com/bennofs/th-lift-instances/")
     (synopsis "Lift instances for template-haskell for common data types.")
@@ -6402,13 +6211,15 @@ back-ends.")
                (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-text" ,ghc-text)
        ("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-semigroups" ,ghc-semigroups)
@@ -6511,8 +6322,7 @@ TIFF and GIF formats.")
     (inputs
      `(("lua" ,lua)
        ("ghc-exceptions" ,ghc-exceptions)
-       ("ghc-fail" ,ghc-fail)
-       ("ghc-text" ,ghc-text)))
+       ("ghc-fail" ,ghc-fail)))
     (native-inputs
      `(("ghc-tasty" ,ghc-tasty)
        ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
@@ -6545,8 +6355,7 @@ described in @url{https://www.lua.org/}.")
      `(#:cabal-revision
        ("1" "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n")))
     (inputs
-     `(("ghc-hslua" ,ghc-hslua)
-       ("ghc-text" ,ghc-text)))
+     `(("ghc-hslua" ,ghc-hslua)))
     (native-inputs
      `(("ghc-tasty" ,ghc-tasty)
        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
@@ -6744,7 +6553,6 @@ the choice of SSL/TLS, and SOCKS.")
        ("ghc-hxt" ,ghc-hxt)
        ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
        ("ghc-safe" ,ghc-safe)
-       ("ghc-text" ,ghc-text)
        ("ghc-utf8-string" ,ghc-utf8-string)))
     (native-inputs
      `(("ghc-diff" ,ghc-diff)
@@ -6798,9 +6606,7 @@ provided.  Skylighting is intended to be the successor to highlighting-kate.")
      `(("ghc-aeson" ,ghc-aeson)
        ("ghc-blaze-markup" ,ghc-blaze-markup)
        ("ghc-blaze-html" ,ghc-blaze-html)
-       ("ghc-text" ,ghc-text)
        ("ghc-vector" ,ghc-vector)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-scientific" ,ghc-scientific)))
     (native-inputs
@@ -6863,7 +6669,6 @@ provided.  Skylighting is intended to be the successor to highlighting-kate.")
        ("ghc-network-uri" ,ghc-network-uri)
        ("ghc-old-locale" ,ghc-old-locale)
        ("ghc-pandoc-types" ,ghc-pandoc-types)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-random" ,ghc-random)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-sha" ,ghc-sha)
@@ -6873,7 +6678,6 @@ provided.  Skylighting is intended to be the successor to highlighting-kate.")
        ("ghc-tagsoup" ,ghc-tagsoup)
        ("ghc-temporary" ,ghc-temporary)
        ("ghc-texmath" ,ghc-texmath)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-vector" ,ghc-vector)
        ("ghc-xml" ,ghc-xml)
@@ -6961,8 +6765,7 @@ better for some purposes.")
          "0j36vrc9w841m5qbwqra1lwiznx31xfnhin1sm8x2c2739csbpn0"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-async" ,ghc-async)
-       ("ghc-stm" ,ghc-stm)))
+     `(("ghc-async" ,ghc-async)))
     (native-inputs
      `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
        ("ghc-hspec" ,ghc-hspec)
@@ -6994,7 +6797,6 @@ upon it.")
      `(("ghc-conduit" ,ghc-conduit)
        ("ghc-exceptions" ,ghc-exceptions)
        ("ghc-monad-control" ,ghc-monad-control)
-       ("ghc-text" ,ghc-text)
        ("ghc-transformers-base" ,ghc-transformers-base)
        ("ghc-typed-process" ,ghc-typed-process)
        ("ghc-async" ,ghc-async)
@@ -7003,7 +6805,6 @@ upon it.")
        ("ghc-network" ,ghc-network)
        ("ghc-primitive" ,ghc-primitive)
        ("ghc-resourcet" ,ghc-resourcet)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-streaming-commons" ,ghc-streaming-commons)
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-bytestring-builder" ,ghc-bytestring-builder)
@@ -7033,7 +6834,6 @@ dependencies.  The basic idea is that this package should only depend on
         (base32
          "1jgqxsa9p2q3h6nymbfmvhldqrqlwrhrzmwadlyc0li50x0d8dwr"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-text" ,ghc-text)))
     (home-page "https://john-millikin.com/software/haskell-xml/")
     (synopsis "Basic types for representing XML")
     (description "This package provides basic types for representing XML
@@ -7058,7 +6858,6 @@ documents.")
        ("ghc-conduit-extra" ,ghc-conduit-extra)
        ("ghc-doctest" ,ghc-doctest)
        ("ghc-resourcet" ,ghc-resourcet)
-       ("ghc-text" ,ghc-text)
        ("ghc-xml-types" ,ghc-xml-types)
        ("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-data-default-class" ,ghc-data-default-class)
@@ -7107,7 +6906,6 @@ the @code{conduit} package.")
        ("ghc-pandoc" ,ghc-pandoc)
        ("ghc-tagsoup" ,ghc-tagsoup)
        ("ghc-aeson" ,ghc-aeson)
-       ("ghc-text" ,ghc-text)
        ("ghc-vector" ,ghc-vector)
        ("ghc-xml-conduit" ,ghc-xml-conduit)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
@@ -7118,7 +6916,6 @@ the @code{conduit} package.")
        ("ghc-hs-bibutils" ,ghc-hs-bibutils)
        ("ghc-rfc5051" ,ghc-rfc5051)
        ("ghc-syb" ,ghc-syb)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-old-locale" ,ghc-old-locale)
        ("ghc-aeson-pretty" ,ghc-aeson-pretty)
        ("ghc-attoparsec" ,ghc-attoparsec)
@@ -7242,8 +7039,7 @@ regular expressions.  Parsers can be built using Applicative interface.")
          "0l7ajnh4hpgggf2a1r9dg0hx2fy679vd2kada5y7r02hy3nfxala"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-parsec" ,ghc-parsec)
-       ("ghc-regex-base" ,ghc-regex-base)))
+     `(("ghc-regex-base" ,ghc-regex-base)))
     (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
     (synopsis "POSIX extended regular expressions in Haskell.")
     (description
@@ -7504,8 +7300,7 @@ supported.  A module of colour names (\"Data.Colour.Names\") is provided.")
          "0g3w92rad6x5appfb22rbzcas2ix2h0hy91sdxhq8a4a5cnlrpa0"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-base-compat" ,ghc-base-compat)
-       ("ghc-text" ,ghc-text)))
+     `(("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
@@ -7569,7 +7364,6 @@ for generating graph-like data structures.")
        ("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
        ("ghc-polyparse" ,ghc-polyparse)
        ("ghc-temporary" ,ghc-temporary)
-       ("ghc-text" ,ghc-text)
        ("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)
@@ -7677,8 +7471,7 @@ instance of @code{MonadBase} or @code{MonadBaseControl}.")
     (arguments
      `(#:tests? #f))
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "https://github.com/fpco/haskell-filesystem")
     (synopsis "High-level, byte-based file and directory path manipulations")
     (description
@@ -7707,7 +7500,6 @@ increasing type safety.")
      `(#:tests? #f))
     (inputs
      `(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
-       ("ghc-text" ,ghc-text)
        ("ghc-temporary" ,ghc-temporary)))
     (home-page "https://github.com/fpco/haskell-filesystem")
     (synopsis "Consistent file system interaction across GHC versions")
@@ -7742,7 +7534,6 @@ which can't be decoded in the current locale encoding.")
        ("ghc-lifted-async" ,ghc-lifted-async)
        ("ghc-exceptions" ,ghc-exceptions)
        ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
-       ("ghc-text" ,ghc-text)
        ("ghc-async" ,ghc-async)
        ("ghc-transformers-base" ,ghc-transformers-base)
        ("ghc-hunit" ,ghc-hunit)
@@ -7799,7 +7590,6 @@ easily work with command-line options.")
      `(("ghc-options-bootstrap" ,ghc-options-bootstrap)
        ("ghc-patience" ,ghc-patience)
        ("ghc-random" ,ghc-random)
-       ("ghc-text" ,ghc-text)
        ("ghc-ansi-terminal" ,ghc-ansi-terminal)))
     (home-page "https://john-millikin.com/software/chell/")
     (synopsis "Simple and intuitive library for automated testing")
@@ -7920,8 +7710,7 @@ easily work with command-line options.")
     ;; 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-text" ,ghc-text)
-       ("ghc-chell" ,ghc-chell)
+     `(("ghc-chell" ,ghc-chell)
        ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
        ("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "https://github.com/fpco/haskell-filesystem")
@@ -7948,7 +7737,6 @@ increasing type safety.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-system-filepath" ,ghc-system-filepath)
-       ("ghc-text" ,ghc-text)
        ("ghc-chell" ,ghc-chell)
        ("ghc-temporary" ,ghc-temporary)))
     (home-page "https://github.com/fpco/haskell-filesystem")
@@ -8265,8 +8053,7 @@ accessed or modified.")
                 "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-async" ,ghc-async)
+     `(("ghc-async" ,ghc-async)
        ("ghc-unix-compat" ,ghc-unix-compat)
        ("ghc-hinotify" ,ghc-hinotify)
        ("ghc-tasty" ,ghc-tasty)
@@ -8498,9 +8285,7 @@ handled safely, this is what you're left with.")
          "13kkfgx58z18jphbg56jn08jn72wi3kvfndlwwx87hqwg7x1dfz6"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-syb" ,ghc-syb)
-       ("ghc-text" ,ghc-text)
-       ("ghc-parsec" ,ghc-parsec)))
+     `(("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
@@ -8558,7 +8343,6 @@ JSON (JavaScript Object Notation) is a lightweight data-interchange format.")
          ("ghc-persistent" ,ghc-persistent)
          ("ghc-resourcet" ,ghc-resourcet)
          ("ghc-tagged" ,ghc-tagged)
-         ("ghc-text" ,ghc-text)
          ("ghc-unliftio" ,ghc-unliftio)
          ("ghc-unordered-containers" ,ghc-unordered-containers)))
       (native-inputs
@@ -8592,7 +8376,6 @@ generated SQL and optimize it for your backend.")
     (inputs
      `(("ghc-aeson" ,ghc-aeson)
        ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
     (home-page "https://github.com/koalaman/shellcheck")
     (synopsis "Static analysis for shell scripts")
@@ -8769,7 +8552,6 @@ matching patterns against file paths.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-exceptions" ,ghc-exceptions)
-       ("ghc-text" ,ghc-text)
        ("ghc-transformers-compat" ,ghc-transformers-compat)
        ("ghc-unexceptionalio" ,ghc-unexceptionalio)
        ("ghc-safe" ,ghc-safe)))
@@ -9141,8 +8923,7 @@ and regression and autocorrelation analysis.
          "16m7y7fwrirbjbqqcsfmr4yxa9qvfax6r7pw0zl9ky71ms0wa47p"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-vector" ,ghc-vector)
-              ("ghc-semigroups" ,ghc-semigroups)
-              ("ghc-text" ,ghc-text)))
+              ("ghc-semigroups" ,ghc-semigroups)))
     (home-page "https://github.com/snoyberg/mono-traversable")
     (synopsis "Typeclasses for dealing with various chunked data
 representations for Haskell")
@@ -9355,8 +9136,7 @@ IPv4, IPv6 and MAC addresses.")
                (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit")
                (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
     (inputs `(("ghc-hashable" ,ghc-hashable)
-              ("ghc-random" ,ghc-random)
-              ("ghc-text" ,ghc-text)))
+              ("ghc-random" ,ghc-random)))
     (native-inputs `(("ghc-hunit" ,ghc-hunit)
                      ("ghc-quickcheck" ,ghc-quickcheck)
                      ("ghc-tasty" ,ghc-tasty)
@@ -9402,7 +9182,6 @@ functions.")
               ("ghc-entropy" ,ghc-entropy)
               ("ghc-network-info" ,ghc-network-info)
               ("ghc-random" ,ghc-random)
-              ("ghc-text" ,ghc-text)
               ("ghc-uuid-types" ,ghc-uuid-types)))
     (native-inputs `(("ghc-hunit" ,ghc-hunit)
                      ("ghc-quickcheck" ,ghc-quickcheck)
@@ -9429,11 +9208,9 @@ parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.")
         (base32
          "1gah2qwfpzwamnikbc5h4nv6dgvv9h16di9ka7946za3nibyasya"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-stm" ,ghc-stm)
-              ("ghc-hashable" ,ghc-hashable)
+    (inputs `(("ghc-hashable" ,ghc-hashable)
               ("ghc-vector" ,ghc-vector)
               ("ghc-unordered-containers" ,ghc-unordered-containers)
-              ("ghc-text" ,ghc-text)
               ("ghc-scientific" ,ghc-scientific)
               ("ghc-uuid" ,ghc-uuid)
               ("ghc-dlist" ,ghc-dlist)
@@ -9546,7 +9323,6 @@ vector. ")
     (build-system haskell-build-system)
     (inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
               ("ghc-primitive" ,ghc-primitive)
-              ("ghc-text" ,ghc-text)
               ("ghc-vector" ,ghc-vector)
               ("ghc-unordered-containers" ,ghc-unordered-containers)
               ("ghc-hashable" ,ghc-hashable)
@@ -9580,7 +9356,6 @@ and are often as efficient as hand-written folds.")
     (build-system haskell-build-system)
     (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
               ("ghc-hashable" ,ghc-hashable)
-              ("ghc-text" ,ghc-text)
               ("ghc-vector" ,ghc-vector)
               ("ghc-vector-algorithms" ,ghc-vector-algorithms)
               ("ghc-split" ,ghc-split)))
@@ -9618,7 +9393,6 @@ data structures as non-empty.")
               ("ghc-transformers-base" ,ghc-transformers-base)
               ("ghc-primitive" ,ghc-primitive)
               ("ghc-vector" ,ghc-vector)
-              ("ghc-text" ,ghc-text)
               ("ghc-void" ,ghc-void)
               ("ghc-mwc-random" ,ghc-mwc-random)
               ("ghc-unix-compat" ,ghc-unix-compat)
@@ -9674,7 +9448,6 @@ as well as a convenient Conduit module.")
        ("ghc-safe" ,ghc-safe)
        ("ghc-scientific" ,ghc-scientific)
        ("ghc-tagged" ,ghc-tagged)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-utf8-string" ,ghc-utf8-string)
        ("ghc-vector" ,ghc-vector)
@@ -9765,7 +9538,6 @@ Foundation has the following goals:
         (base32
          "0f27sp09yha43xk9q55sc185jyjs5h7gq2dhsyx6bm9kz9dzqi13"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-stm" ,ghc-stm)))
     (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,
@@ -9810,8 +9582,6 @@ operators for looping.")
          "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
-              ("ghc-text" ,ghc-text)
-              ("ghc-stm" ,ghc-stm)
               ("ghc-stm-chans" ,ghc-stm-chans)
               ("ghc-lifted-base" ,ghc-lifted-base)
               ("ghc-resourcet" ,ghc-resourcet)
@@ -9846,9 +9616,7 @@ code locations of messages.")
         (base32
          "1vk4b19zvwy4mpwaq9z3l3kfmz75gfyf7alhh0y112gspgpccm23"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-parsec" ,ghc-parsec)
-              ("ghc-text" ,ghc-text)
-              ("ghc-aeson" ,ghc-aeson)
+    (inputs `(("ghc-aeson" ,ghc-aeson)
               ("ghc-blaze-markup" ,ghc-blaze-markup)
               ("ghc-blaze-html" ,ghc-blaze-html)
               ("ghc-exceptions" ,ghc-exceptions)
@@ -9906,7 +9674,6 @@ a memory chunk that will be auto-scrubbed after it run out of scope.")
     (inputs `(("ghc-hashable" ,ghc-hashable)
               ("ghc-monad-control" ,ghc-monad-control)
               ("ghc-transformers-base" ,ghc-transformers-base)
-              ("ghc-stm" ,ghc-stm)
               ("ghc-vector" ,ghc-vector)))
     (home-page "https://github.com/bos/pool")
     (synopsis "Striped resource pooling implementation in Haskell")
@@ -9933,8 +9700,7 @@ connections.")
      `(#:cabal-revision
        ("1" "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4")))
     (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
-              ("ghc-base-compat" ,ghc-base-compat)
-              ("ghc-text" ,ghc-text)))
+              ("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
@@ -10017,7 +9783,6 @@ parser that uses ByteStrings for parsing and representing the URI data.")
               ("ghc-attoparsec-iso8601" ,ghc-attoparsec-iso8601)
               ("ghc-hashable" ,ghc-hashable)
               ("ghc-http-types" ,ghc-http-types)
-              ("ghc-text" ,ghc-text)
               ("ghc-time-locale-compat" ,ghc-time-locale-compat)
               ("ghc-unordered-containers" ,ghc-unordered-containers)
               ("ghc-uri-bytestring" ,ghc-uri-bytestring)
@@ -10044,7 +9809,6 @@ Haskell data types to and from HTTP API data.")
          "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-old-locale" ,ghc-old-locale)
-              ("ghc-text" ,ghc-text)
               ("ghc-conduit" ,ghc-conduit)
               ("ghc-resourcet" ,ghc-resourcet)
               ("ghc-exceptions" ,ghc-exceptions)
@@ -10098,7 +9862,6 @@ way.")
               ("ghc-exceptions" ,ghc-exceptions)
               ("ghc-hashable" ,ghc-hashable)
               ("ghc-scientific" ,ghc-scientific)
-              ("ghc-text" ,ghc-text)
               ("ghc-time-locale-compat" ,ghc-time-locale-compat)
               ("ghc-unordered-containers" ,ghc-unordered-containers)
               ("ghc-vector" ,ghc-vector)
@@ -10130,7 +9893,6 @@ ghc-aeson.")
        ("2" "03qgwk32krldph3blw5agiqcpccr3649hajyn8wm9k71zz82dpn6")))
     (inputs `(("ghc-persistent" ,ghc-persistent)
               ("ghc-monad-control" ,ghc-monad-control)
-              ("ghc-text" ,ghc-text)
               ("ghc-aeson" ,ghc-aeson)
               ("ghc-aeson-compat" ,ghc-aeson-compat)
               ("ghc-monad-logger" ,ghc-monad-logger)
@@ -10240,7 +10002,6 @@ used both from lens and microlens).")
     (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH
     (inputs
      `(("ghc-async" ,ghc-async)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-unliftio-core" ,ghc-unliftio-core)))
     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
     (home-page "https://github.com/fpco/unliftio")
@@ -10277,8 +10038,7 @@ working with it.")
               ("ghc-unordered-containers" ,ghc-unordered-containers)))
     (native-inputs `(("ghc-hspec" ,ghc-hspec)
                      ("ghc-persistent-template" ,ghc-persistent-template)
-                     ("ghc-temporary" ,ghc-temporary)
-                     ("ghc-text" ,ghc-text)))
+                     ("ghc-temporary" ,ghc-temporary)))
     (home-page
      "https://www.yesodweb.com/book/persistent")
     (synopsis "Backend for the persistent library using sqlite3")
@@ -10336,7 +10096,6 @@ address string against RFC 5322.")
              ("cabal-doctest" ,cabal-doctest)
              ("ghc-doctest" ,ghc-doctest)
              ("ghc-scientific" ,ghc-scientific)
-             ("ghc-text" ,ghc-text)
              ("ghc-transformers-compat" ,ghc-transformers-compat)
              ("ghc-unordered-containers" ,ghc-unordered-containers)
              ("ghc-void" ,ghc-void)
@@ -10433,7 +10192,6 @@ This package provides an orphan instance.")
     (arguments '(#:tests? #f))
     (inputs
      `(("ghc-network" ,ghc-network)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-hunit" ,ghc-hunit)
        ("ghc-regex-compat" ,ghc-regex-compat)
        ("ghc-hslogger" ,ghc-hslogger)
@@ -10612,7 +10370,6 @@ widths to the Char type.")
        ("ghc-hashable" ,ghc-hashable)
        ("ghc-microlens" ,ghc-microlens)
        ("ghc-primitive" ,ghc-primitive)
-       ("ghc-text" ,ghc-text)
        ("ghc-typed-process" ,ghc-typed-process)
        ("ghc-unliftio" ,ghc-unliftio)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
@@ -10698,7 +10455,6 @@ expose it from another module in the hierarchy.
                #t))))))
     (inputs
      `(("ghc-utf8-string" ,ghc-utf8-string)
-       ("ghc-text" ,ghc-text)
        ("cairo" ,cairo)))
     (native-inputs
      `(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools)
@@ -10755,12 +10511,10 @@ backend for the Charts library.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-temporary" ,ghc-temporary)
-       ("ghc-unix-compat" ,ghc-unix-compat)
-       ("ghc-text" ,ghc-text)))
+       ("ghc-unix-compat" ,ghc-unix-compat)))
     (native-inputs
      `(("ghc-temporary" ,ghc-temporary)
        ("ghc-unix-compat" ,ghc-unix-compat)
-       ("ghc-text" ,ghc-text)
        ("ghc-hspec" ,ghc-hspec)
        ("hspec-discover" ,hspec-discover)))
     (home-page "https://github.com/stackbuilders/atomic-write")
@@ -10845,8 +10599,7 @@ monadic incremental interface is provided as well.")
          "0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z"))))
     (build-system haskell-build-system)
     (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-stm-chans" ,ghc-stm-chans)
+     `(("ghc-stm-chans" ,ghc-stm-chans)
        ("ghc-cereal" ,ghc-cereal)
        ("ghc-cereal-conduit" ,ghc-cereal-conduit)
        ("ghc-conduit" ,ghc-conduit)
@@ -11001,7 +10754,6 @@ based on a binomial heap.")
        ("ghc-monad-control" ,ghc-monad-control)
        ("ghc-pqueue" ,ghc-pqueue)
        ("ghc-resourcet" ,ghc-resourcet)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-stm-conduit" ,ghc-stm-conduit)
        ("ghc-streaming-commons" ,ghc-streaming-commons)
        ("ghc-unliftio-core" ,ghc-unliftio-core)
@@ -11038,7 +10790,6 @@ level asynchronous processing and some other utilities.")
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
-       ("ghc-text" ,ghc-text)
        ("hspec-discover" ,hspec-discover)))
     (home-page "https://github.com/sol/interpolate")
     (synopsis "String interpolation library")
@@ -11068,7 +10819,6 @@ Haskell.")
        ("ghc-http-client-tls" ,ghc-http-client-tls)
        ("ghc-http-types" ,ghc-http-types)
        ("ghc-scientific" ,ghc-scientific)
-       ("ghc-text" ,ghc-text)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-vector" ,ghc-vector)
        ("ghc-yaml" ,ghc-yaml)))
@@ -11133,7 +10883,6 @@ DOS/Windows paths and markup languages (such as XML).")
      `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
        ("ghc-cryptohash" ,ghc-cryptohash)
        ("ghc-hashable" ,ghc-hashable)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-parsers" ,ghc-parsers)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-vector" ,ghc-vector)))
@@ -11312,7 +11061,6 @@ from strict or lazy bytestrings.")
     (inputs
      `(("ghc-attoparsec" ,ghc-attoparsec)
        ("ghc-hashable" ,ghc-hashable)
-       ("ghc-text" ,ghc-text)
        ("ghc-unix-compat" ,ghc-unix-compat)
        ("ghc-unordered-containers" ,ghc-unordered-containers)))
     (native-inputs
@@ -11443,7 +11191,6 @@ man pages with practical examples.")
        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
        ("ghc-hunit" ,ghc-hunit)
        ("ghc-shelly" ,ghc-shelly)
-       ("ghc-text" ,ghc-text)
        ("gcc" ,gcc)))
     (arguments
      `(;; XXX: Test failures are induced by a parse error in <bits/floatn.h>
@@ -11493,10 +11240,12 @@ imported with the correct Haskell types.")
         (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-text" ,ghc-text)
        ("ghc-data-default-class" ,ghc-data-default-class)
        ("ghc-network" ,ghc-network)
        ("ghc-utf8-string" ,ghc-utf8-string)))
@@ -12037,7 +11786,7 @@ default)
 (define-public ghc-validation
   (package
     (name "ghc-validation")
-    (version "1.1")
+    (version "1")
     (source
      (origin
        (method url-fetch)
@@ -12047,18 +11796,11 @@ default)
              ".tar.gz"))
        (sha256
         (base32
-         "1acj7mh3581ks405xswxw6667z7y1y0slisg6jvp6chc191ji9l5"))))
+         "08drmdvyzg2frbb26icy1mlz52xv0l6gi3v8gb7xp0vrcci5libh"))))
     (build-system haskell-build-system)
     (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'add-setup-script
-           (lambda _
-             ;; The usual "Setup.hs" script is missing from the source.
-             (with-output-to-file "Setup.hs"
-               (lambda ()
-                 (format #t "import Distribution.Simple~%")
-                 (format #t "main = defaultMain~%"))))))))
+     `(#:cabal-revision
+       ("1" "1x1g4nannz81j1h64l1m3ancc96zc57d1bjhj1wk7bwn1xxbi5h3")))
     (inputs
      `(("ghc-semigroups" ,ghc-semigroups)
        ("ghc-semigroupoids" ,ghc-semigroupoids)
@@ -12091,7 +11833,7 @@ example of, \"An applicative functor that is not a monad.\"")
 (define-public ghc-concurrent-output
   (package
     (name "ghc-concurrent-output")
-    (version "1.10.10")
+    (version "1.10.9")
     (source
      (origin
        (method url-fetch)
@@ -12101,11 +11843,10 @@ example of, \"An applicative functor that is not a monad.\"")
              ".tar.gz"))
        (sha256
         (base32
-         "1wnjxnwbc3l853kiiijagzjyb6fmhz3lmkwls24plbximl1qrr22"))))
+         "0mwf155w89nbbkjln7hhbn8k3f8p0ylcvgrg31cm7ijpx4499i4c"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-async" ,ghc-async)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-exceptions" ,ghc-exceptions)
        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
        ("ghc-terminal-size" ,ghc-terminal-size)))
diff --git a/gnu/packages/idris.scm b/gnu/packages/idris.scm
index ec3eb15d63..4290d8c21f 100644
--- a/gnu/packages/idris.scm
+++ b/gnu/packages/idris.scm
@@ -78,7 +78,6 @@
        ("ghc-safe" ,ghc-safe)
        ("ghc-split" ,ghc-split)
        ("ghc-terminal-size" ,ghc-terminal-size)
-       ("ghc-text" ,ghc-text)
        ("ghc-uniplate" ,ghc-uniplate)
        ("ghc-unordered-containers" ,ghc-unordered-containers)
        ("ghc-utf8-string" ,ghc-utf8-string)
diff --git a/gnu/packages/photo.scm b/gnu/packages/photo.scm
index cbfc2debd8..b445374718 100644
--- a/gnu/packages/photo.scm
+++ b/gnu/packages/photo.scm
@@ -70,14 +70,14 @@
 (define-public libraw
   (package
     (name "libraw")
-    (version "0.19.3")
+    (version "0.19.4")
     (source (origin
               (method url-fetch)
               (uri (string-append "https://www.libraw.org/data/LibRaw-"
                                   version ".tar.gz"))
               (sha256
                (base32
-                "0xs1qb6pcvc4c43fy5xi3nkqxcif77gakkw99irf0fc5iccdd5px"))))
+                "07wnzw9k3mwdq9dmpmg94al3ksc065kskfbxkknnmhvrsv2iri8k"))))
     (build-system gnu-build-system)
     (native-inputs
      `(("pkg-config" ,pkg-config)))
diff --git a/gnu/packages/ruby.scm b/gnu/packages/ruby.scm
index d47c2ed07d..1b70f842ae 100644
--- a/gnu/packages/ruby.scm
+++ b/gnu/packages/ruby.scm
@@ -4849,14 +4849,14 @@ alternative to Marshal for Object serialization. ")
 (define-public ruby-pg
   (package
     (name "ruby-pg")
-    (version "1.1.3")
+    (version "1.1.4")
     (source
      (origin
        (method url-fetch)
        (uri (rubygems-uri "pg" version))
        (sha256
         (base32
-         "1pnjw3rspdfjssxyf42jnbsdlgri8ylysimp0s28wxb93k6ff2qb"))))
+         "0fmnyxcyrvgdbgq7m09whgn9i8rwfybk0w8aii1nc4g5kqw0k2jy"))))
     (build-system ruby-build-system)
     (arguments
      '(#:test-target "spec"))
@@ -4865,7 +4865,7 @@ alternative to Marshal for Object serialization. ")
        ("ruby-hoe" ,ruby-hoe)
        ("ruby-rspec" ,ruby-rspec)))
     (inputs
-     `(("postgresql" ,postgresql-9.6)))
+     `(("postgresql" ,postgresql)))
     (synopsis "Ruby interface to PostgreSQL")
     (description "Pg is the Ruby interface to the PostgreSQL RDBMS.  It works
 with PostgreSQL 9.0 and later.")
diff --git a/gnu/packages/statistics.scm b/gnu/packages/statistics.scm
index f27f2229f7..248bf39eff 100644
--- a/gnu/packages/statistics.scm
+++ b/gnu/packages/statistics.scm
@@ -1404,13 +1404,13 @@ data derived from /etc/mime.types in UNIX-type systems.")
 (define-public r-markdown
   (package
     (name "r-markdown")
-    (version "1.0")
+    (version "1.1")
     (source (origin
               (method url-fetch)
               (uri (cran-uri "markdown" version))
               (sha256
                (base32
-                "19nrz0ba1yd5kicd65crkkz2r3kialm2hm6zdkp495l2s5r80b8p"))))
+                "06zwbrp14bri3470anadd7dvgmw06xf8df6v2pk64wx3f9sd934d"))))
     (build-system r-build-system)
     ;; Skip check phase because the tests require the r-knitr package to be
     ;; installed. This prevents installation failures. Knitr normally
@@ -1418,7 +1418,8 @@ data derived from /etc/mime.types in UNIX-type systems.")
     ;; package.
     (arguments `(#:tests? #f))
     (propagated-inputs
-     `(("r-mime" ,r-mime)))
+     `(("r-mime" ,r-mime)
+       ("r-xfun" ,r-xfun)))
     (home-page "https://github.com/rstudio/markdown")
     (synopsis "Markdown rendering for R")
     (description
@@ -1448,13 +1449,13 @@ emitter (http://pyyaml.org/wiki/LibYAML) for R.")
 (define-public r-knitr
   (package
     (name "r-knitr")
-    (version "1.23")
+    (version "1.24")
     (source (origin
               (method url-fetch)
               (uri (cran-uri "knitr" version))
               (sha256
                (base32
-                "16ba4258c915xydhniw4cw7fvv1vp4cnwd1w49ykx7zw00rznfq6"))))
+                "12bvs9fd61m7k7bq321qzrh2ccl9rq653s1anrvfb9s5ni1j0378"))))
     (build-system r-build-system)
     (propagated-inputs
      `(("r-evaluate" ,r-evaluate)
@@ -5140,14 +5141,14 @@ using modular prediction and response module classes.")
 (define-public r-quantreg
   (package
     (name "r-quantreg")
-    (version "5.42.1")
+    (version "5.51")
     (source
      (origin
        (method url-fetch)
        (uri (cran-uri "quantreg" version))
        (sha256
         (base32
-         "1aycnghci329yqw63kybv7sfjjx5whq3xs7xzic4wsaj7j4b1hjc"))))
+         "1cdx51a9g6fjq2g9arr6wp6ghkyl2m6bs2dj4kcycvpn8p9304yz"))))
     (build-system r-build-system)
     (native-inputs
      `(("gfortran" ,gfortran)))
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index 160c267882..ffe2590bf2 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -596,10 +596,8 @@ tiled on several screens.")
      `(("ghc-hinotify" ,ghc-hinotify)
        ("ghc-http" ,ghc-http)
        ("ghc-iwlib" ,ghc-iwlib)
-       ("ghc-parsec" ,ghc-parsec)
        ("ghc-parsec-numbers" ,ghc-parsec-numbers)
        ("ghc-regex-compat" ,ghc-regex-compat)
-       ("ghc-stm" ,ghc-stm)
        ("ghc-x11-xft" ,ghc-x11-xft)
        ("libxpm" ,libxpm)))
     (arguments
diff --git a/guix/import/hackage.scm b/guix/import/hackage.scm
index 6f426af900..5fe3d85a7f 100644
--- a/guix/import/hackage.scm
+++ b/guix/import/hackage.scm
@@ -3,6 +3,7 @@
 ;;; Copyright © 2016 Eric Bavier <bavier@member.fsf.org>
 ;;; Copyright © 2016 ng0 <ng0@n0.is>
 ;;; Copyright © 2018 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -52,7 +53,7 @@
 
 (define ghc-standard-libraries
   ;; List of libraries distributed with ghc (8.4.3).
-  ;; https://downloads.haskell.org/~ghc/8.4.3/docs/html/users_guide/8.4.3-notes.html
+  ;; Contents of ...-ghc-8.4.3/lib/ghc-8.4.3.
   '("ghc"
     "cabal" ;; in the output of `ghc-pkg list` Cabal is uppercased, but
             ;; hackage-name->package-name takes this into account.
@@ -65,7 +66,9 @@
     "deepseq"
     "directory"
     "filepath"
+    "ghc"
     "ghc-boot"
+    "ghc-boot-th"
     "ghc-compact"
     "ghc-prim"
     "ghci"
@@ -74,8 +77,11 @@
     "integer-gmp"
     "mtl"
     "parsec"
+    "pretty"
     "process"
+    "stm"
     "template-haskell"
+    "terminfo"
     "text"
     "time"
     "transformers"