gnu: Move web packages from haskell to haskell-web.

* gnu/packages/haskell.scm (ghc-tagsoup, ghc-cookie, ghc-http-types, ghc-http,
ghc-http-client, ghc-http-client-tls, ghc-http-date, ghc-http2,
ghc-http-conduit, ghc-wai, ghc-wai-logger, ghc-wai-extra, ghc-wai-conduit,
ghc-warp, ghc-warp-tls, ghc-xss-sanitize, ghc-css-text, ghc-mime-types,
ghc-html, ghc-xhtml, ghc-blaze-html, ghc-aeson, ghc-aeson-pretty,
ghc-aeson-qq, ghc-multipart): Move variables to ...
* gnu/packages/haskell-web.scm: ... this new file.
* gnu/local.mk (GNU_SYSTEM_MODULES): Add it.
* gnu/packages/haskell.scm,
gnu/packages/idris.scm,
gnu/packages/version-control.scm,
gnu/packages/wm.scm: Include haskell-web module.

5 files changed, 847 insertions, 812 deletions

diff --git a/gnu/packages/haskell-web.scm b/gnu/packages/haskell-web.scm
new file mode 100644
index 0000000000..c1a24b91f9
--- /dev/null
+++ b/gnu/packages/haskell-web.scm
@@ -0,0 +1,843 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
+;;; Copyright © 2015, 2016 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
+;;; Copyright © 2016 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2017 rsiddharth <s@ricketyspace.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-web)
+  #: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)
+  #:use-module (guix utils))
+
+(define-public ghc-tagsoup
+  (package
+    (name "ghc-tagsoup")
+    (version "0.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tagsoup/tagsoup-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "07pax7i0bl79dmqqz58zy09yrgpnyyr2ya0z183hv96kp65jv0lh"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-text" ,ghc-text)))
+    (home-page
+     "http://community.haskell.org/~ndm/tagsoup/")
+    (synopsis
+     "Parsing and extracting information from (possibly malformed) HTML/XML
+documents")
+    (description
+     "TagSoup is a library for parsing HTML/XML.  It supports the HTML 5
+specification, and can be used to parse either well-formed XML, or
+unstructured and malformed HTML from the web.  The library also provides
+useful functions to extract information from an HTML document, making it ideal
+for screen-scraping.")
+    (license license:bsd-3)))
+
+(define-public ghc-cookie
+  (package
+    (name "ghc-cookie")
+    (version "0.4.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/cookie/cookie-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
+    (build-system haskell-build-system)
+    (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)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://github.com/snoyberg/cookie")
+    (synopsis "HTTP cookie parsing and rendering")
+    (description "HTTP cookie parsing and rendering library for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-http-types
+  (package
+    (name "ghc-http-types")
+    (version "0.9")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/http-types/http-types-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find
+                               ; Blaze.Bytestring.Builder, which should be
+                               ; provided by ghc-blaze-builder.
+    (inputs
+     `(("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-text" ,ghc-text)))
+    (home-page "https://github.com/aristidb/http-types")
+    (synopsis "Generic HTTP types for Haskell")
+    (description "This package provides generic HTTP types for Haskell (for
+both client and server code).")
+    (license license:bsd-3)))
+
+(define-public ghc-http
+  (package
+    (name "ghc-http")
+    (version "4000.2.20")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/HTTP/HTTP-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-parsec" ,ghc-parsec)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-network" ,ghc-network)
+       ("ghc-network-uri" ,ghc-network-uri)))
+    (arguments
+     `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
+    (home-page "https://github.com/haskell/HTTP")
+    (synopsis "Library for client-side HTTP")
+    (description
+     "The HTTP package supports client-side web programming in Haskell.  It
+lets you set up HTTP connections, transmitting requests and processing the
+responses coming back.")
+    (license license:bsd-3)))
+
+(define-public ghc-http-client
+  (package
+    (name "ghc-http-client")
+    (version "0.5.6.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "http-client/http-client-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1v9bdb8dkhb5g6jl9azk86ig7ia8xh9arr64n7s8r94fp0vl6c1c"))))
+    (build-system haskell-build-system)
+    ;; Tests require access to the web.
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-network" ,ghc-network)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-cookie" ,ghc-cookie)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-random" ,ghc-random)
+       ("ghc-mime-types" ,ghc-mime-types)
+       ("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-zlib" ,ghc-zlib)
+       ("ghc-async" ,ghc-async)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://github.com/snoyberg/http-client")
+    (synopsis "HTTP client engine")
+    (description
+     "This package provides an HTTP client engine, intended as a base layer
+for more user-friendly packages.")
+    (license license:expat)))
+
+(define-public ghc-http-client-tls
+  (package
+    (name "ghc-http-client-tls")
+    (version "0.3.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "http-client-tls/http-client-tls-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1mbwdfn4hs8lcwml2l6xv4n068l9zlasyv6vwb2ylgm030pyv3xh"))))
+    (build-system haskell-build-system)
+    ;; Tests require Internet access
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-connection" ,ghc-connection)
+       ("ghc-network" ,ghc-network)
+       ("ghc-tls" ,ghc-tls)
+       ("ghc-http-types" ,ghc-http-types)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://github.com/snoyberg/http-client")
+    (synopsis "Backend for http-client using the TLS library")
+    (description
+     "This package provides a backend for the http-client package using the
+connection and TLS libraries.  It is intended for use by higher-level
+libraries, such as http-conduit.")
+    (license license:expat)))
+
+(define-public ghc-http-date
+  (package
+    (name "ghc-http-date")
+    (version "0.0.6.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "http-date-" version "/"
+                           "http-date-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0dknh28kyarnzqrsc80ssalxjrq0qbv7ir49247p2grb7rh0dqgj"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)))
+    (native-inputs
+     `(("ghc-doctest" ,ghc-doctest)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-old-locale" ,ghc-old-locale)))
+    (home-page "https://github.com/kazu-yamamoto/http-date")
+    (synopsis "HTTP Date parser/formatter")
+    (description "Library for Parsing and formatting HTTP
+Date in Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-http2
+  (package
+    (name "ghc-http2")
+    (version "1.6.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "http2-" version "/"
+                           "http2-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0hww0rfsv6lqx62qzycbcqy5q6rh9k09qkyjkdm5m1sp1z50wqk1"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-aeson-pretty" ,ghc-aeson-pretty)
+       ("ghc-hex" ,ghc-hex)
+       ("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)))
+    (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
+and HPACK.  Currently HTTP/2 16 framing and HPACK 10 is supported.")
+    (license license:bsd-3)))
+
+(define-public ghc-http-conduit
+  (package
+    (name  "ghc-http-conduit")
+    (version "2.2.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "http-conduit-" version "/" "http-conduit-"
+                           version ".tar.gz"))
+       (sha256 (base32
+                "03na2nbm9la0shlijvjyb5mpp1prfskk4jmjy8iz707r0731dbjk"))))
+    (build-system haskell-build-system)
+    ;; FIXME: `httpLbs TLS` in test-suite `test` fails with
+    ;; ConnectionFailure getProtocolByName: does not exist (no such protocol
+    ;; name: tcp)
+    (arguments `(#:tests? #f))
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-http-client-tls" ,ghc-http-client-tls)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-exceptions" ,ghc-exceptions)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("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)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-network" ,ghc-network)
+       ("ghc-wai" ,ghc-wai)
+       ("ghc-warp" ,ghc-warp)
+       ("ghc-wai-conduit" ,ghc-wai-conduit)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-cookie" ,ghc-cookie)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-resourcet" ,ghc-resourcet)))
+    (home-page "https://hackage.haskell.org/package/http-conduit")
+    (synopsis "HTTP/HTTPS client with conduit interface")
+    (description "This library uses attoparsec for parsing the actual
+contents of the HTTP connection.  It also provides higher-level functions
+which allow you to avoid direct usage of conduits.")
+    (license license:bsd-3)))
+
+(define-public ghc-wai
+  (package
+    (name "ghc-wai")
+    (version "3.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/wai/wai-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "08afasnirja21vr0bmzcywz4w29x736dmdv7h8nnh1l8bn7sd02x"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-vault" ,ghc-vault)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-text" ,ghc-text)
+       ("ghc-http-types" ,ghc-http-types)))
+    (native-inputs
+     `(("hspec-discover" ,hspec-discover)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)))
+    (home-page "https://hackage.haskell.org/package/wai")
+    (synopsis "Web application interface for Haskell")
+    (description "This package provides a Web Application Interface (WAI)
+library for the Haskell language.  It defines a common protocol for
+communication between web applications and web servers.")
+    (license license:bsd-3)))
+
+(define-public ghc-wai-logger
+  (package
+    (name "ghc-wai-logger")
+    (version "2.2.4.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/wai-logger/wai-logger-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
+                               ; by propagated-inputs.
+    (inputs
+     `(("ghc-auto-update" ,ghc-auto-update)
+       ("ghc-byteorder" ,ghc-byteorder)
+       ("ghc-easy-file" ,ghc-easy-file)
+       ("ghc-unix-time" ,ghc-unix-time)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-network" ,ghc-network)
+       ("ghc-wai" ,ghc-wai)))
+    (home-page "https://hackage.haskell.org/package/wai-logger")
+    (synopsis "Logging system for WAI")
+    (description "This package provides the logging system for WAI.")
+    (license license:bsd-3)))
+
+(define-public ghc-wai-extra
+  (package
+    (name "ghc-wai-extra")
+    (version "3.0.13.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/wai-extra/wai-extra-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0mh761a1bayr4ydwqmh3h8ndpi19zqw34mmy49lp2abr70r0nm1p"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-cookie" ,ghc-cookie)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-network" ,ghc-network)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-stringsearch" ,ghc-stringsearch)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-wai-logger" ,ghc-wai-logger)
+       ("ghc-zlib" ,ghc-zlib)
+       ("ghc-word8" ,ghc-word8)
+       ("ghc-iproute" ,ghc-iproute)
+       ("ghc-void" ,ghc-void)
+       ("ghc-wai" ,ghc-wai)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-text" ,ghc-text)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-unix-compat" ,ghc-unix-compat)
+       ("ghc-vault" ,ghc-vault)
+       ("ghc-aeson" ,ghc-aeson)))
+    (native-inputs
+     `(("hspec-discover" ,hspec-discover)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/yesodweb/wai")
+    (synopsis "Some basic WAI handlers and middleware")
+    (description "This library provides basic WAI handlers and middleware
+functionality.")
+    (license license:expat)))
+
+(define-public ghc-wai-conduit
+  (package
+    (name "ghc-wai-conduit")
+    (version "3.0.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "wai-conduit-" version "/"
+                           "wai-conduit-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1zvsiwjq2mvkb9sjgp3ly9m968m7a2jjzr4id6jpi3mmqykj15z4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-conduit" ,ghc-conduit)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-wai" ,ghc-wai)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)))
+    (home-page "https://github.com/yesodweb/wai")
+    (synopsis "Conduit wrappers for Haskell's WAI")
+    (description "This package provides data streaming abstraction for
+Haskell's Web Application Interface (WAI).")
+    (license license:expat)))
+
+(define-public ghc-warp
+  (package
+    (name "ghc-warp")
+    (version "3.2.11.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "warp-" version "/" "warp-" version
+                           ".tar.gz"))
+       (sha256
+        (base32
+         "1zp5cy0bbj508vdvms1n5z80z37m253kwsqc5a83cfc990n6fgw5"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-auto-update" ,ghc-auto-update)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-hashable" ,ghc-hashable)
+       ("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)
+       ("ghc-word8" ,ghc-word8)
+       ("ghc-lifted-base" ,ghc-lifted-base)
+       ("ghc-http-date" ,ghc-http-date)
+       ("ghc-simple-sendfile" ,ghc-simple-sendfile)
+       ("ghc-http2" ,ghc-http2)))
+    (native-inputs
+     `(("ghc-silently" ,ghc-silently)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-auto-update" ,ghc-auto-update)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-http" ,ghc-http)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "http://github.com/yesodweb/wai")
+    (synopsis "HTTP server library for Haskell's WAI")
+    (description "Warp is a server library for HTTP/1.x and HTTP/2
+based WAI (Web Application Interface in Haskell).")
+    (license license:expat)))
+
+(define-public ghc-warp-tls
+  (package
+    (name "ghc-warp-tls")
+    (version "3.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "warp-tls-" version "/"
+                           "warp-tls-" version ".tar.gz"))
+       (sha256
+        (base32
+         "14m2bzk5ivz9gdpxlcj6qnh46f2lycm1ybdjnfkj2876zrqwii7m"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-cryptonite" ,ghc-cryptonite)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-network" ,ghc-network)
+       ("ghc-streaming-commons" ,ghc-streaming-commons)
+       ("ghc-tls" ,ghc-tls)
+       ("ghc-wai" ,ghc-wai)
+       ("ghc-warp" ,ghc-warp)))
+    (home-page "http://github.com/yesodweb/wai")
+    (synopsis "SSL/TLS support for Warp")
+    (description "This package provides SSL/TLS support for Warp,
+a WAI handler, via the native Haskell TLS implementation.")
+    (license license:expat)))
+
+(define-public ghc-xss-sanitize
+  (package
+    (name "ghc-xss-sanitize")
+    (version "0.3.5.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tagsoup" ,ghc-tagsoup)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-css-text" ,ghc-css-text)
+       ("ghc-network-uri" ,ghc-network-uri)))
+    (native-inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
+    (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
+    (description "This library provides @code{sanitizeXSS}.  Run untrusted
+HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
+attacks.")
+    (license license:bsd-3)))
+
+(define-public ghc-css-text
+  (package
+    (name "ghc-css-text")
+    (version "0.1.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/css-text/css-text-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "http://www.yesodweb.com/")
+    (synopsis "CSS parser and renderer")
+    (description "This package provides a CSS parser and renderer for
+Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-mime-types
+  (package
+    (name "ghc-mime-types")
+    (version "0.1.0.6")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "mime-types/mime-types-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw"))))
+    (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
+     "This library provides basic MIME type handling types and functions.")
+    (license license:expat)))
+
+(define-public ghc-html
+  (package
+    (name "ghc-html")
+    (version "1.0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/html/html-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://hackage.haskell.org/package/html")
+    (synopsis "HTML combinator library")
+    (description
+     "This package contains a combinator library for constructing HTML
+documents.")
+    (license license:bsd-3)))
+
+(define-public ghc-xhtml
+  (package
+    (name "ghc-xhtml")
+    (version "3000.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/xhtml/xhtml-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/haskell/xhtml")
+    (synopsis "XHTML combinator library")
+    (description
+     "This package provides combinators for producing XHTML 1.0, including the
+Strict, Transitional and Frameset variants.")
+    (license license:bsd-3)))
+
+(define-public ghc-blaze-html
+  (package
+    (name "ghc-blaze-html")
+    (version "0.8.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/blaze-html/blaze-html-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-text" ,ghc-text)
+       ("ghc-blaze-markup" ,ghc-blaze-markup)))
+    (home-page "http://jaspervdj.be/blaze")
+    (synopsis "Fast HTML combinator library")
+    (description "This library provides HTML combinators for Haskell.")
+    (license license:bsd-3)))
+
+(define-public ghc-aeson
+  (package
+    (name "ghc-aeson")
+    (version "0.10.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/aeson/aeson-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-dlist" ,ghc-dlist)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-syb" ,ghc-syb)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-text" ,ghc-text)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/bos/aeson")
+    (synopsis "Fast JSON parsing and encoding")
+    (description "This package provides a JSON parsing and encoding library
+for Haskell, optimized for ease of use and high performance.  (A note on
+naming: in Greek mythology, Aeson was the father of Jason.)")
+    (license license:bsd-3)))
+
+(define-public ghc-aeson-pretty
+  (package
+    (name "ghc-aeson-pretty")
+    (version "0.7.2")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
+                    version ".tar.gz"))
+              (sha256
+               (base32
+                "03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-text" ,ghc-text)
+       ("ghc-unordered-containers"
+        ,ghc-unordered-containers)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-cmdargs" ,ghc-cmdargs)))
+    (home-page "https://github.com/informatikr/aeson-pretty")
+    (synopsis "JSON pretty-printing library and command-line tool")
+    (description
+     "This package provides a JSON pretty-printing library compatible with aeson
+as well as a command-line tool to improve readabilty of streams of JSON data.
+The library provides the function @code{encodePretty}.  It is a drop-in
+replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
+human readers.  The command-line tool reads JSON from stdin and writes
+prettified JSON to stdout.  It also offers a complementary \"compact\"-mode,
+essentially the opposite of pretty-printing.")
+    (license license:bsd-3)))
+
+(define-public ghc-aeson-qq
+  (package
+    (name "ghc-aeson-qq")
+    (version "0.8.1")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "aeson-qq/aeson-qq-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
+    (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)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/zalora/aeson-qq")
+    (synopsis "JSON quasiquoter for Haskell")
+    (description
+     "aeson-qq provides a JSON quasiquoter for Haskell.  This package exposes
+the function @code{aesonQQ} that compile-time converts a string representation
+of a JSON value into a @code{Data.Aeson.Value}.")
+    (license license:expat)))
+
+(define-public ghc-multipart
+  (package
+    (name "ghc-multipart")
+    (version "0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/multipart/multipart-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-parsec" ,ghc-parsec)))
+    (home-page
+     "http://www.github.com/silkapp/multipart")
+    (synopsis
+     "HTTP multipart library")
+    (description
+     "HTTP multipart split out of the cgi package, for Haskell.")
+    (license license:bsd-3)))
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 68324b1210..23093e318d 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -37,6 +37,7 @@
   #:use-module (gnu packages ghostscript)
   #:use-module (gnu packages gl)
   #:use-module (gnu packages haskell-check)
+  #:use-module (gnu packages haskell-web)
   #:use-module (gnu packages libffi)
   #:use-module (gnu packages lisp)
   #:use-module (gnu packages lua)
@@ -735,75 +736,6 @@ are no options for manipulating the reflected expressions beyond showing
 them.")
     (license license:bsd-3)))
 
-(define-public ghc-multipart
-  (package
-    (name "ghc-multipart")
-    (version "0.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/multipart/multipart-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
-    (build-system haskell-build-system)
-    (inputs `(("ghc-parsec" ,ghc-parsec)))
-    (home-page
-     "http://www.github.com/silkapp/multipart")
-    (synopsis
-     "HTTP multipart library")
-    (description
-     "HTTP multipart split out of the cgi package, for Haskell.")
-    (license license:bsd-3)))
-
-(define-public ghc-html
-  (package
-    (name "ghc-html")
-    (version "1.0.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/html/html-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
-    (build-system haskell-build-system)
-    (home-page
-     "https://hackage.haskell.org/package/html")
-    (synopsis "HTML combinator library")
-    (description
-     "This package contains a combinator library for constructing HTML
-documents.")
-    (license license:bsd-3)))
-
-(define-public ghc-xhtml
-  (package
-    (name "ghc-xhtml")
-    (version "3000.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/xhtml/xhtml-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
-    (build-system haskell-build-system)
-    (home-page "https://github.com/haskell/xhtml")
-    (synopsis "XHTML combinator library")
-    (description
-     "This package provides combinators for producing XHTML 1.0, including the
-Strict, Transitional and Frameset variants.")
-    (license license:bsd-3)))
-
 (define-public ghc-haskell-src
   (package
     (name "ghc-haskell-src")
@@ -1057,38 +989,6 @@ unwanted suggestions, and to add your own custom suggestions.")
 code where you can safely allocate resources.")
     (license license:bsd-3)))
 
-(define-public ghc-xss-sanitize
-  (package
-    (name "ghc-xss-sanitize")
-    (version "0.3.5.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-tagsoup" ,ghc-tagsoup)
-       ("ghc-utf8-string" ,ghc-utf8-string)
-       ("ghc-css-text" ,ghc-css-text)
-       ("ghc-network-uri" ,ghc-network-uri)))
-    (native-inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-attoparsec" ,ghc-attoparsec)
-       ("ghc-hspec" ,ghc-hspec)
-       ("ghc-hunit" ,ghc-hunit)))
-    (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
-    (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
-    (description "This library provides @code{sanitizeXSS}.  Run untrusted
-HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
-attacks.")
-    (license license:bsd-3)))
-
 (define-public ghc-objectname
   (package
     (name "ghc-objectname")
@@ -2117,34 +2017,6 @@ package.  This package re-exports the unix package when available.  When it
 isn't available, portable implementations are used.")
     (license license:bsd-3)))
 
-(define-public ghc-http-types
-  (package
-    (name "ghc-http-types")
-    (version "0.9")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/http-types/http-types-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
-    (build-system haskell-build-system)
-    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find
-                               ; Blaze.Bytestring.Builder, which should be
-                               ; provided by ghc-blaze-builder.
-    (inputs
-     `(("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-text" ,ghc-text)))
-    (home-page "https://github.com/aristidb/http-types")
-    (synopsis "Generic HTTP types for Haskell")
-    (description "This package provides generic HTTP types for Haskell (for
-both client and server code).")
-    (license license:bsd-3)))
-
 (define-public ghc-indents
   (package
     (name "ghc-indents")
@@ -2400,32 +2272,6 @@ aimed particularly at dealing efficiently with network protocols and
 complicated text/binary file formats.")
     (license license:bsd-3)))
 
-(define-public ghc-css-text
-  (package
-    (name "ghc-css-text")
-    (version "0.1.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/css-text/css-text-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-attoparsec" ,ghc-attoparsec)
-       ("ghc-hspec" ,ghc-hspec)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page "http://www.yesodweb.com/")
-    (synopsis "CSS parser and renderer")
-    (description "This package provides a CSS parser and renderer for
-Haskell.")
-    (license license:bsd-3)))
-
 (define-public ghc-zip-archive
   (package
     (name "ghc-zip-archive")
@@ -3409,40 +3255,6 @@ allows cursor movement, screen clearing, color output showing or hiding the
 cursor, and changing the title.")
     (license license:bsd-3)))
 
-(define-public ghc-http
-  (package
-    (name "ghc-http")
-    (version "4000.2.20")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/HTTP/HTTP-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
-    (build-system haskell-build-system)
-    (native-inputs
-     `(("ghc-hunit" ,ghc-hunit)))
-    (inputs
-     `(("ghc-old-time" ,ghc-old-time)
-       ("ghc-parsec" ,ghc-parsec)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-network" ,ghc-network)
-       ("ghc-network-uri" ,ghc-network-uri)))
-    (arguments
-     `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
-    (home-page "https://github.com/haskell/HTTP")
-    (synopsis "Library for client-side HTTP")
-    (description
-     "The HTTP package supports client-side web programming in Haskell.  It
-lets you set up HTTP connections, transmitting requests and processing the
-responses coming back.")
-    (license license:bsd-3)))
-
 (define-public ghc-vault
   (package
     (name "ghc-vault")
@@ -3717,31 +3529,6 @@ interoperate with code that uses the new implementation.")
 library for Haskell.")
     (license license:bsd-3)))
 
-(define-public ghc-blaze-html
-  (package
-    (name "ghc-blaze-html")
-    (version "0.8.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/blaze-html/blaze-html-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
-    (build-system haskell-build-system)
-    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
-    (inputs
-     `(("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-text" ,ghc-text)
-       ("ghc-blaze-markup" ,ghc-blaze-markup)))
-    (home-page "http://jaspervdj.be/blaze")
-    (synopsis "Fast HTML combinator library")
-    (description "This library provides HTML combinators for Haskell.")
-    (license license:bsd-3)))
-
 (define-public ghc-easy-file
   (package
     (name "ghc-easy-file")
@@ -4150,35 +3937,6 @@ of getters, folds, isomorphisms, traversals, setters and lenses and their
 indexed variants.")
     (license license:bsd-3)))
 
-(define-public ghc-tagsoup
-  (package
-    (name "ghc-tagsoup")
-    (version "0.14")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tagsoup/tagsoup-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "07pax7i0bl79dmqqz58zy09yrgpnyyr2ya0z183hv96kp65jv0lh"))))
-    (build-system haskell-build-system)
-    (inputs `(("ghc-text" ,ghc-text)))
-    (home-page
-     "http://community.haskell.org/~ndm/tagsoup/")
-    (synopsis
-     "Parsing and extracting information from (possibly malformed) HTML/XML
-documents")
-    (description
-     "TagSoup is a library for parsing HTML/XML.  It supports the HTML 5
-specification, and can be used to parse either well-formed XML, or
-unstructured and malformed HTML from the web.  The library also provides
-useful functions to extract information from an HTML document, making it ideal
-for screen-scraping.")
-    (license license:bsd-3)))
-
 (define-public ghc-digest
   (package
     (name "ghc-digest")
@@ -4594,36 +4352,6 @@ functions for breaking or splitting on substrings and replacing all
 occurrences of a substring (the first in case of overlaps) with another.")
     (license license:bsd-3)))
 
-(define-public ghc-cookie
-  (package
-    (name "ghc-cookie")
-    (version "0.4.1.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/cookie/cookie-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
-    (build-system haskell-build-system)
-    (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)
-       ("ghc-tasty" ,ghc-tasty)
-       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
-    (home-page "https://github.com/snoyberg/cookie")
-    (synopsis "HTTP cookie parsing and rendering")
-    (description "HTTP cookie parsing and rendering library for Haskell.")
-    (license license:bsd-3)))
-
 (define-public ghc-scientific
   (package
     (name "ghc-scientific")
@@ -4659,74 +4387,6 @@ and space efficient.  They are represented using
 notation}.")
     (license license:bsd-3)))
 
-(define-public ghc-aeson
-  (package
-    (name "ghc-aeson")
-    (version "0.10.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/aeson/aeson-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
-    (build-system haskell-build-system)
-    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
-    (inputs
-     `(("ghc-attoparsec" ,ghc-attoparsec)
-       ("ghc-dlist" ,ghc-dlist)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-scientific" ,ghc-scientific)
-       ("ghc-syb" ,ghc-syb)
-       ("ghc-unordered-containers" ,ghc-unordered-containers)
-       ("ghc-vector" ,ghc-vector)
-       ("ghc-hashable" ,ghc-hashable)
-       ("ghc-text" ,ghc-text)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page "https://github.com/bos/aeson")
-    (synopsis "Fast JSON parsing and encoding")
-    (description "This package provides a JSON parsing and encoding library
-for Haskell, optimized for ease of use and high performance.  (A note on
-naming: in Greek mythology, Aeson was the father of Jason.)")
-    (license license:bsd-3)))
-
-(define-public ghc-aeson-pretty
-  (package
-    (name "ghc-aeson-pretty")
-    (version "0.7.2")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append
-                    "https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
-                    version ".tar.gz"))
-              (sha256
-               (base32
-                "03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-aeson" ,ghc-aeson)
-       ("ghc-vector" ,ghc-vector)
-       ("ghc-text" ,ghc-text)
-       ("ghc-unordered-containers"
-        ,ghc-unordered-containers)
-       ("ghc-attoparsec" ,ghc-attoparsec)
-       ("ghc-cmdargs" ,ghc-cmdargs)))
-    (home-page "https://github.com/informatikr/aeson-pretty")
-    (synopsis "JSON pretty-printing library and command-line tool")
-    (description
-     "This package provides a JSON pretty-printing library compatible with aeson
-as well as a command-line tool to improve readabilty of streams of JSON data.
-The library provides the function @code{encodePretty}.  It is a drop-in
-replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
-human readers.  The command-line tool reads JSON from stdin and writes
-prettified JSON to stdout.  It also offers a complementary \"compact\"-mode,
-essentially the opposite of pretty-printing.")
-    (license license:bsd-3)))
-
 (define-public ghc-boxes
   (package
     (name "ghc-boxes")
@@ -4749,123 +4409,6 @@ essentially the opposite of pretty-printing.")
 using a simple box model.")
     (license license:bsd-3)))
 
-(define-public ghc-wai
-  (package
-    (name "ghc-wai")
-    (version "3.2.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/wai/wai-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "08afasnirja21vr0bmzcywz4w29x736dmdv7h8nnh1l8bn7sd02x"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
-       ("ghc-unix-compat" ,ghc-unix-compat)
-       ("ghc-vault" ,ghc-vault)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-network" ,ghc-network)
-       ("ghc-text" ,ghc-text)
-       ("ghc-http-types" ,ghc-http-types)))
-    (native-inputs
-     `(("hspec-discover" ,hspec-discover)
-       ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-hspec" ,ghc-hspec)))
-    (home-page "https://hackage.haskell.org/package/wai")
-    (synopsis "Web application interface for Haskell")
-    (description "This package provides a Web Application Interface (WAI)
-library for the Haskell language.  It defines a common protocol for
-communication between web applications and web servers.")
-    (license license:bsd-3)))
-
-(define-public ghc-wai-logger
-  (package
-    (name "ghc-wai-logger")
-    (version "2.2.4.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/wai-logger/wai-logger-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
-    (build-system haskell-build-system)
-    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
-                               ; by propagated-inputs.
-    (inputs
-     `(("ghc-auto-update" ,ghc-auto-update)
-       ("ghc-byteorder" ,ghc-byteorder)
-       ("ghc-easy-file" ,ghc-easy-file)
-       ("ghc-unix-time" ,ghc-unix-time)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-fast-logger" ,ghc-fast-logger)
-       ("ghc-http-types" ,ghc-http-types)
-       ("ghc-network" ,ghc-network)
-       ("ghc-wai" ,ghc-wai)))
-    (home-page "https://hackage.haskell.org/package/wai-logger")
-    (synopsis "Logging system for WAI")
-    (description "This package provides the logging system for WAI.")
-    (license license:bsd-3)))
-
-(define-public ghc-wai-extra
-  (package
-    (name "ghc-wai-extra")
-    (version "3.0.13.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/wai-extra/wai-extra-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0mh761a1bayr4ydwqmh3h8ndpi19zqw34mmy49lp2abr70r0nm1p"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
-       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
-       ("ghc-cookie" ,ghc-cookie)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-network" ,ghc-network)
-       ("ghc-lifted-base" ,ghc-lifted-base)
-       ("ghc-streaming-commons" ,ghc-streaming-commons)
-       ("ghc-stringsearch" ,ghc-stringsearch)
-       ("ghc-resourcet" ,ghc-resourcet)
-       ("ghc-fast-logger" ,ghc-fast-logger)
-       ("ghc-wai-logger" ,ghc-wai-logger)
-       ("ghc-zlib" ,ghc-zlib)
-       ("ghc-word8" ,ghc-word8)
-       ("ghc-iproute" ,ghc-iproute)
-       ("ghc-void" ,ghc-void)
-       ("ghc-wai" ,ghc-wai)
-       ("ghc-http-types" ,ghc-http-types)
-       ("ghc-text" ,ghc-text)
-       ("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-data-default-class" ,ghc-data-default-class)
-       ("ghc-unix-compat" ,ghc-unix-compat)
-       ("ghc-vault" ,ghc-vault)
-       ("ghc-aeson" ,ghc-aeson)))
-    (native-inputs
-     `(("hspec-discover" ,hspec-discover)
-       ("ghc-hspec" ,ghc-hspec)
-       ("ghc-hunit" ,ghc-hunit)))
-    (home-page "https://github.com/yesodweb/wai")
-    (synopsis "Some basic WAI handlers and middleware")
-    (description "This library provides basic WAI handlers and middleware
-functionality.")
-    (license license:expat)))
-
 (define-public ghc-deepseq-generics
   (package
     (name "ghc-deepseq-generics")
@@ -5301,38 +4844,6 @@ info for more informative bug reports.")
 template-haskell abstract syntax.")
     (license license:bsd-3)))
 
-(define-public ghc-aeson-qq
-  (package
-    (name "ghc-aeson-qq")
-    (version "0.8.1")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "aeson-qq/aeson-qq-" version ".tar.gz"))
-              (sha256
-               (base32
-                "1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
-    (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)
-       ("hspec-discover" ,hspec-discover)))
-    (home-page "https://github.com/zalora/aeson-qq")
-    (synopsis "JSON quasiquoter for Haskell")
-    (description
-     "aeson-qq provides a JSON quasiquoter for Haskell.  This package exposes
-the function @code{aesonQQ} that compile-time converts a string representation
-of a JSON value into a @code{Data.Aeson.Value}.")
-    (license license:expat)))
-
 (define-public ghc-conduit
   (package
     (name "ghc-conduit")
@@ -5578,68 +5089,6 @@ libraries, like OpenSSL.")
 described in @url{http://www.lua.org/}.")
     (license license:expat)))
 
-(define-public ghc-mime-types
-  (package
-    (name "ghc-mime-types")
-    (version "0.1.0.6")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "mime-types/mime-types-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw"))))
-    (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
-     "This library provides basic MIME type handling types and functions.")
-    (license license:expat)))
-
-(define-public ghc-http-client
-  (package
-    (name "ghc-http-client")
-    (version "0.5.6.1")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "http-client/http-client-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "1v9bdb8dkhb5g6jl9azk86ig7ia8xh9arr64n7s8r94fp0vl6c1c"))))
-    (build-system haskell-build-system)
-    ;; Tests require access to the web.
-    (arguments `(#:tests? #f))
-    (inputs
-     `(("ghc-text" ,ghc-text)
-       ("ghc-http-types" ,ghc-http-types)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-data-default-class" ,ghc-data-default-class)
-       ("ghc-network" ,ghc-network)
-       ("ghc-streaming-commons" ,ghc-streaming-commons)
-       ("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
-       ("ghc-cookie" ,ghc-cookie)
-       ("ghc-exceptions" ,ghc-exceptions)
-       ("ghc-random" ,ghc-random)
-       ("ghc-mime-types" ,ghc-mime-types)
-       ("ghc-network-uri" ,ghc-network-uri)
-       ("ghc-monad-control" ,ghc-monad-control)
-       ("ghc-zlib" ,ghc-zlib)
-       ("ghc-async" ,ghc-async)))
-    (native-inputs
-     `(("ghc-hspec" ,ghc-hspec)))
-    (home-page "https://github.com/snoyberg/http-client")
-    (synopsis "HTTP client engine")
-    (description
-     "This package provides an HTTP client engine, intended as a base layer
-for more user-friendly packages.")
-    (license license:expat)))
-
 (define-public ghc-byteable
   (package
     (name "ghc-byteable")
@@ -6081,38 +5530,6 @@ needs.  It provides a very simple API to create sockets to a destination with
 the choice of SSL/TLS, and SOCKS.")
     (license license:bsd-3)))
 
-(define-public ghc-http-client-tls
-  (package
-    (name "ghc-http-client-tls")
-    (version "0.3.4.1")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "http-client-tls/http-client-tls-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "1mbwdfn4hs8lcwml2l6xv4n068l9zlasyv6vwb2ylgm030pyv3xh"))))
-    (build-system haskell-build-system)
-    ;; Tests require Internet access
-    (arguments `(#:tests? #f))
-    (inputs
-     `(("ghc-data-default-class" ,ghc-data-default-class)
-       ("ghc-http-client" ,ghc-http-client)
-       ("ghc-connection" ,ghc-connection)
-       ("ghc-network" ,ghc-network)
-       ("ghc-tls" ,ghc-tls)
-       ("ghc-http-types" ,ghc-http-types)))
-    (native-inputs
-     `(("ghc-hspec" ,ghc-hspec)))
-    (home-page "https://github.com/snoyberg/http-client")
-    (synopsis "Backend for http-client using the TLS library")
-    (description
-     "This package provides a backend for the http-client package using the
-connection and TLS libraries.  It is intended for use by higher-level
-libraries, such as http-conduit.")
-    (license license:expat)))
-
 (define-public ghc-pandoc
   (package
     (name "ghc-pandoc")
@@ -7975,58 +7392,6 @@ advanced user's otherwise working script to fail under future circumstances.
 @end enumerate")
     (license license:gpl3+)))
 
-(define-public ghc-wai-conduit
-  (package
-    (name "ghc-wai-conduit")
-    (version "3.0.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "wai-conduit-" version "/"
-                           "wai-conduit-" version ".tar.gz"))
-       (sha256
-        (base32
-         "1zvsiwjq2mvkb9sjgp3ly9m968m7a2jjzr4id6jpi3mmqykj15z4"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-conduit" ,ghc-conduit)
-       ("ghc-http-types" ,ghc-http-types)
-       ("ghc-wai" ,ghc-wai)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)))
-    (home-page "https://github.com/yesodweb/wai")
-    (synopsis "Conduit wrappers for Haskell's WAI")
-    (description "This package provides data streaming abstraction for
-Haskell's Web Application Interface (WAI).")
-    (license license:expat)))
-
-(define-public ghc-http-date
-  (package
-    (name "ghc-http-date")
-    (version "0.0.6.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "http-date-" version "/"
-                           "http-date-" version ".tar.gz"))
-       (sha256
-        (base32
-         "0dknh28kyarnzqrsc80ssalxjrq0qbv7ir49247p2grb7rh0dqgj"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-attoparsec" ,ghc-attoparsec)))
-    (native-inputs
-     `(("ghc-doctest" ,ghc-doctest)
-       ("ghc-hspec" ,ghc-hspec)
-       ("hspec-discover" ,hspec-discover)
-       ("ghc-old-locale" ,ghc-old-locale)))
-    (home-page "https://github.com/kazu-yamamoto/http-date")
-    (synopsis "HTTP Date parser/formatter")
-    (description "Library for Parsing and formatting HTTP
-Date in Haskell.")
-    (license license:bsd-3)))
-
 (define-public ghc-simple-sendfile
   (package
     (name "ghc-simple-sendfile")
@@ -8170,182 +7535,6 @@ Typical applications of Priority Search Queues include:
 matching patterns against file paths.")
     (license license:bsd-3)))
 
-(define-public ghc-http2
-  (package
-    (name "ghc-http2")
-    (version "1.6.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "http2-" version "/"
-                           "http2-" version ".tar.gz"))
-       (sha256
-        (base32
-         "0hww0rfsv6lqx62qzycbcqy5q6rh9k09qkyjkdm5m1sp1z50wqk1"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
-       ("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-aeson" ,ghc-aeson)
-       ("ghc-aeson-pretty" ,ghc-aeson-pretty)
-       ("ghc-hex" ,ghc-hex)
-       ("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)))
-    (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
-and HPACK.  Currently HTTP/2 16 framing and HPACK 10 is supported.")
-    (license license:bsd-3)))
-
-(define-public ghc-warp
-  (package
-    (name "ghc-warp")
-    (version "3.2.11.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "warp-" version "/" "warp-" version
-                           ".tar.gz"))
-       (sha256
-        (base32
-         "1zp5cy0bbj508vdvms1n5z80z37m253kwsqc5a83cfc990n6fgw5"))))
-    (build-system haskell-build-system)
-    (arguments
-     `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
-    (inputs
-     `(("ghc-async" ,ghc-async)
-       ("ghc-auto-update" ,ghc-auto-update)
-       ("ghc-blaze-builder" ,ghc-blaze-builder)
-       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
-       ("ghc-case-insensitive" ,ghc-case-insensitive)
-       ("ghc-hashable" ,ghc-hashable)
-       ("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)
-       ("ghc-word8" ,ghc-word8)
-       ("ghc-lifted-base" ,ghc-lifted-base)
-       ("ghc-http-date" ,ghc-http-date)
-       ("ghc-simple-sendfile" ,ghc-simple-sendfile)
-       ("ghc-http2" ,ghc-http2)))
-    (native-inputs
-     `(("ghc-silently" ,ghc-silently)
-       ("ghc-hspec" ,ghc-hspec)
-       ("ghc-auto-update" ,ghc-auto-update)
-       ("ghc-doctest" ,ghc-doctest)
-       ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-http" ,ghc-http)
-       ("hspec-discover" ,hspec-discover)))
-    (home-page "http://github.com/yesodweb/wai")
-    (synopsis "HTTP server library for Haskell's WAI")
-    (description "Warp is a server library for HTTP/1.x and HTTP/2
-based WAI (Web Application Interface in Haskell).")
-    (license license:expat)))
-
-(define-public ghc-warp-tls
-  (package
-    (name "ghc-warp-tls")
-    (version "3.2.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "warp-tls-" version "/"
-                           "warp-tls-" version ".tar.gz"))
-       (sha256
-        (base32
-         "14m2bzk5ivz9gdpxlcj6qnh46f2lycm1ybdjnfkj2876zrqwii7m"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-cryptonite" ,ghc-cryptonite)
-       ("ghc-data-default-class" ,ghc-data-default-class)
-       ("ghc-network" ,ghc-network)
-       ("ghc-streaming-commons" ,ghc-streaming-commons)
-       ("ghc-tls" ,ghc-tls)
-       ("ghc-wai" ,ghc-wai)
-       ("ghc-warp" ,ghc-warp)))
-    (home-page "http://github.com/yesodweb/wai")
-    (synopsis "SSL/TLS support for Warp")
-    (description "This package provides SSL/TLS support for Warp,
-a WAI handler, via the native Haskell TLS implementation.")
-    (license license:expat)))
-
-(define-public ghc-http-conduit
-  (package
-    (name  "ghc-http-conduit")
-    (version "2.2.3.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "http-conduit-" version "/" "http-conduit-"
-                           version ".tar.gz"))
-       (sha256 (base32
-                "03na2nbm9la0shlijvjyb5mpp1prfskk4jmjy8iz707r0731dbjk"))))
-    (build-system haskell-build-system)
-    ;; FIXME: `httpLbs TLS` in test-suite `test` fails with
-    ;; ConnectionFailure getProtocolByName: does not exist (no such protocol
-    ;; name: tcp)
-    (arguments `(#:tests? #f))
-    (inputs
-     `(("ghc-aeson" ,ghc-aeson)
-       ("ghc-resourcet" ,ghc-resourcet)
-       ("ghc-conduit" ,ghc-conduit)
-       ("ghc-conduit-extra" ,ghc-conduit-extra)
-       ("ghc-http-types" ,ghc-http-types)
-       ("ghc-lifted-base" ,ghc-lifted-base)
-       ("ghc-http-client" ,ghc-http-client)
-       ("ghc-http-client-tls" ,ghc-http-client-tls)
-       ("ghc-monad-control" ,ghc-monad-control)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-exceptions" ,ghc-exceptions)))
-    (native-inputs
-     `(("ghc-hunit" ,ghc-hunit)
-       ("ghc-hspec" ,ghc-hspec)
-       ("ghc-data-default-class" ,ghc-data-default-class)
-       ("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)
-       ("ghc-lifted-base" ,ghc-lifted-base)
-       ("ghc-network" ,ghc-network)
-       ("ghc-wai" ,ghc-wai)
-       ("ghc-warp" ,ghc-warp)
-       ("ghc-wai-conduit" ,ghc-wai-conduit)
-       ("ghc-http-types" ,ghc-http-types)
-       ("ghc-http-client" ,ghc-http-client)
-       ("ghc-cookie" ,ghc-cookie)
-       ("ghc-conduit-extra" ,ghc-conduit-extra)
-       ("ghc-streaming-commons" ,ghc-streaming-commons)
-       ("ghc-aeson" ,ghc-aeson)
-       ("ghc-temporary" ,ghc-temporary)
-       ("ghc-resourcet" ,ghc-resourcet)))
-    (home-page "https://hackage.haskell.org/package/http-conduit")
-    (synopsis "HTTP/HTTPS client with conduit interface")
-    (description "This library uses attoparsec for parsing the actual
-contents of the HTTP connection.  It also provides higher-level functions
-which allow you to avoid direct usage of conduits.")
-    (license license:bsd-3)))
-
 (define-public ghc-errors
   (package
     (name "ghc-errors")
diff --git a/gnu/packages/idris.scm b/gnu/packages/idris.scm
index 438e582fe3..6eb940c9d5 100644
--- a/gnu/packages/idris.scm
+++ b/gnu/packages/idris.scm
@@ -20,6 +20,7 @@
 (define-module (gnu packages idris)
   #:use-module (gnu packages haskell)
   #:use-module (gnu packages haskell-check)
+  #:use-module (gnu packages haskell-web)
   #:use-module (gnu packages multiprecision)
   #:use-module (gnu packages ncurses)
   #:use-module (guix build-system gnu)
diff --git a/gnu/packages/version-control.scm b/gnu/packages/version-control.scm
index 6ef3f8b060..8e71a11427 100644
--- a/gnu/packages/version-control.scm
+++ b/gnu/packages/version-control.scm
@@ -60,6 +60,7 @@
   #:use-module (gnu packages groff)
   #:use-module (gnu packages haskell)
   #:use-module (gnu packages haskell-check)
+  #:use-module (gnu packages haskell-web)
   #:use-module (gnu packages java)
   #:use-module (gnu packages linux)
   #:use-module (gnu packages nano)
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index cdffb0d852..599d5ad34e 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -43,6 +43,7 @@
   #:use-module (guix build-system python)
   #:use-module (gnu packages haskell)
   #:use-module (gnu packages haskell-check)
+  #:use-module (gnu packages haskell-web)
   #:use-module (gnu packages base)
   #:use-module (gnu packages pkg-config)
   #:use-module (gnu packages perl)