20 files changed, 6882 insertions, 6514 deletions

diff --git a/gnu/packages/bioinformatics.scm b/gnu/packages/bioinformatics.scm
index b5d132749f..2b20191bb3 100644
--- a/gnu/packages/bioinformatics.scm
+++ b/gnu/packages/bioinformatics.scm
@@ -14823,110 +14823,121 @@ datasets.")
 (define-public ngless
   (package
     (name "ngless")
-    (version "1.3.0")
-    (source
-     (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://github.com/ngless-toolkit/ngless.git")
-             (commit (string-append "v" version))))
-       (file-name (git-file-name name version))
-       (sha256
-        (base32
-         "0pb9f6b0yk9p4cdwiym8r190q1bcdiwvc7i2s6rw54qgi8r3g6pj"))
-       (patches (search-patches "ngless-unliftio.patch"))))
+    (version "1.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "NGLess" version))
+              (sha256
+               (base32
+                "0pljyrlpr9r3cl5311dhgxdl8y40szyi4vprn34i3piy0qrldymi"))))
     (build-system haskell-build-system)
     (arguments
-     (list
-      #:haddock? #f    ;The haddock phase fails with: NGLess/CmdArgs.hs:20:1:
-                       ;error: parse error on input import
-                       ;import Options.Applicative
-      #:phases
-      #~(modify-phases %standard-phases
-          (add-after 'unpack 'create-Versions.hs
-            (lambda _
-              (substitute* "Makefile"
-                (("BWA_VERSION = .*")
-                 (string-append "BWA_VERSION = "
-                                #$(package-version bwa) "\n"))
-                (("SAM_VERSION = .*")
-                 (string-append "SAM_VERSION = "
-                                #$(package-version samtools) "\n"))
-                (("PRODIGAL_VERSION = .*")
-                 (string-append "PRODIGAL_VERSION = "
-                                #$(package-version prodigal) "\n"))
-                (("MINIMAP2_VERSION = .*")
-                 (string-append "MINIMAP2_VERSION = "
-                                #$(package-version minimap2) "\n")))
-              (invoke "make" "NGLess/Dependencies/Versions.hs")))
-          (add-after 'create-Versions.hs 'create-cabal-file
-            (lambda _ (invoke "hpack")))
-          ;; These tools are expected to be installed alongside ngless.
-          (add-after 'install 'link-tools
-            (lambda* (#:key inputs #:allow-other-keys)
-              (let ((bin (string-append #$output "/bin/")))
-                (symlink (search-input-file inputs "/bin/prodigal")
-                         (string-append bin "ngless-" #$version "-prodigal"))
-                (symlink (search-input-file inputs "/bin/minimap2")
-                         (string-append bin "ngless-" #$version "-minimap2"))
-                (symlink (search-input-file inputs "/bin/samtools")
-                         (string-append bin "ngless-" #$version "-samtools"))
-                (symlink (search-input-file inputs "/bin/bwa")
-                         (string-append bin "ngless-" #$version "-bwa"))))))))
-    (inputs
-     (list prodigal
-           bwa
-           samtools
-           minimap2
-           ghc-aeson
-           ghc-ansi-terminal
-           ghc-async
-           ghc-atomic-write
-           ghc-bytestring-lexing
-           ghc-conduit
-           ghc-conduit-algorithms
-           ghc-conduit-extra
-           ghc-configurator
-           ghc-convertible
-           ghc-data-default
-           ghc-diagrams-core
-           ghc-diagrams-lib
-           ghc-diagrams-svg
-           ghc-double-conversion
-           ghc-edit-distance
-           ghc-either
-           ghc-errors
-           ghc-extra
-           ghc-filemanip
-           ghc-file-embed
-           ghc-gitrev
-           ghc-hashtables
-           ghc-http-conduit
-           ghc-inline-c
-           ghc-inline-c-cpp
-           ghc-int-interval-map
-           ghc-missingh
-           ghc-optparse-applicative
-           ghc-regex
-           ghc-safe
-           ghc-safeio
-           ghc-strict
-           ghc-tar
-           ghc-tar-conduit
-           ghc-unliftio
-           ghc-unliftio-core
-           ghc-vector
-           ghc-yaml
-           ghc-zlib))
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "NGLess.cabal"
+               (("\\b(base)\\s+[^,]+" all dep)
+                dep))))
+         (add-after 'unpack 'create-Versions.hs
+           (lambda _
+             (substitute* "NGLess/Dependencies/Versions.hs"
+               (("bwaVersion = .+")
+                (string-append "bwaVersion = \""
+                               ,(package-version bwa) "\""))
+               (("samtoolsVersion = .+")
+                (string-append "samtoolsVersion = \""
+                               ,(package-version samtools) "\""))
+               (("prodigalVersion = .+")
+                (string-append "prodigalVersion = \""
+                               ,(package-version prodigal) "\""))
+               (("megahitVersion = .+")
+                (string-append "megahitVersion = \""
+                               ,(package-version megahit) "\""))
+               (("minimap2Version = .+")
+                (string-append "minimap2Version = \""
+                               ,(package-version minimap2) "\"")))))
+         ;; See NGLess/FileManagement.hs.
+         (add-after 'install 'wrap-program
+             (lambda* (#:key inputs outputs #:allow-other-keys)
+               (let* ((out (assoc-ref outputs "out"))
+                      (bwa (search-input-file inputs "/bin/bwa"))
+                      (samtools (search-input-file inputs "/bin/samtools"))
+                      (prodigal (search-input-file inputs "/bin/prodigal"))
+                      (minimap2 (search-input-file inputs "/bin/minimap2"))
+                      (megahit (search-input-file inputs "/bin/megahit")))
+                 (wrap-program (string-append out "/bin/ngless")
+                   `("NGLESS_BWA_BIN" " " = (,bwa))
+                   `("NGLESS_SAMTOOLS_BIN" " " = (,samtools))
+                   `("NGLESS_PRODIGAL_BIN" " " = (,prodigal))
+                   `("NGLESS_MINIMAP2_BIN" " " = (,minimap2))
+                   `("NGLESS_MEGAHIT_BIN" " " = (,megahit))))))
+          ;; Sanity check.
+          (add-after 'wrap-program 'check-install
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let* ((ngless (string-append (assoc-ref outputs "out") "/bin/ngless")))
+                 (invoke ngless "--check-install")))))))
+    (inputs (list prodigal
+                  bwa
+                  samtools
+                  minimap2
+                  megahit
+                  ghc-missingh
+                  ghc-aeson
+                  ghc-ansi-terminal
+                  ghc-async
+                  ghc-atomic-write
+                  ghc-bytestring-lexing
+                  ghc-conduit
+                  ghc-conduit-algorithms
+                  ghc-conduit-extra
+                  ghc-configurator
+                  ghc-convertible
+                  ghc-data-default
+                  ghc-edit-distance
+                  ghc-either
+                  ghc-errors
+                  ghc-extra
+                  ghc-file-embed
+                  ghc-filemanip
+                  ghc-hashable
+                  ghc-hashtables
+                  ghc-hostname
+                  ghc-http-client
+                  ghc-http-conduit
+                  ghc-inline-c
+                  ghc-inline-c-cpp
+                  ghc-int-interval-map
+                  ghc-network
+                  ghc-optparse-applicative
+                  ghc-primitive
+                  ghc-random-shuffle
+                  ghc-regex
+                  ghc-resourcet
+                  ghc-safe
+                  ghc-stm-chans
+                  ghc-stm-conduit
+                  ghc-strict
+                  ghc-tar
+                  ghc-tar-conduit
+                  ghc-unix-compat
+                  ghc-unliftio
+                  ghc-unliftio-core
+                  ghc-vector
+                  ghc-vector-algorithms
+                  ghc-yaml
+                  ghc-zlib
+                  ghc-bzlib-conduit
+                  ghc-double-conversion
+                  ghc-safeio))
     (propagated-inputs
      (list r-r6 r-hdf5r r-iterators r-itertools r-matrix))
-    (native-inputs
-     (list ghc-hpack
-           ghc-quickcheck
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2
-           ghc-test-framework-th))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-tasty-th))
     (home-page "https://ngless.embl.de/")
     (synopsis "DSL for processing next-generation sequencing data")
     (description "Ngless is a domain-specific language for
diff --git a/gnu/packages/dhall.scm b/gnu/packages/dhall.scm
index 9e80abb08a..e84ee7647f 100644
--- a/gnu/packages/dhall.scm
+++ b/gnu/packages/dhall.scm
@@ -30,108 +30,76 @@
 (define-public dhall
   (package
     (name "dhall")
-    (version "1.39.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "dhall" version))
-       (sha256
-        (base32 "1by2d84fbckspczddl4npfsf89q6nprmbg0i5g8yr1psp0fpl4ab"))))
+    (version "1.41.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "dhall" version))
+              (sha256
+               (base32
+                "14m5rrvkid76qnvg0l14xw1mnqclhip3gjrz20g1lp4fd5p056ka"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "dhall")))
-    (inputs
-     (list ghc-aeson
-           ghc-aeson-pretty
-           ghc-ansi-terminal
-           ghc-atomic-write-0.2.0.7
-           ghc-case-insensitive
-           ghc-cborg
-           ghc-cborg-json
-           ghc-contravariant
-           ghc-data-fix
-           ghc-diff
-           ghc-dotgen
-           ghc-either
-           ghc-exceptions
-           ghc-half
-           ghc-hashable
-           ghc-lens-family-core
-           ghc-megaparsec
-           ghc-memory
-           ghc-mmorph
-           ghc-network-uri
-           ghc-optparse-applicative
-           ghc-parsers
-           ghc-parser-combinators
-           ghc-prettyprinter
-           ghc-prettyprinter-ansi-terminal
-           ghc-pretty-simple
-           ghc-profunctors
-           ghc-pretty-simple
-           ghc-repline
-           ghc-serialise
-           ghc-scientific
-           ghc-text-manipulate
-           ghc-th-lift-instances
-           ghc-transformers-compat
-           ghc-unordered-containers
-           ghc-uri-encode
-           ghc-vector
-           ghc-cryptonite
-           ghc-http-types
-           ghc-http-client
-           ghc-http-client-tls))
-    (native-inputs
-     (list ghc-foldl
-           ghc-generic-random-1.3.0.1
-           ghc-quickcheck
-           ghc-quickcheck-instances
-           ghc-semigroups
-           ghc-special-values
-           ghc-spoon
-           ghc-tasty
-           ghc-tasty-expected-failure
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck
-           ghc-tasty-silver
-           ghc-turtle
-           ghc-mockery
-           ghc-doctest))
+    (inputs (list ghc-aeson
+                  ghc-aeson-pretty
+                  ghc-ansi-terminal
+                  ghc-atomic-write
+                  ghc-base16-bytestring
+                  ghc-case-insensitive
+                  ghc-cborg
+                  ghc-cborg-json
+                  ghc-contravariant
+                  ghc-data-fix
+                  ghc-diff
+                  ghc-dotgen
+                  ghc-either
+                  ghc-half
+                  ghc-hashable
+                  ghc-indexed-traversable
+                  ghc-lens-family-core
+                  ghc-megaparsec
+                  ghc-mmorph
+                  ghc-network-uri
+                  ghc-optparse-applicative
+                  ghc-parsers
+                  ghc-parser-combinators
+                  ghc-prettyprinter
+                  ghc-prettyprinter-ansi-terminal
+                  ghc-pretty-simple
+                  ghc-profunctors
+                  ghc-repline
+                  ghc-serialise
+                  ghc-scientific
+                  ghc-text-manipulate
+                  ghc-text-short
+                  ghc-th-lift-instances
+                  ghc-unordered-containers
+                  ghc-uri-encode
+                  ghc-vector
+                  ghc-cryptohash-sha256
+                  ghc-http-types
+                  ghc-http-client
+                  ghc-http-client-tls))
+    (native-inputs (list ghc-foldl
+                         ghc-generic-random
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-special-values
+                         ghc-spoon
+                         ghc-system-filepath
+                         ghc-tasty
+                         ghc-tasty-expected-failure
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-tasty-silver
+                         ghc-temporary
+                         ghc-turtle
+                         ghc-mockery
+                         ghc-doctest))
     (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'remove-network-tests
-           (lambda _
-             (with-directory-excursion "dhall-lang/tests"
-               (for-each
-                delete-file
-                '("import/success/customHeadersA.dhall"
-                  "import/success/noHeaderForwardingA.dhall"
-                  "import/success/unit/RemoteAsTextA.dhall"
-                  "import/success/unit/SimpleRemoteA.dhall"
-                  "import/success/unit/asLocation/RemoteChain1A.dhall"
-                  "import/success/unit/asLocation/RemoteChain2A.dhall"
-                  "import/success/unit/asLocation/RemoteChain3A.dhall"
-                  "import/success/unit/asLocation/RemoteChainEnvA.dhall"
-                  "import/success/unit/asLocation/RemoteChainMissingA.dhall"
-                  "type-inference/success/CacheImportsA.dhall"
-                  "type-inference/success/CacheImportsCanonicalizeA.dhall")))
-             (substitute* "src/Dhall/Tutorial.hs"
-               (((string-append
-                  "-- >>> input auto "
-                  "\"https://raw.githubusercontent.com/dhall-lang"
-                  "/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/"
-                  "examples/True\" :: IO Bool"))
-                "")
-               (((string-append
-                  "-- >>> input auto "
-                  "\"False == "
-                  "https://raw.githubusercontent.com/dhall-lang"
-                  "/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/"
-                  "examples/True\" :: IO Bool"))
-                ""))
-             #t)))))
-    (home-page "https://dhall-lang.org/")
+     `(#:tests? #f ; Tries to access httpbin.org
+       #:cabal-revision ("4"
+                         "0innb3cn98ynb8bd83jdyrm64ij7wcvajg5qcwzdwbyzpr62anfx")))
+    (home-page "http://hackage.haskell.org/package/dhall")
     (synopsis "Configuration language guaranteed to terminate")
     (description
      "Dhall is an explicitly typed configuration language that is not Turing
diff --git a/gnu/packages/elm.scm b/gnu/packages/elm.scm
index 12c7e8301b..6d301cf51c 100644
--- a/gnu/packages/elm.scm
+++ b/gnu/packages/elm.scm
@@ -70,7 +70,7 @@
           (add-before 'configure 'update-constraints
             (lambda _
               (substitute* "elm.cabal"
-                (("(ansi-terminal|containers|network|http-client|language-glsl)\\s+[^,]+" all dep)
+                (("(ansi-terminal|bytestring|containers|network|HTTP|http-client|language-glsl)\\s+[^,]+" all dep)
                  dep)))))))
     (inputs
      (list ghc-ansi-terminal
diff --git a/gnu/packages/finance.scm b/gnu/packages/finance.scm
index ea3b7c8577..192d1d2817 100644
--- a/gnu/packages/finance.scm
+++ b/gnu/packages/finance.scm
@@ -217,14 +217,13 @@ line client and a client based on Qt.")
 (define-public hledger
   (package
     (name "hledger")
-    (version "1.21")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hledger" version))
-       (sha256
-        (base32
-         "07fcfkmv4cy92njnf2qc7jh0naz96q962hxldcd7hk4k7ddv0mss"))))
+    (version "1.27.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hledger" version))
+              (sha256
+               (base32
+                "0qdg87m7ys2ykqqq32p7h7aw827w4f5bcqx4dspxxq6zqlvzddqb"))))
     (build-system haskell-build-system)
     (arguments
      (list
@@ -235,34 +234,34 @@ line client and a client based on Qt.")
               (install-file "hledger.info" (string-append #$output "/share/info"))
               (install-file "hledger.1" (string-append #$output "/man/man1")))))))
     (properties '((upstream-name . "hledger")))
-    (inputs
-     (list ghc-ansi-terminal
-           ghc-base-compat-batteries
-           ghc-cmdargs
-           ghc-data-default
-           ghc-decimal
-           ghc-diff
-           ghc-hashable
-           ghc-hledger-lib
-           ghc-lucid
-           ghc-math-functions
-           ghc-megaparsec
-           ghc-old-time
-           ghc-regex-tdfa
-           ghc-safe
-           ghc-aeson
-           ghc-extra
-           ghc-tasty
-           ghc-timeit
-           ghc-shakespeare
-           ghc-split
-           ghc-tabular
-           ghc-temporary
-           ghc-unordered-containers
-           ghc-utf8-string
-           ghc-utility-ht
-           ghc-wizards))
-    (home-page "https://hledger.org")
+    (inputs (list ghc-decimal
+                  ghc-diff
+                  ghc-aeson
+                  ghc-ansi-terminal
+                  ghc-breakpoint
+                  ghc-cmdargs
+                  ghc-data-default
+                  ghc-extra
+                  ghc-githash
+                  ghc-hashable
+                  ghc-hledger-lib
+                  ghc-lucid
+                  ghc-math-functions
+                  ghc-megaparsec
+                  ghc-microlens
+                  ghc-regex-tdfa
+                  ghc-safe
+                  ghc-shakespeare
+                  ghc-split
+                  ghc-tabular
+                  ghc-tasty
+                  ghc-temporary
+                  ghc-timeit
+                  ghc-unordered-containers
+                  ghc-utf8-string
+                  ghc-utility-ht
+                  ghc-wizards))
+    (home-page "http://hledger.org")
     (synopsis "Command-line interface for the hledger accounting system")
     (description
      "The command-line interface for the hledger accounting system.  Its basic
@@ -1969,59 +1968,63 @@ generate a variety of reports from them, and provides a web interface.")
 (define-public hledger-web
   (package
     (name "hledger-web")
-    (version "1.21")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hledger-web" version))
-       (sha256
-        (base32
-         "0ivszqcypw0j2wn4r7fv7dqm1pvr0b1y6rqpxagzyk8cxn3ic9g2"))))
+    (version "1.27.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hledger-web" version))
+              (sha256
+               (base32
+                "151dxci7dld8626dzw823sr3d9iaac92wfzbfcbdz4jh9f7n07wa"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hledger-web")))
+    (inputs (list ghc-decimal
+                  ghc-aeson
+                  ghc-base64
+                  ghc-blaze-html
+                  ghc-blaze-markup
+                  ghc-breakpoint
+                  ghc-case-insensitive
+                  ghc-clientsession
+                  ghc-cmdargs
+                  ghc-conduit
+                  ghc-conduit-extra
+                  ghc-data-default
+                  ghc-extra
+                  ghc-hjsmin
+                  hledger
+                  ghc-hledger-lib
+                  ghc-hspec
+                  ghc-http-client
+                  ghc-http-conduit
+                  ghc-http-types
+                  ghc-megaparsec
+                  ghc-network
+                  ghc-shakespeare
+                  ghc-unix-compat
+                  ghc-unordered-containers
+                  ghc-utf8-string
+                  ghc-wai
+                  ghc-wai-cors
+                  ghc-wai-extra
+                  ghc-wai-handler-launch
+                  ghc-warp
+                  ghc-yaml
+                  ghc-yesod
+                  ghc-yesod-core
+                  ghc-yesod-form
+                  ghc-yesod-static
+                  ghc-yesod-test))
     (arguments
-     `(#:tests? #f ; TODO: fail.
-       #:cabal-revision
-       ("1" "1hnw10ibhbafbsfj5lzlxwjg4cjnqr5bb51n6mqbi30qqabgq78x")))
-    (inputs
-     (list ghc-aeson
-           ghc-blaze-html
-           ghc-blaze-markup
-           ghc-case-insensitive
-           ghc-clientsession
-           ghc-cmdargs
-           ghc-conduit-extra
-           ghc-conduit
-           ghc-data-default
-           ghc-decimal
-           ghc-extra
-           ghc-hjsmin
-           ghc-hledger-lib
-           ghc-hspec
-           ghc-http-client
-           ghc-http-conduit
-           ghc-http-types
-           ghc-megaparsec
-           ghc-network
-           ghc-shakespeare
-           ghc-unix-compat
-           ghc-unordered-containers
-           ghc-utf8-string
-           ghc-wai-cors
-           ghc-wai-extra
-           ghc-wai
-           ghc-wai-handler-launch
-           ghc-warp
-           ghc-yaml
-           ghc-yesod-core
-           ghc-yesod-form
-           ghc-yesod
-           ghc-yesod-static
-           ghc-yesod-test
-           hledger))
-    (home-page "https://hledger.org")
+     (list #:phases
+           #~(modify-phases %standard-phases
+               ;; Tests write to $HOME.
+               (add-before 'check 'set-home
+                 (lambda _
+                   (setenv "HOME" "/tmp"))))))
+    (home-page "http://hledger.org")
     (synopsis "Web-based user interface for the hledger accounting system")
-    (description "This package provides a simple Web-based User
+    (description
+     "This package provides a simple Web-based User
 Interface (UI) for the hledger accounting system.  It can be used as a
 local, single-user UI, or as a multi-user UI for viewing, adding, and
 editing on the Web.")
diff --git a/gnu/packages/haskell-apps.scm b/gnu/packages/haskell-apps.scm
index 4e680e612b..5a6bae5281 100644
--- a/gnu/packages/haskell-apps.scm
+++ b/gnu/packages/haskell-apps.scm
@@ -61,29 +61,27 @@
 (define-public apply-refact
   (package
     (name "apply-refact")
-    (version "0.9.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "apply-refact" version))
-       (sha256
-        (base32
-         "1sn5g71sx8xa4ggyk49m661iip6zrzl65vb87l16l31kf79bbm7w"))))
+    (version "0.10.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "apply-refact" version))
+              (sha256
+               (base32
+                "129bf8n66kpwh5420rxprngg43bqr2agyd8q8d7l49k2rxsjl1fb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "apply-refact")))
-    (inputs
-     (list ghc-refact
-           ghc-exactprint
-           ghc-syb
-           ghc-extra
-           ghc-uniplate
-           ghc-filemanip
-           ghc-unix-compat
-           ghc-optparse-applicative))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-golden ghc-tasty-expected-failure
-           ghc-silently))
-    (home-page "https://hackage.haskell.org/package/apply-refact")
+    (inputs (list ghc-refact
+                  ghc-exactprint
+                  ghc-paths
+                  ghc-extra
+                  ghc-syb
+                  ghc-filemanip
+                  ghc-uniplate
+                  ghc-unix-compat
+                  ghc-optparse-applicative))
+    (native-inputs (list ghc-tasty ghc-tasty-golden ghc-tasty-expected-failure
+                         ghc-silently))
+    (home-page "https://github.com/mpickering/apply-refact")
     (synopsis "Perform refactorings specified by the refact library")
     (description
      "This package lets you perform refactorings specified by the refact
@@ -94,43 +92,36 @@ library.  It is primarily used with HLint's @code{--refactor} flag.")
 ;; update this packages after updating GHC.
 (define-public cabal-install
  (package
-  (name "cabal-install")
-   (version "3.2.0.0")
-   (source
-    (origin
-     (method url-fetch)
-      (uri (hackage-uri "cabal-install" version))
-      (patches (search-patches "cabal-install-base16-bytestring1.0.patch"
-                               "cabal-install-ghc8.10.patch"))
-      (sha256
-       (base32 "1c0cc256bha97aj7l0lf76l5swlnmwcqppiz8l4cl5xgba4mwmd0"))))
+   (name "cabal-install")
+   (version "3.6.2.0")
+   (source (origin
+             (method url-fetch)
+             (uri (hackage-uri "cabal-install" version))
+             (sha256
+              (base32
+               "0dihpm4h3xh13vnpvwflnb7v614qdvljycc6ffg5cvhwbwfrxyfw"))))
    (build-system haskell-build-system)
    (properties '((upstream-name . "cabal-install")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "cabal-install.cabal"
-               (("(base|base16-bytestring|random)\\s+[^,]+" all dep)
-                dep)))))))
-   (inputs
-    (list ghc-async
-          ghc-base16-bytestring
-          ghc-cryptohash-sha256
-          ghc-echo
-          ghc-edit-distance
-          ghc-hackage-security
-          ghc-hashable
-          ghc-http
-          ghc-network-uri
-          ghc-network
-          ghc-random
-          ghc-resolv
-          ghc-tar
-          ghc-zip-archive
-          ghc-zlib))
-   (home-page "https://www.haskell.org/cabal/")
+   (inputs (list ghc-async
+                 ghc-base16-bytestring
+                 ghc-cryptohash-sha256
+                 ghc-echo
+                 ghc-edit-distance
+                 ghc-hashable
+                 ghc-http
+                 ghc-network-uri
+                 ghc-random
+                 ghc-tar
+                 ghc-zlib
+                 ghc-hackage-security
+                 ghc-regex-base
+                 ghc-regex-posix
+                 ghc-resolv
+                 ghc-lukko))
+   (arguments
+    `(#:cabal-revision ("2"
+                        "1kpgyfl5njxp4c8ax5ziag1bhqvph3h0pn660v3vpxalz8d1j6xv")))
+   (home-page "http://www.haskell.org/cabal/")
    (synopsis "Command-line interface for Cabal and Hackage")
    (description
     "The cabal command-line program simplifies the process of managing
@@ -153,6 +144,9 @@ installation of Haskell libraries and programs.")
     (properties '((upstream-name . "cpphs")))
     (inputs
      (list ghc-polyparse ghc-old-locale ghc-old-time))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1f8jzs8zdh4wwbcq8fy6qqxkv75ypnvsm4yzw49wpr3b9vpnzlha")))
     (home-page "https://projects.haskell.org/cpphs/")
     (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
     (description "Cpphs is a re-implementation of the C pre-processor that is
@@ -170,14 +164,14 @@ unlit literate code files; and an option to turn off macro-expansion.")
 (define-public darcs
   (package
     (name "darcs")
-    (version "2.16.4")
+    (version "2.16.5")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "darcs" version))
        (sha256
         (base32
-         "07dygwh6p4fsrlgxmq6r7yvxmf4n2y04izzd30jzqgs0pi9645p4"))
+         "0ar4markr71l9hzrbgcz4q37cf2rf3936i6qi8p827p36v96qg6n"))
        (modules '((guix build utils)))
        ;; Remove time-dependent code for reproducibility.
        (snippet
@@ -203,57 +197,50 @@ unlit literate code files; and an option to turn off macro-expansion.")
          (add-before 'configure 'update-constraints
            (lambda _
              (substitute* "darcs.cabal"
-               (("(constraints)\\s+[^,]+" all dep)
-                dep)
-               (("(cryptonite)\\s+[^,]+" all dep)
+               (("(attoparsec|base|bytestring|constraints|cryptonite|hashable|memory|regex-tdfa|time)\\s+[^,]+" all dep)
                 dep)))))))
-    (inputs
-     (list ghc-cmdargs
-           ghc-split
-           ghc-test-framework-quickcheck2
-           ghc-test-framework-hunit
-           ghc-test-framework
-           ghc-quickcheck
-           ghc-constraints
-           ghc-findbin
-           ghc-hunit
-           ghc-cryptonite
-           ghc-http-conduit
-           ghc-http-types
-           ghc-async
-           ghc-attoparsec
-           ghc-base16-bytestring
-           ghc-bytestring-builder
-           ghc-cryptohash
-           ghc-data-ordlist
-           ghc-fgl
-           ghc-system-filepath
-           ghc-graphviz
-           ghc-hashable
-           ghc-html
-           ghc-mmap
-           ghc-old-time
-           ghc-random
-           ghc-regex-applicative
-           ghc-regex-compat-tdfa
-           ghc-sandi
-           ghc-shelly
-           ghc-tar
-           ghc-transformers-compat
-           ghc-unix-compat
-           ghc-utf8-string
-           ghc-vector
-           ghc-zip-archive
-           ghc-zlib
-           ghc-http
-           curl
-           ghc
-           ncurses
-           perl
-           ghc-network
-           ghc-network-uri))
-    (native-inputs
-     (list pkg-config))
+    (inputs (list ghc-regex-base
+                  ghc-regex-tdfa
+                  ghc-regex-applicative
+                  ghc-fgl
+                  ghc-html
+                  ghc-memory
+                  ghc-cryptonite
+                  ghc-base16-bytestring
+                  ghc-utf8-string
+                  ghc-vector
+                  ghc-tar
+                  ghc-data-ordlist
+                  ghc-attoparsec
+                  ghc-zip-archive
+                  ghc-async
+                  ghc-constraints
+                  ghc-unix-compat
+                  ghc-old-time
+                  ghc-temporary
+                  ghc-hashable
+                  ghc-mmap
+                  ghc-zlib
+                  ghc-network-uri
+                  ghc-network
+                  ghc-conduit
+                  ghc-http-conduit
+                  ghc-http-types
+                  curl))
+    (native-inputs (list ghc-cmdargs
+                         ghc-findbin
+                         ghc-quickcheck
+                         ghc-leancheck
+                         ghc-hunit
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2
+                         ghc-test-framework-leancheck
+                         ghc-monad-control
+                         ghc-system-filepath
+                         ghc-system-fileio
+                         ghc-transformers-base
+                         pkg-config))
     (home-page "http://darcs.net")
     (synopsis "Distributed Revision Control System")
     (description
@@ -509,36 +496,39 @@ used to keep a folder in sync between computers.")
 (define-public hlint
   (package
     (name "hlint")
-    (version "3.2.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hlint" version))
-       (sha256
-        (base32
-         "0z6gxndrh7blzapkdn6fq1pkbkjlmbgjbq9ydnvy2wm00fb3v73g"))))
+    (version "3.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hlint" version))
+              (sha256
+               (base32
+                "0bkk03c9hacvfd73dk89g4r81b50g7pjgw5pavldali4qwss34cz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hlint")))
-    (inputs
-     (list ghc-unordered-containers
-           ghc-yaml
-           ghc-vector
-           ghc-data-default
-           ghc-file-embed
-           ghc-utf8-string
-           cpphs
-           ghc-filepattern
-           ghc-lib-parser-ex
-           hscolour
-           ghc-cmdargs
-           ghc-uniplate
-           ghc-ansi-terminal
-           ghc-extra
-           ghc-refact
-           ghc-aeson))
-    (home-page "https://github.com/ndmitchell/hlint")
+    (inputs (list ghc-unordered-containers
+                  ghc-vector
+                  ghc-file-embed
+                  ghc-utf8-string
+                  ghc-data-default
+                  cpphs
+                  ghc-cmdargs
+                  ghc-uniplate
+                  ghc-ansi-terminal
+                  ghc-extra
+                  ghc-refact
+                  ghc-aeson
+                  ghc-deriving-aeson
+                  ghc-filepattern
+                  ghc-lib-parser-ex
+                  hscolour
+                  ghc-yaml))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1rdaffg5n179yfcn5zjwjb0bki09qy13gz2ijky455y9pbaz8yz9")))
+    (home-page "https://github.com/ndmitchell/hlint#readme")
     (synopsis "Suggest improvements for Haskell source code")
-    (description "HLint reads Haskell programs and suggests changes that
+    (description
+     "HLint reads Haskell programs and suggests changes that
 hopefully make them easier to read.  HLint also makes it easy to disable
 unwanted suggestions, and to add your own custom suggestions.")
     (license license:bsd-3)))
@@ -546,50 +536,50 @@ unwanted suggestions, and to add your own custom suggestions.")
 (define-public hoogle
   (package
     (name "hoogle")
-    (version "5.0.18.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri
-        (hackage-uri "hoogle" version))
-       (sha256
-        (base32
-         "1xacx2f33x1a4qlv25f8rlmb4wi0cjfzrj22nlnkrd0knghik3m7"))))
+    (version "5.0.18.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hoogle" version))
+              (sha256
+               (base32
+                "0v6k75w0an9pqgb7a6cicnpf9rz77xd2lmxfbafc5l4f99jg83bn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hoogle")))
-    (inputs
-     (list ghc-quickcheck
-           ghc-aeson
-           ghc-blaze-html
-           ghc-blaze-markup
-           ghc-cmdargs
-           ghc-conduit
-           ghc-conduit-extra
-           ghc-connection
-           ghc-extra
-           ghc-foundation
-           ghc-old-locale
-           ghc-haskell-src-exts
-           ghc-http-conduit
-           ghc-http-types
-           ghc-js-flot
-           ghc-js-jquery
-           ghc-mmap
-           ghc-process-extras
-           ghc-resourcet
-           ghc-storable-tuple
-           ghc-tar
-           ghc-uniplate
-           ghc-utf8-string
-           ghc-vector
-           ghc-wai
-           ghc-wai-logger
-           ghc-warp
-           ghc-warp-tls
-           ghc-zlib))
+    (inputs (list ghc-quickcheck
+                  ghc-aeson
+                  ghc-blaze-html
+                  ghc-blaze-markup
+                  ghc-cmdargs
+                  ghc-conduit
+                  ghc-conduit-extra
+                  ghc-connection
+                  ghc-extra
+                  ghc-foundation
+                  ghc-old-locale
+                  ghc-hashable
+                  ghc-haskell-src-exts
+                  ghc-http-conduit
+                  ghc-http-types
+                  ghc-js-flot
+                  ghc-js-jquery
+                  ghc-mmap
+                  ghc-process-extras
+                  ghc-resourcet
+                  ghc-storable-tuple
+                  ghc-tar
+                  ghc-uniplate
+                  ghc-utf8-string
+                  ghc-vector
+                  ghc-wai
+                  ghc-wai-logger
+                  ghc-warp
+                  ghc-warp-tls
+                  ghc-zlib
+                  ghc-semigroups))
     (home-page "https://hoogle.haskell.org/")
     (synopsis "Haskell API Search")
-    (description "Hoogle is a Haskell API search engine, which allows
+    (description
+     "Hoogle is a Haskell API search engine, which allows
 you to search many standard Haskell libraries by either function name,
 or by approximate type signature.")
     (license license:bsd-3)))
@@ -617,90 +607,89 @@ and mIRC chat codes.")
     (license license:bsd-3)))
 
 (define-public kmonad
-  (package
-    (name "kmonad")
-    (version "0.4.1")
-    (source
-     (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://github.com/david-janssen/kmonad")
-             (commit version)))
-       (file-name (git-file-name name version))
-       (sha256
-        (base32 "1rp880zxvrznx0y1k464wjrds441dpsz94syhrkaw5dnmxf74yjd"))))
-    (build-system haskell-build-system)
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (delete 'haddock)             ; Haddock fails to generate docs
-         (add-after 'install 'install-udev-rules
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (rules (string-append out "/lib/udev/rules.d")))
-               (mkdir-p rules)
-               (call-with-output-file (string-append rules "/70-kmonad.rules")
-                 (lambda (port)
-                   (display
-                    (string-append
-                     "KERNEL==\"uinput\", MODE=\"0660\", "
-                     "GROUP=\"input\", OPTIONS+=\"static_node=uinput\"\n")
-                    port)))
-               #t)))
-         (add-after 'install-udev-rules 'install-documentation
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (doc (string-append out "/share/doc/kmonad-" ,version)))
-               (install-file "README.md" doc)
-               (copy-recursively "doc" doc)
-               (copy-recursively "keymap" (string-append doc "/keymap"))
-               #t))))))
-    (inputs
-     (list ghc-cereal
-           ghc-exceptions
-           ghc-hashable
-           ghc-lens
-           ghc-megaparsec
-           ghc-optparse-applicative
-           ghc-resourcet
-           ghc-rio
-           ghc-unagi-chan
-           ghc-unliftio
-           ghc-unordered-containers))
-    (home-page "https://github.com/david-janssen/kmonad")
-    (synopsis "Advanced keyboard manager")
-    (description "KMonad is a keyboard remapping utility that supports
+  ;; Project is active, but no new releases exist. Pick current master
+  ;; HEAD as of 2023-01-08.
+  (let ((commit "a0af5b8b3f085adb2c09ca52374a53566c25194c")
+        (revision "1"))
+    (package
+      (name "kmonad")
+      (version (git-version "0.4.1" revision commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/david-janssen/kmonad")
+               (commit commit)))
+         (file-name (git-file-name name version))
+         (sha256
+          (base32 "00qmmk1lgadhh32dqi530xm18v79ndcm7rrxvdsf827vicv2nhw1"))))
+      (build-system haskell-build-system)
+      (arguments
+       `(#:haddock? #f ; Haddock fails to generate docs
+         #:phases
+         (modify-phases %standard-phases
+           (add-after 'unpack 'patch-git-path
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "src/KMonad/Args/TH.hs"
+                 (("\"git\"")
+                  (string-append "\"" (search-input-file inputs "/bin/git") "\"")))))
+           (add-after 'install 'install-udev-rules
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let* ((out (assoc-ref outputs "out"))
+                      (rules (string-append out "/lib/udev/rules.d")))
+                 (mkdir-p rules)
+                 (call-with-output-file (string-append rules "/70-kmonad.rules")
+                   (lambda (port)
+                     (display
+                      (string-append
+                       "KERNEL==\"uinput\", MODE=\"0660\", "
+                       "GROUP=\"input\", OPTIONS+=\"static_node=uinput\"\n")
+                      port)))
+                 #t)))
+           (add-after 'install-udev-rules 'install-documentation
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let* ((out (assoc-ref outputs "out"))
+                      (doc (string-append out "/share/doc/kmonad-" ,version)))
+                 (install-file "README.md" doc)
+                 (copy-recursively "doc" doc)
+                 (copy-recursively "keymap" (string-append doc "/keymap"))
+                 #t))))))
+      (inputs
+       (list ghc-cereal
+             ghc-exceptions
+             ghc-lens
+             ghc-megaparsec
+             ghc-optparse-applicative
+             ghc-resourcet
+             ghc-rio
+             ghc-unliftio
+             ghc-unordered-containers
+             ghc-template-haskell))
+      (native-inputs (list ghc-hspec hspec-discover git))
+      (home-page "https://github.com/david-janssen/kmonad")
+      (synopsis "Advanced keyboard manager")
+      (description "KMonad is a keyboard remapping utility that supports
 advanced functionality, such as custom keymap layers and modifiers, macros,
 and conditional mappings that send a different keycode when tapped or held.
 By operating at a lower level than most similar tools, it supports X11,
 Wayland, and Linux console environments alike.")
-    (license license:expat)))
+      (license license:expat))))
 
 (define-public nixfmt
   (package
     (name "nixfmt")
-    (version "0.4.0")
+    (version "0.5.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "nixfmt" version))
        (sha256
-        (base32 "1ispgl8rc2scr6v8bb6sks7px856jf61x74zj2iyddrn5qamkb3n"))))
+        (base32 "0rxi8zrd2xr72w673nvgnhb0g3r7rssc1ahlhz8rmdpc6c1a82wl"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "nixfmt")))
     (inputs
      (list ghc-megaparsec ghc-parser-combinators ghc-cmdargs
            ghc-safe-exceptions))
-    (arguments
-     `(#:cabal-revision
-       ("1" "1hsj0jh6siph3afd9c2wii09sffl48rzqv653n4clpd8qy0rn48d")
-       #:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "nixfmt.cabal"
-               (("(base|megaparsec)\\s+[^,]+" all dep)
-                dep)))))))
     (home-page "https://github.com/serokell/nixfmt")
     (synopsis "Opinionated formatter for Nix")
     (description
@@ -711,16 +700,16 @@ formatting by forgetting all existing formatting during parsing.")
 (define-public greenclip
   (package
     (name "greenclip")
-    (version "3.4")
+    (version "4.2")
     (source
      (origin
        (method git-fetch)
        (uri (git-reference
              (url "https://github.com/erebe/greenclip")
-             (commit version)))
+             (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
-        (base32 "1baw360dcnyavacf7a8v6wq4m5g6bcmyybkckv4cz7r4xl5p3qws"))))
+        (base32 "10r485q055ci29fmpsjy55n1yqfil53cvdxldlzw2n6mpynmckyv"))))
     (build-system haskell-build-system)
     (native-inputs
      (list pkg-config))
@@ -734,6 +723,7 @@ formatting by forgetting all existing formatting during parsing.")
            ghc-microlens
            ghc-microlens-mtl
            ghc-protolude
+           ghc-tomland
            ghc-vector
            ghc-wordexp))
     (home-page "https://github.com/erebe/greenclip")
@@ -929,34 +919,31 @@ output, stderr, and exit status.")
 (define-public stylish-haskell
   (package
     (name "stylish-haskell")
-    (version "0.13.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri
-        (hackage-uri "stylish-haskell" version))
-       (sha256
-        (base32
-         "0x9w3zh1lzp6l5xj3mynnlr0fzb5mbv0wwpfxp8fr6bk0jcrzjwf"))))
+    (version "0.14.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "stylish-haskell" version))
+              (sha256
+               (base32
+                "17w92v0qnwj7m6yqdq5cxbr04xiz0yfnnyx5q54218wdl7n5lf6d"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "stylish-haskell")))
-    (inputs
-     (list ghc-aeson
-           ghc-file-embed
-           ghc-haskell-src-exts
-           ghc-semigroups
-           ghc-syb
-           ghc-hsyaml
-           ghc-hsyaml-aeson
-           ghc-lib-parser
-           ghc-strict
-           ghc-optparse-applicative
-           ghc-hunit
-           ghc-test-framework
-           ghc-test-framework-hunit))
-    (home-page "https://github.com/jaspervdj/stylish-haskell")
+    (inputs (list ghc-aeson
+                  ghc-file-embed
+                  ghc-regex-tdfa
+                  ghc-syb
+                  ghc-hsyaml-aeson
+                  ghc-hsyaml
+                  ghc-semigroups
+                  ghc-lib-parser-ex
+                  ghc-strict
+                  ghc-optparse-applicative))
+    (native-inputs (list ghc-hunit ghc-random ghc-test-framework
+                         ghc-test-framework-hunit))
+    (home-page "https://github.com/haskell/stylish-haskell")
     (synopsis "Haskell code prettifier")
-    (description "Stylish-haskell is a Haskell code prettifier.  The goal is
+    (description
+     "Stylish-haskell is a Haskell code prettifier.  The goal is
 not to format all of the code in a file, to avoid \"getting in the way\".
 However, this tool can e.g. clean up import statements and help doing various
 tasks that get tedious very quickly.  It can
diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm
index e00103d2fe..6b7fe878e2 100644
--- a/gnu/packages/haskell-check.scm
+++ b/gnu/packages/haskell-check.scm
@@ -90,25 +90,19 @@ Haskell test framework.")
 (define-public ghc-tasty-quickcheck
   (package
     (name "ghc-tasty-quickcheck")
-    (version "0.10.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tasty-quickcheck" version))
-       (sha256
-        (base32
-         "0i1i78587znqzwps49milyr5n2k388ld2kr9ysz1vw8gcw51qq49"))))
+    (version "0.10.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-quickcheck" version))
+              (sha256
+               (base32
+                "1qnc6rdvjvlw08q6sln2n98rvj0s0pp689h6w4z58smjbn0lr25l"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty-quickcheck")))
-    (inputs
-     (list ghc-quickcheck
-           ghc-tagged
-           ghc-tasty
-           ghc-random
-           ghc-ansi-terminal
-           ghc-tasty-hunit
-           ghc-pcre-light))
-    (home-page "http://documentup.com/feuerbach/tasty")
+    (inputs (list ghc-tagged ghc-tasty ghc-random ghc-quickcheck
+                  ghc-optparse-applicative))
+    (native-inputs (list ghc-tasty-hunit ghc-pcre-light))
+    (home-page "https://github.com/UnkindPartition/tasty")
     (synopsis "QuickCheck support for the Tasty test framework")
     (description "This package provides QuickCheck support for the Tasty
 Haskell test framework.")
@@ -117,26 +111,23 @@ Haskell test framework.")
 (define-public ghc-tasty-golden
   (package
     (name "ghc-tasty-golden")
-    (version "2.3.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tasty-golden" version))
-       (sha256
-        (base32
-         "1nskavqgfxx1cw7q6c0cmizlwj54rnlv93yhgssaa77gv1nbvwpn"))))
+    (version "2.3.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-golden" version))
+              (sha256
+               (base32
+                "03klnxn9rcv0l7fl4w8q6s59fzl1328j1wzwi1za4gb0l90vadwb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty-golden")))
-    (inputs
-     (list ghc-async
-           ghc-optparse-applicative
-           ghc-tagged
-           ghc-tasty
-           ghc-temporary
-           ghc-unix-compat))
+    (inputs (list ghc-tasty
+                  ghc-typed-process
+                  ghc-optparse-applicative
+                  ghc-temporary
+                  ghc-tagged
+                  ghc-async))
     (native-inputs (list ghc-tasty-hunit))
-    (home-page
-     "https://github.com/feuerbach/tasty-golden")
+    (home-page "https://github.com/UnkindPartition/tasty-golden")
     (synopsis "Golden tests support for tasty")
     (description
      "This package provides support for @code{golden testing}.  A @dfn{golden
@@ -148,28 +139,20 @@ contains the correct result for the test.")
 (define-public ghc-tasty
   (package
     (name "ghc-tasty")
-    (version "1.4.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tasty" version))
-       (sha256
-        (base32
-         "0574hbqzxzyv6vsk5kzbf04kz58y0iy8x9ydcj4b8fpncgmgy63g"))))
+    (version "1.4.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty" version))
+              (sha256
+               (base32
+                "006bf4gyc30i2gvb17hj1mzrh1kwnwf7l050x3f72wi6c2axl87l"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty")))
-    (inputs
-     (list ghc-tagged
-           ghc-regex-tdfa
-           ghc-optparse-applicative
-           ghc-unbounded-delays
-           ghc-async
-           ghc-ansi-terminal
-           ghc-clock-bootstrap
-           ghc-wcwidth-bootstrap))
-    (home-page "http://documentup.com/feuerbach/tasty")
+    (inputs (list ghc-tagged ghc-optparse-applicative ghc-ansi-terminal))
+    (home-page "https://github.com/UnkindPartition/tasty")
     (synopsis "Modern and extensible testing framework")
-    (description "Tasty is a modern testing framework for Haskell.  It lets
+    (description
+     "Tasty is a modern testing framework for Haskell.  It lets
 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
 and any other types of tests into a single test suite.")
     (license license:expat)))
@@ -177,23 +160,21 @@ and any other types of tests into a single test suite.")
 (define-public ghc-tasty-hedgehog
   (package
     (name "ghc-tasty-hedgehog")
-    (version "1.1.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tasty-hedgehog" version))
-       (sha256
-        (base32
-         "0cy49z8n124xh2ra2482vfy5if1n6d9lbdjma2zg1mxfj0k0zyfb"))))
+    (version "1.3.1.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-hedgehog" version))
+              (sha256
+               (base32
+                "1iq452mvd9wc9pfmjsmm848jwp3cvsk1faf2mlr21vcs0yaxvq3m"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty-hedgehog")))
-    (inputs
-     (list ghc-tagged ghc-tasty ghc-hedgehog))
-    (native-inputs
-     (list ghc-tasty-expected-failure))
+    (inputs (list ghc-tagged ghc-tasty ghc-hedgehog))
+    (native-inputs (list ghc-tasty-expected-failure))
     (home-page "https://github.com/qfpl/tasty-hedgehog")
     (synopsis "Integration for tasty and hedgehog")
-    (description "This package provides the means for integrating the
+    (description
+     "This package provides the means for integrating the
 @url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library}
 with the @url{https://hackage.haskell.org/package/tasty, tasty testing
 framework}.")
@@ -202,31 +183,27 @@ framework}.")
 (define-public ghc-tasty-hspec
   (package
     (name "ghc-tasty-hspec")
-    (version "1.1.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tasty-hspec" version))
-       (sha256
-        (base32
-         "02s82ijs2ringqxsqbm7m3vcy5brmwxa617azxv0v2phi3rdkjvl"))))
+    (version "1.2.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-hspec" version))
+              (sha256
+               (base32
+                "0ibl2xi6mmqad2mriz67nb7pjwwvjik385amp24j9kc7a7zkx091"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty-hspec")))
-    (inputs
-     (list ghc-hspec
-           ghc-hspec-core
-           ghc-quickcheck
-           ghc-tagged
-           ghc-tasty
-           ghc-tasty-smallcheck
-           ghc-tasty-quickcheck))
+    (inputs (list ghc-hspec
+                  ghc-hspec-core
+                  ghc-quickcheck
+                  ghc-tasty
+                  ghc-tasty-smallcheck
+                  ghc-tasty-quickcheck
+                  ghc-tagged))
     (arguments
-     `(#:cabal-revision
-       ("1" "0za15rg0szacxq9yfxxjzddr77ai7ng5827a20pj9dr5anjlnajj")))
-    (home-page
-     "https://github.com/mitchellwrosen/tasty-hspec")
-    (synopsis
-     "Hspec support for the Tasty test framework")
+     `(#:cabal-revision ("1"
+                         "0a6r4gzxzp6n90z0nif7ha7p7am57hs48i54i2y4z9kgjv6lnvll")))
+    (home-page "https://github.com/mitchellwrosen/tasty-hspec")
+    (synopsis "Hspec support for the Tasty test framework")
     (description
      "This package provides a Tasty provider for Hspec test suites.")
     (license license:bsd-3)))
@@ -276,21 +253,23 @@ tasty.")
 (define-public ghc-tasty-lua
   (package
     (name "ghc-tasty-lua")
-    (version "0.2.3.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tasty-lua" version))
-       (sha256
-        (base32
-         "0wa73ihkjcxi50lgpdzwwdx7s903lqi79hw7hxlvhbcvdly1cq53"))))
+    (version "1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-lua" version))
+              (sha256
+               (base32
+                "1vnyvgcjsvqhwwyqkbgqksr9ppj5whiihpwcqkg33sl7jj3ysdwv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty-lua")))
-    (inputs
-     (list ghc-file-embed ghc-hslua ghc-tasty))
-    (native-inputs
-     (list ghc-tasty-hunit))
-    (home-page "https://github.com/hslua/tasty-lua")
+    (inputs (list ghc-hslua-core
+                  ghc-hslua-marshalling
+                  ghc-lua-arbitrary
+                  ghc-tasty
+                  ghc-quickcheck
+                  ghc-file-embed))
+    (native-inputs (list ghc-tasty-hunit))
+    (home-page "https://github.com/hslua/hslua")
     (synopsis "Write tests in Lua, integrate into tasty")
     (description "This package gives users the ability to define tasty tests
 from Lua.")
@@ -335,6 +314,9 @@ test-framework.")
     (inputs
      (list ghc-optparse-applicative ghc-reducers ghc-split ghc-tagged
            ghc-tasty))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0091arn90cx5rzn5n2bpb9alzybwraf9yj7hb0bwdfyamzpf3pkb")))
     (home-page "https://github.com/ocharles/tasty-rerun")
     (synopsis "Run tests by filtering the test tree")
     (description "This package adds the ability to run tests by filtering the
@@ -376,37 +358,35 @@ development.")
 (define-public ghc-quickcheck-instances
   (package
     (name "ghc-quickcheck-instances")
-    (version "0.3.25.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "quickcheck-instances" version))
-       (sha256
-        (base32
-         "0ihqbarl2ddrfgq3mq09lswwn8213qpw13g49qxs5mjkcm6gbk3h"))))
+    (version "0.3.28")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "quickcheck-instances" version))
+              (sha256
+               (base32
+                "1jycijv7gaj6qrkp219nllrdv9zd0ifp0mb0rch430fm95xin4f4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "quickcheck-instances")))
-    (arguments
-     `(#:cabal-revision
-       ("2" "1lsa3pbg4ljlk29fhm3mdklnx3hwffyga1nr5krbpcyc3ywq8fq8")))
-    (inputs
-     (list ghc-case-insensitive
-           ghc-data-fix
-           ghc-hashable
-           ghc-integer-logarithms
-           ghc-old-time
-           ghc-quickcheck
-           ghc-scientific
-           ghc-splitmix
-           ghc-strict
-           ghc-tagged
-           ghc-these
-           ghc-time-compat
-           ghc-transformers-compat
-           ghc-unordered-containers
-           ghc-uuid-types
-           ghc-vector))
-    (home-page "https://github.com/aslatter/qc-instances")
+    (inputs (list ghc-quickcheck
+                  ghc-splitmix
+                  ghc-case-insensitive
+                  ghc-data-fix
+                  ghc-hashable
+                  ghc-integer-logarithms
+                  ghc-old-time
+                  ghc-onetuple
+                  ghc-primitive
+                  ghc-scientific
+                  ghc-strict
+                  ghc-tagged
+                  ghc-these
+                  ghc-time-compat
+                  ghc-transformers-compat
+                  ghc-unordered-containers
+                  ghc-uuid-types
+                  ghc-vector
+                  ghc-text-short))
+    (home-page "https://github.com/haskellari/qc-instances")
     (synopsis "Common quickcheck instances")
     (description "This package provides QuickCheck instances for types
 provided by the Haskell Platform.")
@@ -521,8 +501,8 @@ HUnit.")
      `(#:tests? #f  ; FIXME: Tests do not build.
        #:cabal-revision
        ("6" "0wbq9wiaag69nsqxwijzhs5y1hb9kbpkp1x65dvx158cxp8i9w9r")))
-    (native-inputs
-     (list ghc-hunit ghc-quickcheck))
+    ;(native-inputs
+    ; (list ghc-hunit ghc-quickcheck))
     (inputs
      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
        ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
@@ -673,19 +653,17 @@ JUnit tool for Java.")
 (define-public hspec-discover
   (package
     (name "hspec-discover")
-    (version "2.7.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hspec-discover" version))
-       (sha256
-        (base32
-         "13yzvd3b679skvs1insk4s0wc4zvmz6hs38kc8q0j6vzqq06smqa"))))
+    (version "2.9.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec-discover" version))
+              (sha256
+               (base32
+                "0536kdxjw6p8b6gcwvmr22jbmb6cgzbddi0fkd01b2m847z37sb5"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hspec-discover")))
-    (native-inputs
-     (list ghc-quickcheck ghc-hspec-meta))
-    (home-page "https://hspec.github.io/")
+    (native-inputs (list ghc-quickcheck ghc-hspec-meta ghc-mockery-bootstrap))
+    (home-page "http://hspec.github.io/")
     (synopsis "Automatically discover and run Hspec tests")
     (description "hspec-discover is a tool which automatically discovers and
 runs Hspec tests.")
@@ -694,28 +672,28 @@ runs Hspec tests.")
 (define-public ghc-hspec-core
   (package
     (name "ghc-hspec-core")
-    (version "2.7.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hspec-core" version))
-       (sha256
-        (base32
-         "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1"))))
+    (version "2.9.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec-core" version))
+              (sha256
+               (base32
+                "040rzqiqwkp373jjpij8lkmv08pp2ya92zzcf95bw8px215rp08n"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hspec-core")))
-    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
-    (inputs
-     (list ghc-setenv
-           ghc-ansi-terminal
-           ghc-clock
-           ghc-quickcheck-io
-           ghc-hunit
-           ghc-quickcheck
-           ghc-hspec-expectations
-           ghc-silently
-           ghc-tf-random))
-    (home-page "https://hspec.github.io/")
+    (inputs (list ghc-hunit
+                  ghc-quickcheck
+                  ghc-ansi-terminal
+                  ghc-call-stack
+                  ghc-clock
+                  ghc-hspec-expectations
+                  ghc-quickcheck-io
+                  ghc-random
+                  ghc-setenv
+                  ghc-tf-random))
+    (native-inputs (list ghc-base-orphans-bootstrap ghc-hspec-meta
+                         ghc-silently-bootstrap ghc-temporary))
+    (home-page "http://hspec.github.io/")
     (synopsis "Testing framework for Haskell")
     (description "This library exposes internal types and functions that can
 be used to extend Hspec's functionality.")
@@ -724,26 +702,23 @@ be used to extend Hspec's functionality.")
 (define-public ghc-hspec-meta
   (package
     (name "ghc-hspec-meta")
-    (version "2.7.8")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hspec-meta" version))
-       (sha256
-        (base32
-         "0sfj0n2hy1r8ifysgbcmfdygcd7vyzr13ldkcp0l2ml337f8j0si"))))
+    (version "2.9.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec-meta" version))
+              (sha256
+               (base32
+                "1raxwpsmcijl3x2h5naw6aydhbiknxvhj3x7v384bi1rqi51ainm"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hspec-meta")))
-    (inputs
-     (list ghc-quickcheck
-           ghc-hunit
-           ghc-ansi-terminal
-           ghc-clock
-           ghc-hspec-expectations
-           ghc-setenv
-           ghc-random
-           ghc-quickcheck-io))
-    (home-page "https://hspec.github.io/")
+    (inputs (list ghc-quickcheck
+                  ghc-ansi-terminal
+                  ghc-call-stack-boot
+                  ghc-clock
+                  ghc-quickcheck-io
+                  ghc-random
+                  ghc-setenv))
+    (home-page "http://hspec.github.io/")
     (synopsis "Version of Hspec to test Hspec itself")
     (description "This library provides a stable version of Hspec which is
 used to test the in-development version of Hspec.")
@@ -752,26 +727,18 @@ used to test the in-development version of Hspec.")
 (define-public ghc-hspec
   (package
     (name "ghc-hspec")
-    (version "2.7.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hspec" version))
-       (sha256
-        (base32
-         "0z0lwrmrqkglr78n6k2c36n4h68142bh785ys0x4jaibjshvs6rw"))))
+    (version "2.9.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec" version))
+              (sha256
+               (base32
+                "092sfqjkargxxszp9jjqa8ldjz0xv34jwn6k21q59ys5ckvsrpc1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hspec")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-hspec-core
-           hspec-discover
-           ghc-hspec-expectations
-           ghc-quickcheck
-           ghc-hunit
-           ghc-stringbuilder
-           ghc-hspec-meta))
-    (home-page "https://hspec.github.io/")
+    (inputs (list ghc-quickcheck ghc-hspec-core hspec-discover
+                  ghc-hspec-expectations))
+    (home-page "http://hspec.github.io/")
     (synopsis "Testing Framework for Haskell")
     (description "This library provides the Hspec testing framework for
 Haskell, inspired by the Ruby library RSpec.")
@@ -780,23 +747,21 @@ Haskell, inspired by the Ruby library RSpec.")
 (define-public ghc-hspec-contrib
   (package
     (name "ghc-hspec-contrib")
-    (version "0.5.1")
+    (version "0.5.1.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "hspec-contrib" version))
               (sha256
                (base32
-                "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc"))))
+                "1nyb5n2jiq920yyf3flzyxrs5xpfyppl3jn18zhviyysjjk5drpx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hspec-contrib")))
-    (inputs
-     (list ghc-hspec-core ghc-hunit ghc-hspec ghc-quickcheck))
-    (native-inputs
-     (list hspec-discover))
-    (home-page "https://hspec.github.io/")
+    (inputs (list ghc-hunit ghc-hspec-core))
+    (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover))
+    (arguments (list #:tests? #f)) ; Tests fail to compile.
+    (home-page "http://hspec.github.io/")
     (synopsis "Contributed functionality for Hspec")
-    (description
-     "This package provides contributed Hspec extensions.")
+    (description "This package provides contributed Hspec extensions.")
     (license license:expat)))
 
 (define-public ghc-hspec-expectations
@@ -834,8 +799,8 @@ Haskell, inspired by the Ruby library RSpec.")
          "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "nanospec")))
-    (inputs
-     (list ghc-hspec ghc-silently))
+    (inputs (list ghc-silently-bootstrap))
+    (native-inputs (list ghc-hspec))
     (home-page "https://github.com/hspec/nanospec#readme")
     (synopsis "Lightweight implementation of a subset of Hspec's API")
     (description
@@ -843,6 +808,14 @@ Haskell, inspired by the Ruby library RSpec.")
 minimal dependencies.")
     (license license:expat)))
 
+(define-public ghc-nanospec-bootstrap
+  (package
+    (inherit ghc-nanospec)
+    (name "ghc-nanospec-bootstrap")
+    (arguments '(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
 (define-public ghc-crypto-cipher-tests
   (package
     (name "ghc-crypto-cipher-tests")
@@ -874,31 +847,29 @@ implementations of cryptographic ciphers.")
 (define-public ghc-hedgehog
   (package
     (name "ghc-hedgehog")
-    (version "1.0.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hedgehog" version))
-       (sha256
-        (base32
-         "1qsqs8lmxa3wmw228cwi98vvvh9hqbc9d43i1sy2c9igw9xlhfi6"))))
+    (version "1.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hedgehog" version))
+              (sha256
+               (base32
+                "0dbk75hk6hqpzkjdlpw3s63qhm42kqigij33p321by6xndb59jg1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hedgehog")))
-    (inputs
-     (list ghc-ansi-terminal
-           ghc-async
-           ghc-concurrent-output
-           ghc-erf
-           ;("ghc-exceptions" ,ghc-exceptions)
-           ghc-lifted-async
-           ghc-mmorph
-           ghc-monad-control
-           ghc-pretty-show
-           ghc-primitive
-           ghc-random
-           ghc-resourcet
-           ghc-transformers-base
-           ghc-wl-pprint-annotated))
+    (inputs (list ghc-ansi-terminal
+                  ghc-async
+                  ghc-barbies
+                  ghc-concurrent-output
+                  ghc-erf
+                  ghc-lifted-async
+                  ghc-mmorph
+                  ghc-monad-control
+                  ghc-pretty-show
+                  ghc-primitive
+                  ghc-random
+                  ghc-resourcet
+                  ghc-transformers-base
+                  ghc-wl-pprint-annotated))
     (home-page "https://hedgehog.qa")
     (synopsis "Property-based testing in the spirt of QuickCheck")
     (description
@@ -910,23 +881,30 @@ To get started quickly, see the examples:
 @uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}")
     (license license:bsd-3)))
 
+;; Deprecated. Don’t use.
 (define-public cabal-doctest
   (package
     (name "cabal-doctest")
-    (version "1.0.8")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cabal-doctest" version))
-       (sha256
-        (base32
-         "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
+    (version "1.0.9")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cabal-doctest" version))
+              (sha256
+               (base32
+                "0wxs0xkspc80h0g8ks792lrzldxvcnhc9rja1j0k678ijs20hmjm"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cabal-doctest")))
     (arguments
-     `(#:cabal-revision
-       ("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
-    (home-page "https://github.com/phadej/cabal-doctest")
+     `(#:cabal-revision ("2"
+                         "0868js0qgfhvmyw4hjzrvmlzyqsm8dfsbmqhybxb90x44xi3r0i1")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "cabal-doctest.cabal"
+               (("\\b(Cabal|base)\\s+[^,]+" all dep)
+                dep)))))))
+    (home-page "https://github.com/haskellari/cabal-doctest")
     (synopsis "Setup.hs helper for running doctests")
     (description
      "To properly work, the @code{doctest} package needs plenty of
@@ -934,6 +912,10 @@ configuration.  This library provides the common bits for writing custom
 @file{Setup.hs} files.")
     (license license:bsd-3)))
 
+;; Deprecated. Don’t use.
+(define-public ghc-cabal-doctest
+  (deprecated-package "ghc-cabal-doctest" cabal-doctest))
+
 (define-public ghc-testing-type-modifiers
   (package
     (name "ghc-testing-type-modifiers")
@@ -959,22 +941,20 @@ testing frameworks.")
 (define-public ghc-testing-feat
   (package
     (name "ghc-testing-feat")
-    (version "1.1.0.0")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "testing-feat" version))
-        (sha256
-          (base32
-            "1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r"))))
+    (version "1.1.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "testing-feat" version))
+              (sha256
+               (base32
+                "14d6licgrkiw36xj1cshnqxcbx5iwzxwq731xlb1wb5n2sw8ijf2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "testing-feat")))
-    (inputs
-      (list ghc-quickcheck ghc-size-based ghc-testing-type-modifiers
-            ghc-semigroups))
-    (home-page "https://github.com/JonasDuregard/testing-feat")
+    (inputs (list ghc-quickcheck ghc-size-based ghc-testing-type-modifiers))
+    (home-page "https://github.com/size-based/testing-feat")
     (synopsis "Functional Enumeration of Algebraic Types")
-    (description "Feat (Functional Enumeration of Algebraic Types)
+    (description
+     "Feat (Functional Enumeration of Algebraic Types)
 provides enumerations as functions from natural numbers to
 values (similar to @code{toEnum} but for any algebraic data type).  This
 can be used for SmallCheck-style systematic testing, QuickCheck-style
@@ -984,18 +964,16 @@ random testing, and hybrids of the two.")
 (define-public ghc-inspection-testing
   (package
     (name "ghc-inspection-testing")
-    (version "0.4.6.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "inspection-testing" version))
-       (sha256
-        (base32
-         "0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig"))))
+    (version "0.4.6.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "inspection-testing" version))
+              (sha256
+               (base32
+                "0mxff0v3ciccbk4b8kxnh4752fzbwn7213qd8xji0csv6gi2w83y"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "inspection-testing")))
-    (home-page
-     "https://github.com/nomeata/inspection-testing")
+    (home-page "https://github.com/nomeata/inspection-testing")
     (synopsis "GHC plugin to do inspection testing")
     (description
      "Some carefully crafted libraries make promises to their users beyond
@@ -1133,6 +1111,9 @@ these constraints more cleanly.")
     (properties '((upstream-name . "doctest-exitcode-stdio")))
     (inputs
       (list ghc-doctest-lib ghc-quickcheck ghc-semigroups))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1065s8bch6zhl6mc8nhvfpwd1irmjd04z7xgycbpihc14x4ijim3")))
     (home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/")
     (synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environment")
     (description
@@ -1140,55 +1121,33 @@ these constraints more cleanly.")
 environment.")
     (license license:bsd-3)))
 
-(define-public ghc-cabal-doctest
-  (package
-    (name "ghc-cabal-doctest")
-    (version "1.0.8")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "cabal-doctest" version))
-        (sha256
-          (base32 "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "cabal-doctest")))
-    (arguments
-      `(#:cabal-revision
-        ("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
-    (home-page "https://github.com/phadej/cabal-doctest")
-    (synopsis "@file{Setup.hs} helper for Doctests running")
-    (description
-      "This package provides helpers for running Doctests in @file{Setup.hs}.")
-    (license license:bsd-3)))
-
 (define-public ghc-tasty-silver
   (package
     (name "ghc-tasty-silver")
-    (version "3.2.3")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "tasty-silver" version))
-        (sha256
-          (base32 "0nvh2k8iqqkanmp7lpwd3asimyarzisly8wavbdahcxryn0j4xb7"))))
+    (version "3.3.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-silver" version))
+              (sha256
+               (base32
+                "13j0zs0ciijv9q2nncna1gbgsgw2g7xc228hzmqic1750n3ybz9m"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tasty-silver")))
-    (inputs
-      (list ghc-ansi-terminal
-            ghc-async
-            ghc-optparse-applicative
-            ghc-process-extras
-            ghc-regex-tdfa
-            ghc-semigroups
-            ghc-tagged
-            ghc-tasty
-            ghc-temporary))
-    (native-inputs
-     (list ghc-tasty-hunit ghc-silently))
+    (inputs (list ghc-ansi-terminal
+                  ghc-async
+                  ghc-optparse-applicative
+                  ghc-process-extras
+                  ghc-regex-tdfa
+                  ghc-silently
+                  ghc-tagged
+                  ghc-tasty
+                  ghc-temporary
+                  ghc-semigroups))
+    (native-inputs (list ghc-tasty-hunit))
     (home-page "https://github.com/phile314/tasty-silver")
     (synopsis "Fancy test runner, including support for golden tests")
     (description
-      "This package provides a fancy test runner and support for @dfn{golden
+     "This package provides a fancy test runner and support for @dfn{golden
 testing}.  A golden test is an IO action that writes its result to a file.  To
 pass the test, this output file should be identical to the corresponding
 ``golden'' file, which contains the correct result for the test.  The test
@@ -1196,3 +1155,22 @@ runner allows filtering tests using regexes, and to interactively inspect the
 result of golden tests.")
     (license license:expat)))
 
+(define-public ghc-tasty-inspection-testing
+  (package
+    (name "ghc-tasty-inspection-testing")
+    (version "0.1.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-inspection-testing" version))
+              (sha256
+               (base32
+                "0p46w44f19w7lvdzyg3vq6qzix0rjp8p23ilxz82dviq38lgmifp"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "tasty-inspection-testing")))
+    (inputs (list ghc-inspection-testing ghc-tasty))
+    (home-page "https://github.com/Bodigrim/tasty-inspection-testing")
+    (synopsis "Inspection testing support for tasty")
+    (description
+     "Integrate @@inspection-testing@@ into @@tasty@@ test suites.")
+    (license license:expat)))
+
diff --git a/gnu/packages/haskell-crypto.scm b/gnu/packages/haskell-crypto.scm
index e06ff7058b..0046e0481a 100644
--- a/gnu/packages/haskell-crypto.scm
+++ b/gnu/packages/haskell-crypto.scm
@@ -27,6 +27,7 @@
   #:use-module (gnu packages haskell)
   #:use-module (gnu packages haskell-check)
   #:use-module (gnu packages haskell-xyz)
+  #:use-module (gnu packages pkg-config)
   #:use-module (gnu packages tls)
   #:use-module (guix build-system haskell)
   #:use-module (guix download)
@@ -209,25 +210,24 @@ that hides the C implementation.")
 (define-public ghc-cryptohash-sha1
   (package
     (name "ghc-cryptohash-sha1")
-    (version "0.11.100.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cryptohash-sha1" version))
-       (sha256
-        (base32
-         "1aqdxdhxhl9jldh951djpwxx8z7gzaqspxl7iwpl84i5ahrsyy9w"))))
+    (version "0.11.101.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cryptohash-sha1" version))
+              (sha256
+               (base32
+                "0h9jl9v38gj0vnscqx7xdklk634p05fa6z2pcvknisq2mnbjq154"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cryptohash-sha1")))
-    (arguments
-     `(#:cabal-revision
-       ("6" "10rpxrmqgwihmplczglwxf5q3l13z9j3kvi065z884y4dymmnkgc")
-       #:tests? #f)) ; tests require old version of ghc-hunit (0.9)
     (native-inputs (list ghc-base16-bytestring ghc-sha ghc-tasty
-                         ghc-tasty-quickcheck ghc-hunit))
+                         ghc-tasty-quickcheck ghc-tasty-hunit))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0bz9rfl7b2iwn45m0lxcmsyi5rrv3xdgzx2lzr79bds91dw6i25b")))
     (home-page "https://github.com/hvr/cryptohash-sha1")
     (synopsis "SHA-1 implementation for Haskell")
-    (description "This Haskell package provides an incremental and one-pass,
+    (description
+     "This Haskell package provides an incremental and one-pass,
 pure API to the @uref{https://en.wikipedia.org/wiki/SHA-1, SHA-1 hash algorithm},
 including @uref{https://en.wikipedia.org/wiki/HMAC, HMAC support}, with
 performance close to the fastest implementations available in other languages.
@@ -270,23 +270,18 @@ the C implementation.")
 (define-public ghc-cryptonite
   (package
     (name "ghc-cryptonite")
-    (version "0.29")
+    (version "0.30")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "cryptonite" version))
               (sha256
                (base32
-                "13xhp3hshb8x06bw37kp16c9jpjmgfn06nkj9drz745fv8f04fnq"))))
+                "07bb97iszhnrfddh5ql6p3dqd0c13xycjw5n2kljw7d0ia59q2an"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cryptonite")))
-    ;; FIXME: tests are broken.
-    ;; See https://github.com/haskell-crypto/cryptonite/issues/260
-    (arguments '(#:tests? #f))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-basement ghc-memory ghc-byteable))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit ghc-tasty-kat))
+    (inputs (list ghc-memory ghc-basement))
+    (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
+                         ghc-tasty-kat))
     (home-page "https://github.com/haskell-crypto/cryptonite")
     (synopsis "Cryptography primitives")
     (description
@@ -299,24 +294,21 @@ generators, and more.")
 (define-public ghc-digest
   (package
     (name "ghc-digest")
-    (version "0.0.1.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "digest" version))
-       (sha256
-        (base32
-         "1l5383l5pvp018rj3vabrppnzcqrr2g0dvgvmsrbjdn02wzab5jm"))))
+    (version "0.0.1.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "digest" version))
+              (sha256
+               (base32
+                "05pc5l4bwddszc6vy1hazwi1dnrxg323521gdkis9cvh7zs2a4gr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "digest")))
     (arguments
      `(#:extra-directories ("zlib")))
-    (inputs
-     (list zlib))
-    (home-page
-     "https://hackage.haskell.org/package/digest")
-    (synopsis
-     "Various cryptographic hashes for bytestrings")
+    (inputs (list zlib))
+    (native-inputs (list pkg-config))
+    (home-page "http://hackage.haskell.org/package/digest")
+    (synopsis "Various cryptographic hashes for bytestrings")
     (description
      "This package provides efficient cryptographic hash implementations for
 strict and lazy bytestrings.  For now, CRC32 and Adler32 are supported; they
@@ -326,13 +318,13 @@ are implemented as FFI bindings to efficient code from zlib.")
 (define-public ghc-entropy
   (package
     (name "ghc-entropy")
-    (version "0.4.1.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "entropy" version))
-       (sha256
-        (base32 "0qmzz0zgad13zl0kjrxz6cxg8ckn2w8saas2a2j72vbafpzmkixd"))))
+    (version "0.4.1.10")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "entropy" version))
+              (sha256
+               (base32
+                "1rbx4ydabrjs8kkdg9laznkh9nisiq6b5z93vnp9bh6iy59ivb45"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "entropy")))
     (home-page "https://github.com/TomMD/entropy")
@@ -418,26 +410,24 @@ libraries, like OpenSSL.")
 (define-public ghc-x509
   (package
     (name "ghc-x509")
-    (version "1.7.5")
+    (version "1.7.7")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "x509" version))
               (sha256
                (base32
-                "1j67c35g8334jx7x32hh6awhr43dplp0qwal5gnlkmx09axzrc5i"))))
+                "1zk8lll1hmzl5xvrd16dhyz25151y59xhsqp2mm1wgymwl7r5ijr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "x509")))
-    (inputs
-     (list ghc-memory
-           ghc-hourglass
-           ghc-pem
-           ghc-asn1-types
-           ghc-asn1-encoding
-           ghc-asn1-parse
-           ghc-cryptonite))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck))
-    (home-page "https://github.com/vincenthz/hs-certificate")
+    (inputs (list ghc-memory
+                  ghc-hourglass
+                  ghc-pem
+                  ghc-asn1-types
+                  ghc-asn1-encoding
+                  ghc-asn1-parse
+                  ghc-cryptonite))
+    (native-inputs (list ghc-tasty ghc-tasty-quickcheck))
+    (home-page "http://github.com/vincenthz/hs-certificate")
     (synopsis "X509 reader and writer")
     (description
      "This library provides functions to read and write X509 certificates.")
@@ -446,21 +436,19 @@ libraries, like OpenSSL.")
 (define-public ghc-x509-store
   (package
     (name "ghc-x509-store")
-    (version "1.6.7")
+    (version "1.6.9")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "x509-store" version))
               (sha256
                (base32
-                "1y8yyr1i95jkllg8k0z54k5v4vachp848clc07m33xpxidn3b1lp"))))
+                "1nn8ql7vkp4qgf2msm600sr6ranpsajbhq0sc4c0l6pk1i9174n5"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "x509-store")))
-    (inputs
-     (list ghc-pem ghc-asn1-types ghc-asn1-encoding ghc-cryptonite
-           ghc-x509))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit))
-    (home-page "https://github.com/vincenthz/hs-certificate")
+    (inputs (list ghc-pem ghc-asn1-types ghc-asn1-encoding ghc-cryptonite
+                  ghc-x509))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "http://github.com/vincenthz/hs-certificate")
     (synopsis "X.509 collection accessing and storing methods")
     (description
      "This package provides functions for accessing and storing X.509
@@ -470,29 +458,26 @@ collections, certificates, revocation lists, and exception lists.")
 (define-public ghc-x509-validation
   (package
     (name "ghc-x509-validation")
-    (version "1.6.11")
+    (version "1.6.12")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "x509-validation" version))
               (sha256
                (base32
-                "16yihzljql3z8w5rgdl95fv3hgk7yd86kbl9b3glllsark5j2hzr"))))
+                "1j7is28ljz4yxwxz5ax3x7ykgwkr38dx46bw7vgj4arkk7hl93hd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "x509-validation")))
-    (inputs
-     (list ghc-memory
-           ghc-byteable
-           ghc-hourglass
-           ghc-data-default-class
-           ghc-pem
-           ghc-asn1-types
-           ghc-asn1-encoding
-           ghc-x509
-           ghc-x509-store
-           ghc-cryptonite))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit))
-    (home-page "https://github.com/vincenthz/hs-certificate")
+    (inputs (list ghc-memory
+                  ghc-hourglass
+                  ghc-data-default-class
+                  ghc-pem
+                  ghc-asn1-types
+                  ghc-asn1-encoding
+                  ghc-x509
+                  ghc-x509-store
+                  ghc-cryptonite))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "http://github.com/vincenthz/hs-certificate")
     (synopsis "X.509 certificate and revocation list validation")
     (description
      "This package provides functions for X.509 certificate and revocation
@@ -502,18 +487,17 @@ list validation.")
 (define-public ghc-x509-system
   (package
     (name "ghc-x509-system")
-    (version "1.6.6")
+    (version "1.6.7")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "x509-system" version))
               (sha256
                (base32
-                "06a4m9c7vlr9nhp9gmqbb46arf0yj1dkdm4nip03hzy67spdmp20"))))
+                "049bdaxrih49nkhkyl2342qnbx2f0q99z8rld648bz1kkgyizz38"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "x509-system")))
-    (inputs
-     (list ghc-pem ghc-x509 ghc-x509-store))
-    (home-page "https://github.com/vincenthz/hs-certificate")
+    (inputs (list ghc-pem ghc-x509 ghc-x509-store))
+    (home-page "http://github.com/vincenthz/hs-certificate")
     (synopsis "Handle system X.509 accessors and storage")
     (description
      "This package provides a library to handle system accessors and storage
@@ -654,7 +638,7 @@ percent.
     (properties '((upstream-name . "ed25519")))
     (arguments
      `(#:cabal-revision
-       ("3" "1yidh86ymzwmp2b449pwim6vvfcs1qgkkncbixw1zmb7wj6v167v")
+       ("6" "0qyx6cl52fnll8lp6v9133wfvv3zhvq7v2crn441mng520j9wp48")
        ;; We omit these test suites because they require old versions of
        ;; packages and packages we do not have.
        #:configure-flags
@@ -671,33 +655,30 @@ guidelines.")
 (define-public ghc-tls
   (package
     (name "ghc-tls")
-    (version "1.5.5")
+    (version "1.5.8")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "tls" version))
               (sha256
                (base32
-                "0j1rxxq5lzs584nk19610mk7mmsqqkgfxw2qj74ibb1zsk7baj4a"))))
+                "0rxdv8ab98kd4nqql7djmmi51k4vayq21s38s43sx3rzn0iyla3b"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tls")))
-    (inputs
-     (list ghc-cereal
-           ghc-data-default-class
-           ghc-memory
-           ghc-cryptonite
-           ghc-asn1-types
-           ghc-asn1-encoding
-           ghc-x509
-           ghc-x509-store
-           ghc-x509-validation
-           ghc-async
-           ghc-network
-           ghc-hourglass))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck))
-    (home-page "https://github.com/vincenthz/hs-tls")
-    (synopsis
-     "TLS/SSL protocol native implementation (Server and Client)")
+    (inputs (list ghc-cereal
+                  ghc-data-default-class
+                  ghc-memory
+                  ghc-cryptonite
+                  ghc-asn1-types
+                  ghc-asn1-encoding
+                  ghc-x509
+                  ghc-x509-store
+                  ghc-x509-validation
+                  ghc-async
+                  ghc-hourglass
+                  ghc-network))
+    (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck))
+    (home-page "http://github.com/vincenthz/hs-tls")
+    (synopsis "TLS/SSL protocol native implementation (Server and Client)")
     (description
      "Native Haskell TLS and SSL protocol implementation for server and client.
 This provides a high-level implementation of a sensitive security protocol,
@@ -711,23 +692,22 @@ extensions.")
 (define-public ghc-hsopenssl
   (package
     (name "ghc-hsopenssl")
-    (version "0.11.7.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "HsOpenSSL" version))
-       (sha256
-        (base32
-         "0ysdfl8ck3nzhx597fa13dqf31jq5gzwajlak6r91jajks9w0dl5"))))
+    (version "0.11.7.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "HsOpenSSL" version))
+              (sha256
+               (base32
+                "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "HsOpenSSL")))
+    (inputs (list ghc-network openssl))
     (arguments
      `(#:extra-directories ("openssl")))
-    (inputs
-     (list ghc-network openssl))
-    (home-page "https://github.com/vshabanov/HsOpenSSL")
+    (home-page "https://github.com/haskell-cryptography/HsOpenSSL")
     (synopsis "Partial OpenSSL binding for Haskell")
-    (description "HsOpenSSL is an OpenSSL binding for Haskell.  It can
+    (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
@@ -754,6 +734,9 @@ implementation of SSL.")
      (list ghc-hsopenssl ghc-io-streams ghc-network))
     (native-inputs
      (list ghc-hunit ghc-test-framework ghc-test-framework-hunit))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0vfawnfcjrw29qg1n7k6z6bk4bmnk869gjlr9mxw4mzxgl80b2vp")))
     (home-page "https://hackage.haskell.org/package/openssl-streams")
     (synopsis "OpenSSL network support for io-streams")
     (description "This library contains io-streams routines for secure
diff --git a/gnu/packages/haskell-web.scm b/gnu/packages/haskell-web.scm
index 3194bcdf05..75b84b10a7 100644
--- a/gnu/packages/haskell-web.scm
+++ b/gnu/packages/haskell-web.scm
@@ -167,48 +167,26 @@ both client and server code).")
 (define-public ghc-http
   (package
     (name "ghc-http")
-    (version "4000.3.16")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "HTTP" version))
-       (sha256
-        (base32
-         "0bgyj3ahqlyg0jw6qsm2sncp8mklc4h0dj91s043vb3ig01iq2fn"))))
+    (version "4000.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "HTTP" version))
+              (sha256
+               (base32
+                "0lyl5lpkk51xn3dfndh8ksgvwcdsviyigmsnp3d28lbpxkpxhcfz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "HTTP")))
-    (native-inputs
-     (list ghc-httpd-shed ghc-hunit ghc-test-framework
-           ghc-test-framework-hunit))
-    (inputs
-     (list ghc-case-insensitive
-           ghc-conduit
-           ghc-conduit-extra
-           ghc-http-types
-           ghc-old-time
-           ghc-puremd5
-           ghc-network
-           ghc-network-uri
-           ghc-split))
+    (inputs (list ghc-network ghc-network-uri))
+    (native-inputs (list ghc-httpd-shed
+                         ghc-hunit
+                         ghc-puremd5
+                         ghc-split
+                         ghc-test-framework
+                         ghc-test-framework-hunit))
     (arguments
-     `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'create-simple-paths-module
-           (lambda _
-             (call-with-output-file "Paths_HTTP.hs"
-               (lambda (port)
-                 (format port "\
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE NoRebindableSyntax #-}
-{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
-module Paths_HTTP (version) where
-import Data.Version (Version(..))
-version :: Version
-version = Version [~a] []
-" (string-map (lambda (chr) (if (eq? chr #\.) #\, chr)) ,version))))
-             #t)))))
+     `(#:tests? #f ; Tests fail due to missing /etc/protocols?
+       #:cabal-revision ("1"
+                         "04y04vbxbnblpmqqmpl8km4bkcjaj96nbxkssdr1zgbhqisxay5q")))
     (home-page "https://github.com/haskell/HTTP")
     (synopsis "Library for client-side HTTP")
     (description
@@ -220,37 +198,35 @@ responses coming back.")
 (define-public ghc-http-client
   (package
     (name "ghc-http-client")
-    (version "0.7.11")
+    (version "0.7.13.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "http-client" version))
               (sha256
                (base32
-                "12j7vkpkm2djws6ny7vm2324c7916d0iaf1mbvf4mfjxzy2w7imv"))))
+                "09qfmakjk285jz2rnb53c1m9c764fg8vngfq43ipga1g72h8d3n9"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "http-client")))
-    ;; Tests require access to the web.
-    (arguments `(#:tests? #f))
-    (inputs
-     (list ghc-async
-           ghc-base64-bytestring
-           ghc-blaze-builder
-           ghc-case-insensitive
-           ghc-cookie
-           ghc-data-default-class
-           ghc-exceptions
-           ghc-http-types
-           ghc-iproute
-           ghc-memory
-           ghc-mime-types
-           ghc-monad-control
-           ghc-network
-           ghc-network-uri
-           ghc-random
-           ghc-streaming-commons
-           ghc-zlib))
-    (native-inputs
-     (list ghc-hspec))
+    (inputs (list ghc-http-types
+                  ghc-blaze-builder
+                  ghc-network
+                  ghc-streaming-commons
+                  ghc-case-insensitive
+                  ghc-base64-bytestring
+                  ghc-cookie
+                  ghc-random
+                  ghc-mime-types
+                  ghc-iproute
+                  ghc-async
+                  ghc-network-uri))
+    (native-inputs (list ghc-hspec
+                         ghc-monad-control
+                         ghc-zlib
+                         ghc-hspec
+                         ghc-monad-control
+                         ghc-zlib
+                         hspec-discover))
+    (arguments (list #:tests? #f)) ; Tests try to access httpbin.org.
     (home-page "https://github.com/snoyberg/http-client")
     (synopsis "HTTP client engine")
     (description
@@ -344,42 +320,44 @@ Date in Haskell.")
 (define-public ghc-http2
   (package
     (name "ghc-http2")
-    (version "3.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "http2" version))
-       (sha256
-        (base32
-         "13c2z35gdimncgpyg5dn5cpjvd83rbrigc8b40crg36678m0k0d1"))))
+    (version "3.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "http2" version))
+              (sha256
+               (base32
+                "1kv99i3pnnx31xndlkaczrpd2j5mvzbqlfz1kaw6cwlwkdnl5bhv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "http2")))
-    (inputs
-     (list ghc-aeson
-           ghc-aeson-pretty
-           ghc-base16-bytestring
-           ghc-case-insensitive
-           ghc-cryptonite
-           ghc-http-types
-           ghc-network-byte-order
-           ghc-network
-           ghc-network-run
-           ghc-psqueues
-           ghc-time-manager
-           ghc-unix-time
-           ghc-unordered-containers
-           ghc-vector
-           ghc-word8))
-    (native-inputs
-     (list ghc-async
-           ghc-doctest
-           ghc-glob
-           ghc-hspec
-           hspec-discover
-           ghc-typed-process))
+    (inputs (list ghc-async
+                  ghc-case-insensitive
+                  ghc-http-types
+                  ghc-network
+                  ghc-network-byte-order
+                  ghc-psqueues
+                  ghc-time-manager
+                  ghc-unix-time
+                  ghc-network-run
+                  ghc-cryptonite
+                  ghc-aeson
+                  ghc-aeson-pretty
+                  ghc-base16-bytestring
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-word8))
+    (native-inputs (list ghc-doctest
+                         ghc-hspec
+                         ghc-typed-process
+                         ghc-hspec
+                         ghc-typed-process
+                         ghc-hspec
+                         ghc-glob
+                         ghc-hspec
+                         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
+    (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)))
 
@@ -444,34 +422,30 @@ which allow you to avoid direct usage of conduits.")
 (define-public ghc-http-reverse-proxy
   (package
     (name "ghc-http-reverse-proxy")
-    (version "0.6.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "http-reverse-proxy" version))
-       (sha256
-        (base32
-         "1a6i5njf85b2lhg8m83njagcf09wih5q2irnyb2890s724qr277v"))))
+    (version "0.6.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "http-reverse-proxy" version))
+              (sha256
+               (base32
+                "0a0fc9rqr1crbb1sbq3gzbkwjcfff662d4bgmy3vzspk7ky697ld"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "http-reverse-proxy")))
-    (inputs
-     (list ghc-case-insensitive
-           ghc-http-types
-           ghc-word8
-           ghc-blaze-builder
-           ghc-http-client
-           ghc-wai
-           ghc-network
-           ghc-conduit
-           ghc-conduit-extra
-           ghc-wai-logger
-           ghc-resourcet
-           ghc-unliftio
-           ghc-streaming-commons))
-    (native-inputs
-     (list ghc-hspec ghc-warp ghc-http-conduit))
-    (home-page
-     "https://github.com/fpco/http-reverse-proxy")
+    (inputs (list ghc-case-insensitive
+                  ghc-http-types
+                  ghc-word8
+                  ghc-blaze-builder
+                  ghc-http-client
+                  ghc-wai
+                  ghc-network
+                  ghc-conduit
+                  ghc-conduit-extra
+                  ghc-wai-logger
+                  ghc-resourcet
+                  ghc-unliftio
+                  ghc-streaming-commons))
+    (native-inputs (list ghc-hspec ghc-warp ghc-http-conduit))
+    (home-page "https://github.com/fpco/http-reverse-proxy")
     (synopsis
      "Reverse proxy HTTP requests, either over raw sockets or with WAI")
     (description
@@ -512,14 +486,14 @@ communication between web applications and web servers.")
 (define-public ghc-wai-logger
   (package
     (name "ghc-wai-logger")
-    (version "2.3.6")
+    (version "2.4.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "wai-logger" version))
        (sha256
         (base32
-         "0hbm7if28p6qa36cgpyq6i569275si53z9gsl2g1z8x09z3xiyz2"))))
+         "02i9jsy5gdglqwwk5gcvax8y498lz9flrfp4v9nrv8rmrmd66zh5"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "wai-logger")))
     (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
@@ -543,38 +517,39 @@ communication between web applications and web servers.")
 (define-public ghc-wai-extra
   (package
     (name "ghc-wai-extra")
-    (version "3.1.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "wai-extra" version))
-       (sha256
-        (base32
-         "1avf7bjcsbs8l6klp5kkd0cd2dc5n0j0a2yf8813pnwfn5b7qyd4"))))
+    (version "3.1.13.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "wai-extra" version))
+              (sha256
+               (base32
+                "1h4cqd5akrq0vhv3l0fzryy7qw0c2jb58lngx7x8ij63bckjs3fz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "wai-extra")))
-    (inputs
-     (list ghc-ansi-terminal
-           ghc-base64-bytestring
-           ghc-call-stack
-           ghc-cookie
-           ghc-network
-           ghc-streaming-commons
-           ghc-resourcet
-           ghc-fast-logger
-           ghc-wai-logger
-           ghc-word8
-           ghc-iproute
-           ghc-wai
-           ghc-http-types
-           ghc-http2
-           ghc-case-insensitive
-           ghc-data-default-class
-           ghc-vault
-           ghc-aeson))
-    (native-inputs
-     (list hspec-discover ghc-hspec ghc-hunit ghc-zlib))
-    (home-page "https://github.com/yesodweb/wai")
+    (inputs (list ghc-aeson
+                  ghc-ansi-terminal
+                  ghc-base64-bytestring
+                  ghc-call-stack
+                  ghc-case-insensitive
+                  ghc-cookie
+                  ghc-data-default-class
+                  ghc-fast-logger
+                  ghc-http-types
+                  ghc-hunit
+                  ghc-iproute
+                  ghc-network
+                  ghc-resourcet
+                  ghc-streaming-commons
+                  ghc-vault
+                  ghc-wai
+                  ghc-wai-logger
+                  ghc-warp
+                  ghc-word8))
+    (native-inputs (list ghc-hspec ghc-temporary ghc-zlib hspec-discover))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0dyvg2bb37im790757khncxpnf45451dd8575p736ry4g8rpqgpw")))
+    (home-page "http://github.com/yesodweb/wai")
     (synopsis "Some basic WAI handlers and middleware")
     (description "This library provides basic WAI handlers and middleware
 functionality.")
@@ -615,11 +590,7 @@ Haskell's Web Application Interface (WAI).")
     (build-system haskell-build-system)
     (properties '((upstream-name . "bsb-http-chunked")))
     (arguments
-     `(;; XXX: As of 0.0.4, one property test ("Identical output as Blaze")
-       ;; fails on i686-linux.
-       #:tests? ,(and (not (%current-target-system))
-                      (not (string-prefix? "i686" (or (%current-target-system)
-                                                      (%current-system)))))
+     `(#:tests? #f ; Tests fail: Variable not in scope.
        #:cabal-revision
        ("3" "15hg352id2f4x0dnvv47bdiz6gv5hp5a2mki9yzmhc7ajpk31mdd")))
     (native-inputs
@@ -640,13 +611,13 @@ transfers.")
 (define-public ghc-warp
   (package
     (name "ghc-warp")
-    (version "3.3.17")
+    (version "3.3.23")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "warp" version))
        (sha256
-        (base32 "0v54ca3wpa79gdyiikwhbv9h8b5vr3d60piq3ndb2v7s7fi1qpm0"))))
+        (base32 "0y1r7czq5zrgklqrx1b9pmxn5lhmf7zpqdjz7hfmnzsmr3vndmms"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "warp")))
     (inputs
@@ -668,7 +639,8 @@ transfers.")
            ghc-simple-sendfile
            ghc-unliftio
            ghc-x509
-           ghc-http2))
+           ghc-http2
+           ghc-recv))
     (native-inputs
      (list curl
            ghc-silently
@@ -709,27 +681,25 @@ limitation, automatic pruning, energy saving and replay resistance.")
 (define-public ghc-warp-tls
   (package
     (name "ghc-warp-tls")
-    (version "3.3.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "warp-tls" version))
-       (sha256
-        (base32
-         "0b9viw26ymzq4q8snfddz3w59sqcf5ankxnw6f99iacxjhk6zs6m"))))
+    (version "3.3.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "warp-tls" version))
+              (sha256
+               (base32
+                "00vgs9v7k0fapl05knqii9g47svf4lapb7ixkll7xr4zvmkk0r0m"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "warp-tls")))
-    (inputs
-     (list ghc-cryptonite
-           ghc-data-default-class
-           ghc-network
-           ghc-streaming-commons
-           ghc-tls
-           ghc-tls-session-manager
-           ghc-unliftio
-           ghc-wai
-           ghc-warp))
-    (home-page "https://github.com/yesodweb/wai")
+    (inputs (list ghc-wai
+                  ghc-warp
+                  ghc-data-default-class
+                  ghc-tls
+                  ghc-cryptonite
+                  ghc-network
+                  ghc-streaming-commons
+                  ghc-tls-session-manager
+                  ghc-unliftio))
+    (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.")
@@ -738,34 +708,34 @@ a WAI handler, via the native Haskell TLS implementation.")
 (define-public ghc-websockets
   (package
     (name "ghc-websockets")
-    (version "0.12.7.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "websockets" version))
-       (sha256
-        (base32
-         "1b92a41l2var1ccg350mh2bjmb2plb6d79yzvmlwkd41nifmmi44"))))
+    (version "0.12.7.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "websockets" version))
+              (sha256
+               (base32
+                "0g3z0n4irf3gvbdf9p97jq05ybdg0gwjy5bj4nfc7ivsvyhaic6k"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "websockets")))
-    (inputs
-     (list ghc-attoparsec
-           ghc-base64-bytestring
-           ghc-bytestring-builder
-           ghc-case-insensitive
-           ghc-network
-           ghc-random
-           ghc-sha
-           ghc-clock
-           ghc-async
-           ghc-streaming-commons
-           ghc-entropy))
-    (native-inputs
-     (list ghc-hunit ghc-quickcheck ghc-test-framework
-           ghc-test-framework-hunit ghc-test-framework-quickcheck2))
-    (home-page "https://jaspervdj.be/websockets/")
-    (synopsis
-     "Write WebSocket-capable servers in Haskell")
+    (inputs (list ghc-async
+                  ghc-attoparsec
+                  ghc-base64-bytestring
+                  ghc-bytestring-builder
+                  ghc-case-insensitive
+                  ghc-clock
+                  ghc-network
+                  ghc-random
+                  ghc-sha
+                  ghc-streaming-commons
+                  ghc-entropy))
+    (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1yx97y6jl74vy200y43vjxfyzx338kh10dx8vxkjhr0mfh36wldq")))
+    (home-page "http://jaspervdj.be/websockets")
+    (synopsis "Write WebSocket-capable servers in Haskell")
     (description
      "This library allows you to write WebSocket-capable servers.
 
@@ -811,26 +781,25 @@ See also:
 (define-public ghc-xss-sanitize
   (package
     (name "ghc-xss-sanitize")
-    (version "0.3.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "xss-sanitize" version))
-       (sha256
-        (base32
-         "1d72s3a6520iwwc1wbn9v2znqgbw6a5wwzb23iq8ny9ccnjyx1dk"))))
+    (version "0.3.7.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "xss-sanitize" version))
+              (sha256
+               (base32
+                "1lmmyh28mb1k44m63m7qx6iy4x2fgqq5srmky47dsm0fby9iag1h"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "xss-sanitize")))
-    (inputs
-     (list ghc-tagsoup ghc-utf8-string ghc-css-text ghc-network-uri))
-    (native-inputs
-     (list ghc-attoparsec ghc-hspec ghc-hunit))
-    (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
+    (inputs (list ghc-attoparsec ghc-css-text ghc-network-uri ghc-tagsoup
+                  ghc-utf8-string))
+    (native-inputs (list ghc-hunit ghc-hspec))
+    (home-page "https://github.com/yesodweb/haskell-xss-sanitize#readme")
     (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
-    (description "This library provides @code{sanitizeXSS}.  Run untrusted
+    (description
+     "This library provides @code{sanitizeXSS}.  Run untrusted
 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
 attacks.")
-    (license license:bsd-3)))
+    (license license:bsd-2)))
 
 (define-public ghc-css-text
   (package
@@ -955,54 +924,54 @@ entity decoding bugfixes applied.")
 (define-public ghc-aeson
   (package
     (name "ghc-aeson")
-    (version "1.5.6.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "aeson" version))
-       (sha256
-        (base32
-         "1s5z4bgb5150h6a4cjf5vh8dmyrn6ilh29gh05999v6jwd5w6q83"))))
+    (version "2.0.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "aeson" version))
+              (sha256
+               (base32
+                "09dk0j33n262dm75vff3y3i9fm6lh06dyqswwv7a6kvnhhmhlxhr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "aeson")))
+    (inputs (list ghc-base-compat-batteries
+                  ghc-time-compat
+                  ghc-attoparsec
+                  ghc-data-fix
+                  ghc-dlist
+                  ghc-hashable
+                  ghc-indexed-traversable
+                  ghc-onetuple
+                  ghc-primitive
+                  ghc-quickcheck
+                  ghc-scientific
+                  ghc-semialign
+                  ghc-strict
+                  ghc-tagged
+                  ghc-text-short
+                  ghc-th-abstraction
+                  ghc-these
+                  ghc-unordered-containers
+                  ghc-uuid-types
+                  ghc-vector
+                  ghc-witherable))
+    (native-inputs (list ghc-base-compat
+                         ghc-base-orphans
+                         ghc-base16-bytestring
+                         ghc-diff
+                         ghc-generic-deriving
+                         ghc-integer-logarithms
+                         ghc-quickcheck-instances
+                         ghc-tasty
+                         ghc-tasty-golden
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
     (arguments
-     `(#:tests? #f ; FIXME: testing libraries are missing.
-       #:cabal-revision
-       ("2" "1zxkarvmbgc2cpcc9sx1rlqm7nfh473052898ypiwk8azawp1hbj")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-attoparsec
-           ghc-base-compat-batteries
-           ghc-data-fix
-           ghc-dlist
-           ghc-hashable
-           ghc-primitive
-           ghc-scientific
-           ghc-strict
-           ghc-tagged
-           ghc-th-abstraction
-           ghc-these
-           ghc-time-compat
-           ghc-unordered-containers
-           ghc-uuid-types
-           ghc-vector))
-;    (native-inputs
-;     `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
-;       ("ghc-base-compat" ,ghc-base-compat)
-;       ("ghc-base-orphans" ,ghc-base-orphans)
-;       ("ghc-diff" ,ghc-diff)
-;       ("ghc-generic-deriving" ,ghc-generic-deriving)
-;       ("ghc-hashable-time" ,ghc-hashable-time)
-;       ("ghc-integer-logarithms" ,ghc-integer-logarithms)
-;       ("ghc-quickcheck" ,ghc-quickcheck)
-;       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
-;       ("ghc-tasty" ,ghc-tasty)
-;       ("ghc-tasty-golden" ,ghc-tasty-golden)
-;       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-;       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
-    (home-page "https://github.com/bos/aeson")
+     `(#:cabal-revision ("1"
+                         "1zrgn63jzrpk3n3vd44zkzgw7kb5qxlvhx4nk6g3sswwrsz5j32i")))
+    (home-page "https://github.com/haskell/aeson")
     (synopsis "Fast JSON parsing and encoding")
-    (description "This package provides a JSON parsing and encoding library
+    (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)))
@@ -1071,28 +1040,27 @@ of a JSON value into a @code{Data.Aeson.Value}.")
 (define-public ghc-aeson-better-errors
   (package
     (name "ghc-aeson-better-errors")
-    (version "0.9.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "aeson-better-errors" version))
-       (sha256
-        (base32
-         "09vkyrhwak3bmpfsqcd2az8hfqqkxyhg468hv5avgisy0nzh3w38"))))
+    (version "0.9.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "aeson-better-errors" version))
+              (sha256
+               (base32
+                "05yibq9kqbjb8rh84n12sbax05amvd8jccpja0hyadz58pjy4jnk"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "aeson-better-errors")))
-    (inputs
-     (list ghc-aeson
-           ghc-unordered-containers
-           ghc-dlist
-           ghc-scientific
-           ghc-vector
-           ghc-transformers-compat
-           ghc-void))
-    (home-page
-     "https://github.com/hdgarrood/aeson-better-errors")
-    (synopsis
-     "Better error messages when decoding JSON values in Haskell")
+    (inputs (list ghc-aeson
+                  ghc-unordered-containers
+                  ghc-dlist
+                  ghc-scientific
+                  ghc-vector
+                  ghc-transformers-compat
+                  ghc-void))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0wzvrmhn5q2x1mcv43cyxhlck815ldkhx7c7gz5ijjyva1iicgn2")))
+    (home-page "https://github.com/hdgarrood/aeson-better-errors")
+    (synopsis "Better error messages when decoding JSON values in Haskell")
     (description
      "Gives you the tools to build parsers to decode JSON values, and gives
 good error messages when parsing fails.  See also
@@ -1114,6 +1082,9 @@ good error messages when parsing fails.  See also
     (properties '((upstream-name . "multipart")))
     (inputs
      (list ghc-stringsearch))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "03gaapwnvn843hpm5qwdci9df1wf383msd42p8w9ghilpfjj4qy9")))
     (home-page
      "http://www.github.com/silkapp/multipart")
     (synopsis
@@ -1137,6 +1108,9 @@ good error messages when parsing fails.  See also
     (properties '((upstream-name . "uri-encode")))
     (inputs
      (list ghc-utf8-string ghc-network-uri))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "03pmvbi56gmg1z2wr3glncc7dbyh666bqp565inh31qzsp9zwmgj")))
     (home-page "https://hackage.haskell.org/package/uri-encode")
     (synopsis "Unicode aware uri-encoding")
     (description "Unicode aware uri-encoding for Haskell.")
@@ -1222,67 +1196,58 @@ avoid any issues with characters.")
 (define-public ghc-yesod-core
   (package
     (name "ghc-yesod-core")
-    (version "1.6.21.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "yesod-core" version))
-       (sha256
-        (base32
-         "0wmh7ip318p89lyy6k5mvxkkpq43knp41wlq9iaf3icz0ahqdmb7"))))
+    (version "1.6.24.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "yesod-core" version))
+              (sha256
+               (base32
+                "19ilgm73108ki1hvqc86kir0yrx36vp9g45na6g8dmfsvk9izr10"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "yesod-core")))
-    (inputs (list ghc-wai
-                  ghc-extra
-                  ghc-shakespeare
-                  ghc-blaze-builder
+    (inputs (list ghc-aeson
+                  ghc-auto-update
+                  ghc-blaze-html
+                  ghc-blaze-markup
+                  ghc-case-insensitive
+                  ghc-cereal
                   ghc-clientsession
+                  ghc-conduit
+                  ghc-conduit-extra
+                  ghc-cookie
+                  ghc-entropy
+                  ghc-fast-logger
+                  ghc-http-types
+                  ghc-memory
+                  ghc-monad-logger
+                  ghc-path-pieces
+                  ghc-primitive
                   ghc-random
-                  ghc-cereal
-                  ghc-old-locale
+                  ghc-resourcet
+                  ghc-shakespeare
+                  ghc-unix-compat
                   ghc-unliftio
                   ghc-unordered-containers
-                  ghc-monad-control
-                  ghc-transformers-base
-                  ghc-cookie
-                  ghc-http-types
-                  ghc-case-insensitive
                   ghc-vector
-                  ghc-aeson
-                  ghc-fast-logger
+                  ghc-wai
+                  ghc-wai-extra
                   ghc-wai-logger
-                  ghc-monad-logger
-                  ghc-conduit
-                  ghc-resourcet
-                  ghc-rio
-                  ghc-lifted-base
-                  ghc-blaze-html
-                  ghc-blaze-markup
-                  ghc-data-default
-                  ghc-safe
                   ghc-warp
-                  ghc-unix-compat
-                  ghc-conduit-extra
-                  ghc-exceptions
-                  ghc-deepseq-generics
-                  ghc-mwc-random
-                  ghc-primitive
-                  ghc-word8
-                  ghc-auto-update
-                  ghc-semigroups
-                  ghc-byteable))
+                  ghc-word8))
     (native-inputs (list ghc-hspec
-                         ghc-path-pieces
                          ghc-hunit
+                         ghc-async
+                         ghc-hspec
                          ghc-hspec-expectations
-                         ghc-quickcheck
                          ghc-network
-                         ghc-async
-                         ghc-streaming-commons
-                         ghc-wai-extra))
-    (home-page "https://www.yesodweb.com")
+                         ghc-streaming-commons))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1406s7is60ji6nn3h1mafkdh7729ipq3i06cqsq77hz2ilj264jl")))
+    (home-page "http://www.yesodweb.com/")
     (synopsis "Core package for the Yesod web framework")
-    (description "This Haskell package provides all core functionality, for
+    (description
+     "This Haskell package provides all core functionality, for
 Yesod, on which other packages can be built.  It provides dispatch, handler
 functions, widgets, etc.")
     (license license:expat)))
@@ -1290,17 +1255,15 @@ functions, widgets, etc.")
 (define-public ghc-yesod-persistent
   (package
     (name "ghc-yesod-persistent")
-    (version "1.6.0.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "yesod-persistent" version))
-       (sha256
-        (base32
-         "102xmp7n08sk1g5rv31jpln2v9kqf1zsqsnmi83mnhmgggcbj1k4"))))
+    (version "1.6.0.8")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "yesod-persistent" version))
+              (sha256
+               (base32
+                "02vm0qm0yxqn6x61iir81wf6ibwnf8gkia8lw71fgpxgav154ig6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "yesod-persistent")))
-    (arguments `(#:tests? #f)) ; FIXME: hspec-discover not available in PATH.
     (inputs (list ghc-yesod-core
                   ghc-persistent
                   ghc-persistent-template
@@ -1308,9 +1271,9 @@ functions, widgets, etc.")
                   ghc-conduit
                   ghc-resourcet
                   ghc-resource-pool))
-    (native-inputs (list ghc-hspec ghc-wai-extra ghc-yesod-core
-                         ghc-persistent-sqlite))
-    (home-page "https://www.yesodweb.com/")
+    (native-inputs (list ghc-hspec ghc-wai-extra ghc-persistent-sqlite
+                         hspec-discover))
+    (home-page "http://www.yesodweb.com/")
     (synopsis "Helpers for using Persistent from Yesod")
     (description "This Haskell package provides helpers for using Persistent
 from Yesod.")
@@ -1318,78 +1281,75 @@ from Yesod.")
 
 (define-public ghc-yesod-form
     (package
-    (name "ghc-yesod-form")
-    (version "1.7.0")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "yesod-form" version))
-        (sha256
-          (base32
-            "170gby381h5pg9njn908cyx2931yiv79x3rc5npg2rd74kif06vi"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "yesod-form")))
-    (inputs
-      (list ghc-yesod-core
-            ghc-yesod-persistent
-            ghc-shakespeare
-            ghc-persistent
-            ghc-data-default
-            ghc-xss-sanitize
-            ghc-blaze-builder
-            ghc-email-validate
-            ghc-wai
-            ghc-blaze-html
-            ghc-blaze-markup
-            ghc-attoparsec
-            ghc-byteable
-            ghc-aeson
-            ghc-resourcet
-            ghc-semigroups
-            ghc-network-uri
-            ghc-hspec))
-    (home-page "https://www.yesodweb.com")
-    (synopsis "Form handling support for Yesod Web Framework")
-    (description "This Haskell package provides a set of basic form inputs such
+      (name "ghc-yesod-form")
+      (version "1.7.3")
+      (source (origin
+                (method url-fetch)
+                (uri (hackage-uri "yesod-form" version))
+                (sha256
+                 (base32
+                  "10y3mfh96sicqyzngvl7f4wrjgkvl3znqnh71s8gx1vf7158sjww"))))
+      (build-system haskell-build-system)
+      (properties '((upstream-name . "yesod-form")))
+      (inputs (list ghc-aeson
+                    ghc-attoparsec
+                    ghc-blaze-builder
+                    ghc-blaze-html
+                    ghc-blaze-markup
+                    ghc-byteable
+                    ghc-data-default
+                    ghc-email-validate
+                    ghc-persistent
+                    ghc-resourcet
+                    ghc-shakespeare
+                    ghc-wai
+                    ghc-xss-sanitize
+                    ghc-yesod-core
+                    ghc-yesod-persistent
+                    ghc-network-uri))
+      (native-inputs (list ghc-hspec))
+      (home-page "http://www.yesodweb.com/")
+      (synopsis "Form handling support for Yesod Web Framework")
+      (description
+       "This Haskell package provides a set of basic form inputs such
 as text, number, time, checkbox, select, textarea, etc through the
 @code{Yesod.Form.Fields} module.  Also, there is @code{Yesod.Form.Nic} module
 providing richtext field using Nic editor.")
-    (license license:expat)))
+      (license license:expat)))
 
 (define-public ghc-yesod
   (package
     (name "ghc-yesod")
-    (version "1.6.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "yesod" version))
-       (sha256
-        (base32
-         "13r0ispprj41kgn2rkc7zhy1rxfmgpjbmdlnys15h0ihhh3zhw2f"))))
+    (version "1.6.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "yesod" version))
+              (sha256
+               (base32
+                "1qglaxqx96c7wi4817ff67c9g2fxlnjzdpgic458i80khpdlmb5c"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "yesod")))
-    (inputs
-     (list ghc-yesod-core
-           ghc-yesod-persistent
-           ghc-yesod-form
-           ghc-wai
-           ghc-wai-extra
-           ghc-warp
-           ghc-aeson
-           ghc-file-embed
-           ghc-data-default-class
-           ghc-unordered-containers
-           ghc-yaml
-           ghc-monad-logger
-           ghc-fast-logger
-           ghc-conduit
-           ghc-shakespeare
-           ghc-streaming-commons
-           ghc-wai-logger))
-    (home-page "https://www.yesodweb.com")
+    (inputs (list ghc-aeson
+                  ghc-conduit
+                  ghc-data-default-class
+                  ghc-fast-logger
+                  ghc-file-embed
+                  ghc-monad-logger
+                  ghc-shakespeare
+                  ghc-streaming-commons
+                  ghc-unordered-containers
+                  ghc-wai
+                  ghc-wai-extra
+                  ghc-wai-logger
+                  ghc-warp
+                  ghc-yaml
+                  ghc-yesod-core
+                  ghc-yesod-form
+                  ghc-yesod-persistent))
+    (home-page "http://www.yesodweb.com/")
     (synopsis "Framework for creating type-safe, RESTful web applications")
-    (description "The Haskell package package groups together the various
+    (description
+     "The Haskell package package groups together the various
 Yesod related packages into one cohesive whole.  This is the version of Yesod,
 whereas most of the core code lives in @code{ghc-yesod-core}.")
     (license license:expat)))
@@ -1541,56 +1501,69 @@ pipes-http re-export this package's types and functions.")
 (define-public ghc-http-streams
   (package
     (name "ghc-http-streams")
-    (version "0.8.9.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "http-streams" version))
-       (sha256
-        (base32
-         "03xdcb0v735xdrkjlm1w56mskh3x08cbsjrcd7wn4li65ixc20xa"))))
+    (version "0.8.9.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "http-streams" version))
+              (sha256
+               (base32
+                "1h8nnp1y4ngv6mwr3fxv428kcvrd3ming179sza8fkn49pcwdlxs"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "http-streams")))
-    (inputs
-     (list ghc-attoparsec
-           ghc-base64-bytestring
-           ghc-blaze-builder
-           ghc-case-insensitive
-           ghc-io-streams
-           ghc-hsopenssl
-           ghc-openssl-streams
-           ghc-unordered-containers
-           ghc-aeson
-           ghc-http-common
-           ghc-network-uri
-           ghc-network))
-    (arguments
-     `(#:tests? #f)) ; tests rely on an outdated version of snap-server
-    (home-page "https://github.com/afcowie/http-streams/")
+    (inputs (list ghc-attoparsec
+                  ghc-base64-bytestring
+                  ghc-blaze-builder
+                  ghc-case-insensitive
+                  ghc-io-streams
+                  ghc-hsopenssl
+                  ghc-openssl-streams
+                  ghc-unordered-containers
+                  ghc-aeson
+                  ghc-http-common
+                  ghc-network-uri
+                  ghc-network))
+    (native-inputs (list ghc-hunit
+                         ghc-lifted-base
+                         ghc-aeson-pretty
+                         ghc-hspec
+                         ghc-hspec-expectations
+                         ghc-random
+                         ghc-snap-core
+                         ghc-snap-server))
+    (home-page "https://github.com/aesiniath/http-streams/")
     (synopsis "HTTP client using io-streams")
-    (description "An HTTP client using the Snap Framework's 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)))
 
+;; Breaks cycle between ghc-http-streams and ghc-snap-server
+(define-public ghc-http-streams-bootstrap
+  (package
+    (inherit ghc-http-streams)
+    (name "ghc-http-streams-bootstrap")
+    (arguments `(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
 (define-public ghc-snap-core
   (package
     (name "ghc-snap-core")
-    (version "1.0.4.2")
+    (version "1.0.5.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "snap-core" version))
        (sha256
         (base32
-         "0zxdhx4wk70bkn71574lyz3zhq79yy98rv05r4564rd100xw3fqs"))))
+         "0hf671g7h4nikfvi05q3mmcxhfcsh874dkansssn0mc68k9fsak4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "snap-core")))
     (arguments
-     `(#:tests? #f ; TODO: Fail to compile.
-       #:cabal-revision
-       ("1" "065v61clskzikywv0gy9n4fjaszi2fnjklal83kqbzhzzgkf83ng")))
+     `(#:cabal-revision
+       ("3" "02r6plphl4vqig3xap9amdib0qjd98nqpn5jhy6hsbiwh3p7cy9b")))
     (inputs
      (list ghc-old-locale
            ghc-hunit
@@ -1659,12 +1632,20 @@ contains the core definitions and types for the Snap framework.")
            ghc-threads
            ghc-hunit
            ghc-quickcheck
-           ghc-http-streams
+           ghc-http-streams-bootstrap
            ghc-http-common
            ghc-parallel
            ghc-test-framework
            ghc-test-framework-hunit
            ghc-test-framework-quickcheck2))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "snap-server.cabal"
+               (("\\b(attoparsec|base|bytestring|time)\\s+[^,]+" all dep)
+                dep)))))))
     (home-page "http://snapframework.com/")
     (synopsis "Web server for the Snap Framework")
     (description "Snap is a simple and fast web development framework
@@ -1730,37 +1711,33 @@ requirements of downstream users (e.g. Debian).")
 (define-public ghc-happstack-server
   (package
     (name "ghc-happstack-server")
-    (version "7.7.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "happstack-server" version))
-       (sha256
-        (base32
-         "0nc5rnvrzl9m3pinmdq234m80qkf4jszbdqnd567f7lh09yiqw9n"))))
+    (version "7.7.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "happstack-server" version))
+              (sha256
+               (base32
+                "175aal1l4g558y89skck3s04db0bjblkxp77bijf1s9iyc07n669"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "happstack-server")))
-    (inputs
-     (list ghc-network
-           ghc-network-bsd
-           ghc-network-uri
-           ghc-base64-bytestring
-           ghc-blaze-html
-           ghc-exceptions
-           ghc-extensible-exceptions
-           ghc-hslogger
-           ghc-html
-           ghc-monad-control
-           ghc-old-locale
-           ghc-semigroups
-           ghc-sendfile
-           ghc-system-filepath
-           ghc-syb
-           ghc-threads
-           ghc-transformers-base
-           ghc-transformers-compat
-           ghc-utf8-string
-           ghc-zlib))
+    (inputs (list ghc-network
+                  ghc-network-uri
+                  ghc-base64-bytestring
+                  ghc-blaze-html
+                  ghc-extensible-exceptions
+                  ghc-hslogger
+                  ghc-html
+                  ghc-monad-control
+                  ghc-old-locale
+                  ghc-semigroups
+                  ghc-sendfile
+                  ghc-system-filepath
+                  ghc-syb
+                  ghc-threads
+                  ghc-transformers-base
+                  ghc-transformers-compat
+                  ghc-utf8-string
+                  ghc-zlib))
     (native-inputs (list ghc-hunit))
     (home-page "https://happstack.com")
     (synopsis "Web related tools and services for Haskell")
@@ -1773,19 +1750,17 @@ cookies, serving files, and more.")
 (define-public ghc-sendfile
   (package
     (name "ghc-sendfile")
-    (version "0.7.11.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "sendfile" version))
-       (sha256
-        (base32
-         "0988snmx3bylpw3kcq8hsgji8idc6xcrcfp275qjv3apfdgc9rp0"))))
+    (version "0.7.11.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "sendfile" version))
+              (sha256
+               (base32
+                "1i2i0w18l2ysambyylv93jzy0adiiqwwnhg7zagqb7p2srybxc3k"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "sendfile")))
     (inputs (list ghc-network))
-    (home-page
-     "https://hub.darcs.net/stepcut/sendfile")
+    (home-page "https://github.com/Happstack/sendfile")
     (synopsis "Portable sendfile library for Haskell")
     (description
      "Haskell library which exposes zero-copy sendfile functionality in a portable way.")
@@ -1794,28 +1769,25 @@ cookies, serving files, and more.")
 (define-public ghc-scalpel-core
   (package
     (name "ghc-scalpel-core")
-    (version "0.6.2")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "scalpel-core" version))
-        (sha256
-         (base32
-          "07mjff8aqwabx8yhq8bd7jpnarkkrjqss8h8s2wkfmfj808fllmf"))))
+    (version "0.6.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "scalpel-core" version))
+              (sha256
+               (base32
+                "1yl1lsi5xm3qdlww2sb6vyppjiisj54f4yzvffv3qg8dgkfjfdra"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "scalpel-core")))
-    (inputs
-     (list ghc-data-default
-           ghc-fail
-           ghc-pointedlist
-           ghc-regex-base
-           ghc-regex-tdfa
-           ghc-tagsoup
-           ghc-vector))
+    (inputs (list ghc-data-default
+                  ghc-fail
+                  ghc-pointedlist
+                  ghc-regex-base
+                  ghc-regex-tdfa
+                  ghc-tagsoup
+                  ghc-vector))
     (native-inputs (list ghc-hunit))
     (home-page "https://github.com/fimad/scalpel")
-    (synopsis
-     "High level web scraping library for Haskell")
+    (synopsis "High level web scraping library for Haskell")
     (description
      "Scalpel core provides a subset of the scalpel web scraping library
 that is intended to have lightweight dependencies and to be free of all
@@ -1825,26 +1797,23 @@ non-Haskell dependencies.")
 (define-public ghc-scalpel
   (package
     (name "ghc-scalpel")
-    (version "0.6.2")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "scalpel" version))
-        (sha256
-         (base32
-          "04hhvk0yjxha3yg6n9fxivrz97hpjjiiblnj0bvs5myax1ggkjch"))))
+    (version "0.6.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "scalpel" version))
+              (sha256
+               (base32
+                "0w3l38czfsgbyd3x6yir7qw9bl8nmhclrbpbwfyhs39728jlscnc"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "scalpel")))
-    (inputs
-     (list ghc-scalpel-core
-           ghc-case-insensitive
-           ghc-data-default
-           ghc-http-client
-           ghc-http-client-tls
-           ghc-tagsoup))
+    (inputs (list ghc-scalpel-core
+                  ghc-case-insensitive
+                  ghc-data-default
+                  ghc-http-client
+                  ghc-http-client-tls
+                  ghc-tagsoup))
     (home-page "https://github.com/fimad/scalpel")
-    (synopsis
-     "High level web scraping library for Haskell")
+    (synopsis "High level web scraping library for Haskell")
     (description
      "Scalpel is a web scraping library inspired by libraries like Parsec
 and Perl's @code{Web::Scraper}.  Scalpel builds on top of TagSoup to provide a
@@ -1854,23 +1823,19 @@ declarative and monadic interface.")
 (define-public ghc-sourcemap
   (package
     (name "ghc-sourcemap")
-    (version "0.1.6.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "sourcemap" version))
-       (sha256
-        (base32
-         "0kz8xpcd5syg5s4qa2qq8ylaxjhabj127w42may46vv6i0q1bf8a"))))
+    (version "0.1.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "sourcemap" version))
+              (sha256
+               (base32
+                "09i340mhzlfi5ayy9cb0378glnygdmpdhhsgikm3zrvwf2wmwr2h"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "sourcemap")))
-    (inputs
-     (list ghc-aeson ghc-unordered-containers ghc-attoparsec
-           ghc-utf8-string))
-    (arguments
-     `(#:tests? #f ; FIXME: Fail to compile
-       #:cabal-revision
-       ("1" "1f7q44ar6qfip8fsllg43jyn7r15ifn2r0vz32cbmx0sb0d38dax")))
+    (inputs (list ghc-aeson ghc-unordered-containers ghc-attoparsec
+                  ghc-utf8-string))
+    ;(native-inputs (list node))
+    (arguments (list #:tests? #f)) ; Needs node and module source-map.
     (home-page
      "https://hackage.haskell.org/package/sourcemap")
     (synopsis
@@ -1909,14 +1874,14 @@ as frontend to hjsmin.")
 (define-public ghc-bower-json
   (package
     (name "ghc-bower-json")
-    (version "1.0.0.1")
+    (version "1.1.0.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "bower-json" version))
        (sha256
         (base32
-         "0wvygg3rdbxzrmr61a9w6ddv9pfric85ih8hnxyk0ydzn7i59abs"))))
+         "0lnhcgivg38nicncb6czkkk3z2mk3jbifv1b4r51lk3p9blzydfl"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "bower-json")))
     (inputs
@@ -1969,42 +1934,41 @@ Authoring and Versioning (WebDAV) extensions to HTTP as well an executable,
 (define-public ghc-yesod-test
   (package
     (name "ghc-yesod-test")
-    (version "1.6.12")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "yesod-test" version))
-       (sha256
-        (base32
-         "1xgy7dzhqjgllqcpyyxs0spdg6vlz2c1sjvni7w7qnsf0ckyw2l8"))))
+    (version "1.6.15")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "yesod-test" version))
+              (sha256
+               (base32
+                "16q4f1l3m4l8iy5vmaa8c0vm2iiqhpghf3kykymlh41xy96mqpn3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "yesod-test")))
-    (inputs
-     (list ghc-hunit
-           ghc-aeson
-           ghc-attoparsec
-           ghc-blaze-builder
-           ghc-blaze-html
-           ghc-case-insensitive
-           ghc-conduit
-           ghc-cookie
-           ghc-hspec-core
-           ghc-html-conduit
-           ghc-http-types
-           ghc-network
-           ghc-memory
-           ghc-pretty-show
-           ghc-semigroups
-           ghc-wai
-           ghc-wai-extra
-           ghc-xml-conduit
-           ghc-xml-types
-           ghc-yesod-core))
-    (native-inputs
-     (list ghc-hspec ghc-yesod-form ghc-unliftio ghc-unliftio-core))
-    (home-page "https://www.yesodweb.com")
+    (inputs (list ghc-hunit
+                  ghc-aeson
+                  ghc-attoparsec
+                  ghc-blaze-builder
+                  ghc-blaze-html
+                  ghc-case-insensitive
+                  ghc-conduit
+                  ghc-cookie
+                  ghc-hspec-core
+                  ghc-html-conduit
+                  ghc-http-types
+                  ghc-network
+                  ghc-memory
+                  ghc-pretty-show
+                  ghc-wai
+                  ghc-wai-extra
+                  ghc-xml-conduit
+                  ghc-xml-types
+                  ghc-yesod-core
+                  ghc-blaze-markup))
+    (native-inputs (list ghc-hspec ghc-yesod-form ghc-unliftio
+                         ghc-unliftio-core))
+    (home-page "http://www.yesodweb.com")
     (synopsis "Integration testing for WAI/Yesod Applications")
-    (description "This package's main goal is to encourage integration
+    (description
+     "This package's main goal is to encourage integration
 and system testing of web applications by making everything easy to
 test.  Tests are like browser sessions that keep track of cookies and
 the last visited page.  You can perform assertions on the content of
@@ -2014,41 +1978,36 @@ HTML responses using CSS selectors.")
 (define-public ghc-wai-app-static
   (package
     (name "ghc-wai-app-static")
-    (version "3.1.7.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "wai-app-static" version))
-       (sha256
-        (base32
-         "138gd5482psq0wbm8s1az672lksi7vbavq6ayiyjkliivf6xpry8"))))
+    (version "3.1.7.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "wai-app-static" version))
+              (sha256
+               (base32
+                "1h8zy3dprqjxvlqxrids65yg5qf1h4f63ddspwxrbp0r9d28hwb4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "wai-app-static")))
-    (inputs
-     (list ghc-wai
-           ghc-http-types
-           ghc-unix-compat
-           ghc-old-locale
-           ghc-file-embed
-           ghc-cryptonite
-           ghc-memory
-           ghc-http-date
-           ghc-blaze-html
-           ghc-blaze-markup
-           ghc-mime-types
-           ghc-unordered-containers
-           ghc-zlib
-           ghc-wai-extra
-           ghc-optparse-applicative
-           ghc-warp))
-    (native-inputs
-     (list ghc-hspec ghc-network ghc-temporary ghc-mockery))
-    (arguments
-     `(#:cabal-revision
-       ("1" "1q7zwjasysgbp9rdp75535igd7s6mhi2bnl4pzsn6vbyfw3qnsxd")))
-    (home-page "https://www.yesodweb.com/book/web-application-interface")
+    (inputs (list ghc-wai
+                  ghc-http-types
+                  ghc-unix-compat
+                  ghc-old-locale
+                  ghc-file-embed
+                  ghc-http-date
+                  ghc-blaze-html
+                  ghc-blaze-markup
+                  ghc-mime-types
+                  ghc-unordered-containers
+                  ghc-zlib
+                  ghc-wai-extra
+                  ghc-optparse-applicative
+                  ghc-warp
+                  ghc-cryptonite
+                  ghc-memory))
+    (native-inputs (list ghc-hspec ghc-network ghc-temporary ghc-mockery))
+    (home-page "http://www.yesodweb.com/book/web-application-interface")
     (synopsis "WAI application for static serving")
-    (description "This package provides a Web Application
+    (description
+     "This package provides a Web Application
 Interface (WAI) application for static serving.  It also provides some
 helper functions and datatypes for use outside of WAI.")
     (license license:expat)))
@@ -2067,7 +2026,9 @@ helper functions and datatypes for use outside of WAI.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "hjsmin")))
     (arguments
-     `(#:phases
+     `(#:cabal-revision ("2"
+                         "184g49wsj2sfm8d75kgr7ylfw29gbyrqbqp4syyz30ch047jd0af")
+       #:phases
        (modify-phases %standard-phases
          (add-before 'build 'fix-dist-directory-for-tests
            (lambda _
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index aa8be12a88..69ff954ce4 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -55,6 +55,7 @@
   #:use-module (gnu packages emacs)
   #:use-module (gnu packages freedesktop)
   #:use-module (gnu packages gl)
+  #:use-module (gnu packages glib)
   #:use-module (gnu packages graphviz)
   #:use-module (gnu packages gtk)
   #:use-module (gnu packages haskell)
@@ -73,6 +74,7 @@
   #:use-module (gnu packages sdl)
   #:use-module (gnu packages serialization)
   #:use-module (gnu packages tls)
+  #:use-module (gnu packages version-control)
   #:use-module (gnu packages xml)
   #:use-module (gnu packages xorg)
   #:use-module (guix build-system haskell)
@@ -145,24 +147,25 @@ module for more details.")
 (define-public ghc-active
   (package
     (name "ghc-active")
-    (version "0.2.0.15")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "active" version))
-       (sha256
-        (base32
-         "019xr66pahsssqr2hybs88mga4qshv1vmd22j7624wqafqm57d74"))))
+    (version "0.2.0.16")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "active" version))
+              (sha256
+               (base32
+                "1fz2rsyk41p9f9avlmn9lrdmii5alv88lkw677mw8q6mzyxpw67i"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "active")))
-    (inputs
-     (list ghc-vector ghc-semigroups ghc-semigroupoids ghc-lens
-           ghc-linear))
-    (native-inputs
-     (list ghc-quickcheck))
-    (home-page "https://hackage.haskell.org/package/active")
+    (inputs (list ghc-vector ghc-semigroups ghc-semigroupoids ghc-lens
+                  ghc-linear))
+    (native-inputs (list ghc-quickcheck))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0cyfwrr5c14f5rgrf8dv7i8qsrnmnzigw0xp6l88kfxd61zhk4n8")))
+    (home-page "http://hackage.haskell.org/package/active")
     (synopsis "Abstractions for animation")
-    (description "This package defines an @code{Active} abstraction for
+    (description
+     "This package defines an @code{Active} abstraction for
 time-varying values with finite start and end times.  It is used for
 describing animations within the
 @url{https://archives.haskell.org/projects.haskell.org/diagrams/,
@@ -172,38 +175,33 @@ diagrams framework}.")
 (define-public ghc-adjunctions
   (package
     (name "ghc-adjunctions")
-    (version "4.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "adjunctions" version))
-       (sha256
-        (base32
-         "1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h"))))
+    (version "4.4.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "adjunctions" version))
+              (sha256
+               (base32
+                "06354xzgf78jl4g1xw11rp74gi7zh94rgvsji7ma1g0hp26myyql"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "adjunctions")))
-    (arguments
-     `(#:cabal-revision
-       ("2" "1yfsjx7dqikg3hvld7i91xfsg5lawmr5980lvfd794sybmgxsf17")))
-    (inputs
-     (list ghc-profunctors
-           ghc-comonad
-           ghc-contravariant
-           ghc-distributive
-           ghc-free
-           ghc-tagged
-           ghc-semigroupoids
-           ghc-semigroups
-           ghc-transformers-compat
-           ghc-void))
-    (native-inputs
-     (list ghc-generic-deriving ghc-hspec hspec-discover))
-    (home-page "https://github.com/ekmett/adjunctions/")
+    (inputs (list ghc-comonad
+                  ghc-contravariant
+                  ghc-distributive
+                  ghc-free
+                  ghc-profunctors
+                  ghc-tagged
+                  ghc-semigroupoids
+                  ghc-semigroups
+                  ghc-transformers-compat
+                  ghc-void))
+    (native-inputs (list ghc-generic-deriving ghc-hspec hspec-discover))
+    (home-page "http://github.com/ekmett/adjunctions/")
     (synopsis "Adjunctions and representable functors")
     (description "This library provides adjunctions and representable functors
 for Haskell.")
     (license license:bsd-3)))
 
+;; Deprecated package.
 (define-public ghc-aeson-compat
   (package
     (name "ghc-aeson-compat")
@@ -234,6 +232,9 @@ for Haskell.")
            ghc-quickcheck
            ghc-quickcheck-instances
            ghc-base-orphans))
+    (arguments
+     `(#:cabal-revision ("4"
+                         "001w7pck3q5k4cnx53npllil5cblkg1ssqza4s9v347dfih3zmss")))
     (home-page "https://github.com/phadej/aeson-compat")
     (synopsis "Compatibility layer for ghc-aeson")
     (description "This Haskell package provides compatibility layer for
@@ -243,14 +244,14 @@ ghc-aeson.")
 (define-public ghc-aeson-diff
   (package
     (name "ghc-aeson-diff")
-    (version "1.1.0.9")
+    (version "1.1.0.13")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "aeson-diff" version))
        (sha256
         (base32
-         "18bm4qyjjwgrr6dxc4y0vai0z6qgrh2lcqb4jrr4xqs4cxrlwr92"))))
+         "0sd13q0nj0k1sam5xfj6dcjcki18f375sa69hm6i4xc6snfhn3cb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "aeson-diff")))
     (inputs
@@ -271,7 +272,20 @@ ghc-aeson.")
            ghc-quickcheck
            ghc-doctest
            hlint))
-    (home-page "https://github.com/thsutton/aeson-diff")
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1028adallw7bm72948lj322bb5a99gfs0qc1j0pnm8hryp6n7ma5")
+       #:tests? #f ; Needs doctest Setup.hs
+       #:phases
+       (modify-phases %standard-phases
+         ;; Tries to use non-existent doctest API.
+         (add-after 'unpack 'disable-doctest
+           (lambda _
+             (with-output-to-file "Setup.hs"
+               (lambda _
+                 (display
+                  "import Distribution.Simple\nmain = defaultMain\n"))))))))
+   (home-page "https://github.com/thsutton/aeson-diff")
     (synopsis "Extract and apply patches to JSON documents")
     (description "This is a small library for working with changes to JSON
 documents.  It includes a library and two command-line executables in the
@@ -282,30 +296,17 @@ systems.")
 (define-public ghc-alex
   (package
     (name "ghc-alex")
-    (version "3.2.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "alex" version))
-       (sha256
-        (base32
-         "042lrkn0dbpjn5ivj6j26jzb1fwrj8c1aj18ykxja89isg0hiali"))))
+    (version "3.2.7.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "alex" version))
+              (sha256
+               (base32
+                "1v0vm1l4xvybzwj1p6j5j58yiw5nhbnx7yxjnpyjy6wggsig3llv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "alex")))
-    (arguments
-      (list #:phases
-            #~(modify-phases %standard-phases
-                (add-before 'check 'set-check-variables
-                  (lambda _
-                    (setenv "PATH" (string-append (getcwd) "/dist/build/alex:"
-                                                  (getenv "PATH")))
-                    (setenv "alex_datadir" (string-append (getcwd) "/data")))))))
-    (inputs (list ghc-quickcheck))
-    (native-inputs
-     (list which))
-    (home-page "https://www.haskell.org/alex/")
-    (synopsis
-     "Tool for generating lexical analysers in Haskell")
+    (home-page "http://www.haskell.org/alex/")
+    (synopsis "Tool for generating lexical analysers in Haskell")
     (description
      "Alex is a tool for generating lexical analysers in Haskell.  It takes a
 description of tokens based on regular expressions and generates a Haskell
@@ -386,21 +387,20 @@ a variety of ways.")
 (define-public ghc-ansi-terminal
   (package
     (name "ghc-ansi-terminal")
-    (version "0.11")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ansi-terminal" version))
-       (sha256
-        (base32
-         "14rp62c7y79n9dmmi7m0l9n3mcq6dh331b4yyyrivm5da6g1nqf6"))))
+    (version "0.11.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ansi-terminal" version))
+              (sha256
+               (base32
+                "098f8bdxqmgxaz8y87s6b6bshsq950zq0b75rmbihp2k1a7y963q"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ansi-terminal")))
-    (inputs
-     (list ghc-colour))
-    (home-page "https://github.com/feuerbach/ansi-terminal")
+    (inputs (list ghc-colour))
+    (home-page "https://github.com/UnkindPartition/ansi-terminal")
     (synopsis "ANSI terminal support for Haskell")
-    (description "This package provides ANSI terminal support for Haskell.  It
+    (description
+     "This package provides ANSI terminal support for Haskell.  It
 allows cursor movement, screen clearing, color output showing or hiding the
 cursor, and changing the title.")
     (license license:bsd-3)))
@@ -465,6 +465,9 @@ style.")
     (properties '((upstream-name . "assoc")))
     (inputs
      (list ghc-bifunctors ghc-tagged))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0mrb12dx316q4gxyn68x2rl8jq0gd77zffd12r8j1r41l0xd9f4k")))
     (home-page
      "https://hackage.haskell.org/package/assoc")
     (synopsis
@@ -492,6 +495,9 @@ similar operations (e.g. @code{Either}, @code{These}).")
      (list ghc-hashable))
     (native-inputs
      (list ghc-hunit ghc-test-framework ghc-test-framework-hunit))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1j93w1krkadqijn59yjiws1366yhcn2mad1irqrk50in6l10k51b")))
     (home-page "https://github.com/simonmar/async")
     (synopsis "Library to run IO operations asynchronously")
     (description "Async provides a library to run IO operations
@@ -525,17 +531,14 @@ This library provides a safer method based on the concept of @code{Ticket}s.")
 (define-public ghc-atomic-write
   (package
     (name "ghc-atomic-write")
-    (version "0.2.0.6")
+    (version "0.2.0.7")
     (source
      (origin
        (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/atomic-write/atomic-write-"
-             version
-             ".tar.gz"))
+       (uri (hackage-uri "atomic-write" version))
        (sha256
         (base32
-         "1xs3shwnlj8hmnm3q6jc8nv78z0481i5n4hrqqdmbpx8grvlnqyl"))))
+         "03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm"))))
     (build-system haskell-build-system)
     (properties `((upstream-name . "atomic-write")))
     (inputs
@@ -552,52 +555,28 @@ will destroy the permissions on the original file.  This library preserves
 permissions while atomically writing to a file.")
     (license license:expat)))
 
-(define-public ghc-atomic-write-0.2.0.7
-  (package
-    (inherit ghc-atomic-write)
-    (version "0.2.0.7")
-    (source
-     (origin
-       (inherit (package-source ghc-atomic-write))
-       (uri (hackage-uri "atomic-write" version))
-       (sha256
-        (base32
-         "03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm"))))))
-
 (define-public ghc-attoparsec
   (package
     (name "ghc-attoparsec")
-    (version "0.13.2.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "attoparsec" version))
-       (sha256
-        (base32
-         "0vv88m5m7ynjrg114psp4j4s69f1a5va3bvn293vymqrma7g7q11"))))
+    (version "0.14.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "attoparsec" version))
+              (sha256
+               (base32
+                "0v4yjz4qi8bwhbyavqxlhsfb1iv07v10gxi64khmsmi4hvjpycrz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "attoparsec")))
+    (inputs (list ghc-scientific))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck-unicode ghc-tasty
+                         ghc-tasty-quickcheck ghc-vector))
     (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'patch-for-newer-quickcheck
-           (lambda _
-             (substitute* "attoparsec.cabal"
-               (("QuickCheck >= 2\\.7 && < 2\\.10")
-                "QuickCheck >= 2.7 && < 2.12"))
-             ;; This test fails because of the newer QuickCheck:
-             ;; <https://github.com/bos/attoparsec/issues/134>.
-             (substitute* "tests/QC/ByteString.hs"
-               ((", testProperty \"satisfyWith\" satisfyWith")
-                "")))))))
-    (inputs
-     (list ghc-scientific))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck
-           ghc-quickcheck-unicode ghc-vector))
-    (home-page "https://github.com/bos/attoparsec")
+     `(#:cabal-revision ("2"
+                         "00jyrn2asz1kp698l3fyh19xxxz4npf1993y041x9b9cq239smn0")))
+    (home-page "https://github.com/bgamari/attoparsec")
     (synopsis "Fast combinator parsing for bytestrings and text")
-    (description "This library provides a fast parser combinator library,
+    (description
+     "This library provides a fast parser combinator library,
 aimed particularly at dealing efficiently with network protocols and
 complicated text/binary file formats.")
     (license license:bsd-3)))
@@ -615,21 +594,17 @@ complicated text/binary file formats.")
 (define-public ghc-attoparsec-iso8601
   (package
     (name "ghc-attoparsec-iso8601")
-    (version "1.0.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "attoparsec-iso8601" version))
-       (sha256
-        (base32
-         "162gc101mwhmjbfhhv1wm3yvk2h4ra34wpw5x87735cfqxvjv582"))))
+    (version "1.0.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "attoparsec-iso8601" version))
+              (sha256
+               (base32
+                "1zmj6v63xjj20ja50ffbi222yg513cnnqyxl76ybb4x98z9jld0k"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "attoparsec-iso8601")))
-    (arguments
-     `(#:cabal-revision
-       ("2" "18557xy5gvkhj0sb35wwxmhqirkiqrkwm0y0pqygsr0aimccs5zm")))
     (inputs (list ghc-attoparsec ghc-base-compat-batteries ghc-time-compat))
-    (home-page "https://github.com/bos/aeson")
+    (home-page "https://github.com/haskell/aeson")
     (synopsis "Parse ISO 8601 dates")
     (description "Haskell library for parsing of ISO 8601 dates, originally
 from aeson.")
@@ -659,27 +634,18 @@ periodic, on-demand actions in Haskell.")
 (define-public ghc-aws
   (package
     (name "ghc-aws")
-    (version "0.22")
+    (version "0.23")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "aws" version))
        (sha256 (base32
-                "1l3f94mpih7slz37ikyjkyrwvlf110w87997d8sbnbd8glwlcb8r"))))
+                "0kfdj9hxjvziq1y74xj9mm17zcgwywpvp9c0i6gfd5malf4qxgg0"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "aws")))
     (arguments
      `(#:tests? #f ; Tests require AWS credentials.
-       #:configure-flags (list "-fNetworkBSD") ; Use network-bsd.
-       #:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "aws.cabal"
-               (("(base16-bytestring)\\s+==\\s+0\\.1\\.\\*" all dep)
-                dep)
-               (("(base64-bytestring)\\s+==\\s+1\\.0\\.\\*" all dep)
-                dep)))))))
+       #:configure-flags (list "-fNetworkBSD"))) ; Use network-bsd.
     (inputs
      (list ghc-aeson
            ghc-attoparsec
@@ -728,20 +694,19 @@ Web Services.")
 (define-public ghc-base16-bytestring
   (package
     (name "ghc-base16-bytestring")
-    (version "1.0.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "base16-bytestring" version))
-       (sha256
-        (base32
-         "1ynnplw8iz3v5ld0xxgpxgasb0hg62x62wxxf5lx6lxyb15hmiy0"))))
+    (version "1.0.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base16-bytestring" version))
+              (sha256
+               (base32
+                "1167f9jaivnabn6kg2gc421ac9njb67fr4v0adbj3qph7qa92nhx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "base16-bytestring")))
-    (native-inputs
-     (list ghc-hunit ghc-quickcheck ghc-test-framework
-           ghc-test-framework-hunit ghc-test-framework-quickcheck2))
-    (home-page "https://github.com/bos/base16-bytestring")
+    (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (home-page "http://github.com/haskell/base16-bytestring")
     (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings")
     (description
      "This package provides a Haskell library for working with base16-encoded
@@ -751,17 +716,19 @@ data quickly and efficiently, using the ByteString type.")
 (define-public ghc-base64-bytestring
   (package
     (name "ghc-base64-bytestring")
-    (version "1.1.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "base64-bytestring" version))
-       (sha256
-        (base32 "1adcnkcx4nh3d59k94bkndj0wkgbvchz576qwlpaa7148a86q391"))))
+    (version "1.2.1.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base64-bytestring" version))
+              (sha256
+               (base32
+                "1ja9vkgnpkzaw8gz6sm5jmgha6wg3m1j281m0nv1w9yyxlqfvy7v"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "base64-bytestring")))
-    (arguments `(#:tests? #f))         ; FIXME: testing libraries are missing.
-    (home-page "https://github.com/bos/base64-bytestring")
+    (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (home-page "https://github.com/haskell/base64-bytestring")
     (synopsis "Base64 encoding and decoding for ByteStrings")
     (description "This library provides fast base64 encoding and decoding for
 Haskell @code{ByteString}s.")
@@ -770,46 +737,41 @@ Haskell @code{ByteString}s.")
 (define-public ghc-base-compat
   (package
     (name "ghc-base-compat")
-    (version "0.11.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "base-compat" version))
-       (sha256
-        (base32
-         "1nyvkaij4m01jndw72xl8931czz1xp6jpnynpajabys2ahabb9jk"))))
+    (version "0.12.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base-compat" version))
+              (sha256
+               (base32
+                "1gah466nd6hkj716gwljfh0g270iaqy2rq2a1vw3di2s7a4dqam6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "base-compat")))
-    (outputs '("out" "static" "doc"))
-    (native-inputs
-     (list ghc-quickcheck ghc-hspec hspec-discover))
-    (home-page "https://hackage.haskell.org/package/base-compat")
+    (home-page "http://hackage.haskell.org/package/base-compat")
     (synopsis "Haskell compiler compatibility library")
-    (description "This library provides functions available in later versions
+    (description
+     "This library provides functions available in later versions
 of base to a wider range of compilers, without requiring the use of CPP
 pragmas in your code.")
-    (license license:bsd-3)))
+    (license license:expat)))
 
 (define-public ghc-base-compat-batteries
   (package
     (name "ghc-base-compat-batteries")
-    (version "0.11.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "base-compat-batteries" version))
-       (sha256
-        (base32
-         "08rh9nlm9ir28fm42xim06ga8qwdqdcvkbb5ckz99bwnmajndq1i"))))
+    (version "0.12.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base-compat-batteries" version))
+              (sha256
+               (base32
+                "16gbqng8556wqcvrmj3dmqxh9sxp7z6ixgv0j5sy017r0wp0ksgd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "base-compat-batteries")))
-    (inputs
-     (list ghc-base-compat))
-    (native-inputs
-     (list ghc-hspec ghc-quickcheck hspec-discover))
-    (home-page "https://hackage.haskell.org/package/base-compat-batteries")
+    (inputs (list ghc-base-compat))
+    (native-inputs (list ghc-hspec ghc-quickcheck hspec-discover))
+    (home-page "http://hackage.haskell.org/package/base-compat-batteries")
     (synopsis "base-compat with extra batteries")
-    (description "This library provides functions available in later
+    (description
+     "This library provides functions available in later
 versions of @code{base} to a wider range of compilers, without requiring
 you to use CPP pragmas in your code.  This package provides the same API
 as the @code{base-compat} library, but depends on compatibility
@@ -820,18 +782,16 @@ than @code{base-compat}, which has no dependencies.")
 (define-public ghc-basement
   (package
     (name "ghc-basement")
-    (version "0.0.12")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "basement" version))
-       (sha256
-        (base32
-         "12zsnxkgv86im2prslk6ddhy0zwpawwjc1h4ff63kpxp2xdl7i2k"))))
+    (version "0.0.15")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "basement" version))
+              (sha256
+               (base32
+                "1d2xj5dmjps7nc7rwp5s0kyjcg9v8xfql6ik4yk1d3affnvazhjn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "basement")))
-    (outputs '("out" "static" "doc"))
-    (home-page "https://github.com/haskell-foundation/foundation")
+    (home-page "https://github.com/haskell-foundation/foundation#readme")
     (synopsis "Basic primitives for Foundation starter pack")
     (description
      "This package contains basic primitives for the Foundation set of
@@ -841,42 +801,48 @@ packages.")
 (define-public ghc-base-orphans
   (package
     (name "ghc-base-orphans")
-    (version "0.8.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "base-orphans" version))
-       (sha256
-        (base32
-         "1lw1jhrrsdq7x9wr2bwkxq9mscidcad0n30kh9gfk8kgifl5xh9k"))))
+    (version "0.8.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base-orphans" version))
+              (sha256
+               (base32
+                "0iz4v4h2ydncdwfqzs8fd2qwl38dx0n94w5iymw2g4xy1mzxd3w8"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "base-orphans")))
-    (native-inputs
-     (list ghc-quickcheck ghc-hspec hspec-discover))
-    (home-page "https://hackage.haskell.org/package/base-orphans")
+    (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover))
+    (home-page "https://github.com/haskell-compat/base-orphans#readme")
     (synopsis "Orphan instances for backwards compatibility")
-    (description "This package defines orphan instances that mimic instances
+    (description
+     "This package defines orphan instances that mimic instances
 available in later versions of base to a wider (older) range of compilers.")
-    (license license:bsd-3)))
+    (license license:expat)))
+
+(define-public ghc-base-orphans-bootstrap
+  (package
+    (inherit ghc-base-orphans)
+    (name "ghc-base-orphans-bootstrap")
+    (arguments '(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
 
 (define-public ghc-base-prelude
   (package
     (name "ghc-base-prelude")
-    (version "1.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "base-prelude" version))
-       (sha256
-        (base32
-         "0nn5v2y9kl7i3n21250m7cvn55lvkmzj22wx6q4kaag5ycwwczrs"))))
+    (version "1.6.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base-prelude" version))
+              (sha256
+               (base32
+                "0rbx6k85svqrkw5ixp2xal8bg6xrz729g7rrhkgsr3ixv38k943j"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "base-prelude")))
-    (outputs '("out" "static" "doc"))
     (home-page "https://github.com/nikita-volkov/base-prelude")
     (synopsis "The most complete prelude formed solely from the Haskell's base
 package")
-    (description "This Haskell package aims to reexport all the non-conflicting
+    (description
+     "This Haskell package aims to reexport all the non-conflicting
 and most general definitions from the \"base\" package.
 
 This includes APIs for applicatives, arrows, monoids, foldables, traversables,
@@ -980,26 +946,18 @@ storing and transmitting loosely structured data.")
 (define-public ghc-bifunctors
   (package
     (name "ghc-bifunctors")
-    (version "5.5.11")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "bifunctors" version))
-       (sha256
-        (base32
-         "070964w7gz578379lyj6xvdbcf367csmz22cryarjr5bz9r9csrb"))))
+    (version "5.5.14")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "bifunctors" version))
+              (sha256
+               (base32
+                "0r4jd4s66xvnx0bk75rz0cwnf6cr0lgx3dxrqdv3ppkwqk81c0ak"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "bifunctors")))
-    (inputs
-     (list ghc-base-orphans
-           ghc-comonad
-           ghc-th-abstraction
-           ghc-transformers-compat
-           ghc-tagged
-           ghc-semigroups))
-    (native-inputs
-     (list ghc-hspec hspec-discover ghc-quickcheck))
-    (home-page "https://github.com/ekmett/bifunctors/")
+    (inputs (list ghc-base-orphans ghc-comonad ghc-th-abstraction ghc-tagged))
+    (native-inputs (list ghc-hspec ghc-quickcheck ghc-transformers-compat hspec-discover))
+    (home-page "http://github.com/ekmett/bifunctors/")
     (synopsis "Bifunctors for Haskell")
     (description "This package provides bifunctors for Haskell.")
     (license license:bsd-3)))
@@ -1094,19 +1052,14 @@ interoperate with code that uses the new implementation.")
          "0jd30wg5yz0a97b36zwqg4hv8faifza1n2gys3l1p3fwf9l3zz23"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "blaze-markup")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "blaze-markup.cabal"
-               (("tasty            >= 1\\.0  && < 1\\.1")
-                "tasty            >= 1.0  && < 1.2")))))))
     (inputs
      (list ghc-blaze-builder))
     (native-inputs
      (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit
            ghc-tasty-quickcheck))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "1hn694kk615prqdn7bfzl0wvbw8bksxk4cxwmx8yhwpl0cq3fiwa")))
     (home-page "https://jaspervdj.be/blaze")
     (synopsis "Fast markup combinator library for Haskell")
     (description "This library provides core modules of a markup combinator
@@ -1123,12 +1076,23 @@ library for Haskell.")
        (uri (hackage-uri "bloomfilter" version))
        (sha256
         (base32
-         "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc"))))
+         "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc"))
+       (patches (search-patches "ghc-bloomfilter-ghc9.2.patch"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "bloomfilter")))
     (native-inputs
      (list ghc-quickcheck ghc-random ghc-test-framework
            ghc-test-framework-quickcheck2))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1hi6hwvhv7lxqv0l6hv2854g1rvc52zcmr3ldvnaan1l1b666867")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "bloomfilter.cabal"
+               (("\\b(base)\\s+[^,]+" all dep)
+                dep)))))))
     (home-page "https://github.com/bos/bloomfilter")
     (synopsis "Pure and impure Bloom filter implementations")
     (description "This package provides both mutable and immutable Bloom
@@ -1201,32 +1165,33 @@ system.")
 
 (define-public ghc-bytes
   (package
-   (name "ghc-bytes")
-   (version "0.17.1")
-   (source
-    (origin
-     (method url-fetch)
-     (uri
-      (hackage-uri "bytes" version))
-     (file-name (string-append name "-" version ".tar.gz"))
-     (sha256
-      (base32
-       "1qmps8vvg98wfm9xm734hwzi56bsk8r1zc6vx20rlhc79krv5s9s"))))
-   (build-system haskell-build-system)
-   (properties '((upstream-name . "bytes")))
-   (inputs (list ghc-binary-orphans
-                 ghc-cereal
-                 ghc-hashable
-                 ghc-scientific
-                 ghc-transformers-compat
-                 ghc-unordered-containers
-                 ghc-void))
-   (synopsis "Serialization between @code{binary} and @code{cereal}")
-   (description "This package provides a simple compatibility shim that lets
+    (name "ghc-bytes")
+    (version "0.17.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "bytes" version))
+              (sha256
+               (base32
+                "06kqqk19qjhrwdqi6pyd1lwqfnj2sw3b3s49lc5vr2fmv8gg8mdw"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "bytes")))
+    (inputs (list ghc-binary-orphans
+                  ghc-cereal
+                  ghc-hashable
+                  ghc-transformers-compat
+                  ghc-unordered-containers
+                  ghc-scientific
+                  ghc-void))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0frs6ag93kmg2fw3vd686czx8g7h9qmdn1ip6wdk96d94ap0fz9i")))
+    (home-page "https://github.com/ekmett/bytes")
+    (synopsis "Serialization between @code{binary} and @code{cereal}")
+    (description
+     "This package provides a simple compatibility shim that lets
 you work with both @code{binary} and @code{cereal} with one chunk of
 serialization code.")
-   (home-page "https://hackage.haskell.org/package/bytes")
-   (license license:bsd-3)))
+    (license license:bsd-3)))
 
 (define-public ghc-bytestring-builder
   (package
@@ -1249,6 +1214,7 @@ debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
 Compatibility package for older packages.")
     (license license:bsd-3)))
 
+;; XXX: Incompatible with base
 (define-public ghc-bytestring-handle
   (package
     (name "ghc-bytestring-handle")
@@ -1259,12 +1225,19 @@ Compatibility package for older packages.")
        (uri (hackage-uri "bytestring-handle" version))
        (sha256
         (base32
-         "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y"))))
+         "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y"))
+       (patches (search-patches "ghc-bytestring-handle-ghc9.patch"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "bytestring-handle")))
     (arguments
      `(#:cabal-revision
-       ("2" "1x1sy3dz2ph9v6jk22wmcv5gk2bka5fv4s68i8q0j9m9pk085w37")))
+       ("2" "1x1sy3dz2ph9v6jk22wmcv5gk2bka5fv4s68i8q0j9m9pk085w37")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "bytestring-handle.cabal"
+               (("base >= 4\\.2 && < 4\\.15") "base")))))))
     (inputs
      (list ghc-hunit ghc-quickcheck ghc-test-framework
            ghc-test-framework-hunit ghc-test-framework-quickcheck2))
@@ -1276,24 +1249,22 @@ Compatibility package for older packages.")
 (define-public ghc-bytestring-lexing
   (package
     (name "ghc-bytestring-lexing")
-    (version "0.5.0.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "bytestring-lexing" version))
-       (sha256
-        (base32
-         "1p7i2haix4m11an3djaq65cnd293hzwqy4cd2i8jxzcl248pk6iy"))))
+    (version "0.5.0.9")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "bytestring-lexing" version))
+              (sha256
+               (base32
+                "14nx7sfs75g57mlfiwgzm5sc3wm4va58zryjp27m5lmfdp30873c"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "bytestring-lexing")))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-smallcheck))
-    (home-page "http://code.haskell.org/~wren/")
+    (native-inputs (list ghc-tasty ghc-tasty-smallcheck ghc-tasty-quickcheck))
+    (home-page "https://wrengr.org/software/hackage.html")
     (synopsis "Parse and produce literals from strict or lazy bytestrings")
     (description
      "This package provides tools to parse and produce literals efficiently
 from strict or lazy bytestrings.")
-    (license license:bsd-2)))
+    (license license:bsd-3)))
 
 (define-public ghc-bzlib-conduit
   (package
@@ -1339,7 +1310,9 @@ streaming compression and decompression.")
      (list ghc-test-framework ghc-test-framework-hunit ghc-hunit
            ghc-shelly))
     (arguments
-     `(#:phases
+     `(#:cabal-revision
+       ("1" "0hbv1j9b04gm617c5xqndr4iqidabwdpcn2dcrnaacc04ylchvl2")
+       #:phases
        (modify-phases %standard-phases
          ;; The tarball on Hackage does not ship these tests. See
          ;; https://github.com/haskell/c2hs/issues/269
@@ -1378,20 +1351,19 @@ imported with the correct Haskell types.")
 (define-public ghc-cairo
   (package
     (name "ghc-cairo")
-    (version "0.13.8.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cairo" version))
-       (sha256
-        (base32
-         "1hpkyhrlg1d24s34kq6d379z8l8fvznm98wpq37haqjma4nl25hk"))))
+    (version "0.13.8.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cairo" version))
+              (sha256
+               (base32
+                "1sq2imy359vnbny610n7655a4z5a8fgdxanys4f5nw84246hc2yl"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cairo")))
-    (inputs
-     (list ghc-utf8-string cairo))
-    (native-inputs
-     (list ghc-gtk2hs-buildtools pkg-config))
+    (inputs (list ghc-utf8-string cairo))
+    (native-inputs (list ghc-gtk2hs-buildtools pkg-config))
+    (arguments
+     `(#:extra-directories ("cairo")))
     (home-page "https://projects.haskell.org/gtk2hs/")
     (synopsis "Haskell bindings to the Cairo vector graphics library")
     (description
@@ -1403,17 +1375,17 @@ documents, amongst others.")
 (define-public ghc-call-stack
   (package
     (name "ghc-call-stack")
-    (version "0.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "call-stack" version))
-       (sha256
-        (base32
-         "0ski7ihdxah7x4x07qgkjljg8hzqs9d6aa5k4cmr40bzp3i8s3mq"))))
+    (version "0.4.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "call-stack" version))
+              (sha256
+               (base32
+                "0yxq6v37kcmgv6rrna4g1ipr8mhkgf00ng2p359ybxq46j5cy2s3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "call-stack")))
-    (native-inputs (list ghc-nanospec))
+    ;(arguments (list #:tests? #f))
+    (native-inputs (list ghc-nanospec-bootstrap))
     (home-page "https://github.com/sol/call-stack#readme")
     (synopsis "Use GHC call-stacks in a backward compatible way")
     (description "This package provides a compatibility layer for using GHC
@@ -1461,37 +1433,29 @@ the resulting type will be insensitive to cases.")
 (define-public ghc-cassava
   (package
     (name "ghc-cassava")
-    (version "0.5.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cassava" version))
-       (sha256
-        (base32
-         "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk"))))
+    (version "0.5.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cassava" version))
+              (sha256
+               (base32
+                "1gp954w05bj83z4i6isq2qxi1flqwppsgxxrp1f75mrs8cglbj5l"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cassava")))
-    (inputs
-     (list ghc-attoparsec
-           ghc-hashable
-           ghc-scientific
-           ghc-unordered-containers
-           ghc-vector
-           ghc-only
-           ghc-text-short
-           ghc-bytestring-builder))
-    (native-inputs
-     (list ghc-hunit
-           ghc-quickcheck
-           ghc-quickcheck-instances
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2))
-    (arguments
-     `(#:cabal-revision
-       ("4"
-        "19rkq41r5vj8drnj850b1wqnc54mxpw0x5z54brq0nvyww5f8ai8")
-       #:configure-flags '("--flags=-bytestring--lt-0_10_4")))
+    (inputs (list ghc-attoparsec
+                  ghc-hashable
+                  ghc-scientific
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-only
+                  ghc-bytestring-builder
+                  ghc-nats))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
     (home-page "https://github.com/haskell-hvr/cassava")
     (synopsis "CSV parsing and encoding library")
     (description
@@ -1532,7 +1496,9 @@ very simple example of encoding CSV data:
 
 @verbatim
 >>> Data.Csv.encode [(\"John\",27),(\"Jane\",28)]
-\"John,27\r\nJane,28\r\n\"
+\"John,27

+Jane,28

+\"
 @end verbatim
 ")
     (license license:bsd-3)))
@@ -1564,29 +1530,30 @@ provides for better error messages at the expense of some speed.")
 (define-public ghc-cborg
   (package
     (name "ghc-cborg")
-    (version "0.2.5.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cborg" version))
-       (sha256
-        (base32
-         "08da498bpbnl5c919m45mjm7sr78nn6qs7xyl0smfgd06wwm65xf"))))
+    (version "0.2.8.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cborg" version))
+              (sha256
+               (base32
+                "07mh5bk61k5dz2x5g7fqw2cv7bjzs7v65yxvzkq7mdbkq8kwhn9f"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cborg")))
-    (inputs
-     (list ghc-half ghc-primitive))
-    (native-inputs
-     (list ghc-aeson
-           ghc-base64-bytestring
-           ghc-base16-bytestring
-           ghc-fail
-           ghc-quickcheck
-           ghc-scientific
-           ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck
-           ghc-vector))
+    (inputs (list ghc-half ghc-primitive))
+    (native-inputs (list ghc-base-orphans
+                         ghc-aeson
+                         ghc-base64-bytestring
+                         ghc-base16-bytestring
+                         ghc-quickcheck
+                         ghc-random
+                         ghc-scientific
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-vector))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "13m2shrlpvg5s9d40a2463mmckzg50y8jb47zfd6i1rg6q3q6xx6")))
     (home-page "https://hackage.haskell.org/package/cborg")
     (synopsis "Concise Binary Object Representation")
     (description
@@ -1609,51 +1576,48 @@ command-line utility for working with CBOR data.")
 (define-public ghc-cborg-json
   (package
     (name "ghc-cborg-json")
-    (version "0.2.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cborg-json" version))
-       (sha256
-        (base32 "0ysilz7rrjk94sqr3a61s98hr9qfi1xg13bskmlpc6mpgi2s4s5b"))))
+    (version "0.2.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cborg-json" version))
+              (sha256
+               (base32
+                "1m3w0yyp6xb07fx04g5c52pb0b46vpkgpi32w1c8bz867x2p7hsq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cborg-json")))
+    (inputs (list ghc-aeson
+                  ghc-aeson-pretty
+                  ghc-unordered-containers
+                  ghc-scientific
+                  ghc-vector
+                  ghc-cborg))
     (arguments
-     `(#:cabal-revision
-       ("3" "1sn2f9nfjcbr0n62n4kklbdi3pzpwrcy7ilg7m3v41nwrk53ifwy")))
-    (inputs
-     (list ghc-aeson
-           ghc-aeson-pretty
-           ghc-unordered-containers
-           ghc-scientific
-           ghc-vector
-           ghc-cborg))
+     `(#:cabal-revision ("1"
+                         "0zzn2p6yl9mqw7agm5w7iiz105078gv66vxr8bqazilgssqk5wyg")))
     (home-page "https://github.com/well-typed/cborg")
     (synopsis "Library for encoding JSON as CBOR")
-    (description
-     "This package implements the bijection between JSON and CBOR
+    (description "This package implements the bijection between JSON and CBOR
 defined in the CBOR specification, RFC 7049.")
     (license license:bsd-3)))
 
 (define-public ghc-cereal
   (package
     (name "ghc-cereal")
-    (version "0.5.8.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cereal" version))
-       (sha256
-        (base32
-         "1mqvd1iwzr50az4y24332x3g3wsrzw8j1iwph02vr7jbjfn8i7id"))))
+    (version "0.5.8.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cereal" version))
+              (sha256
+               (base32
+                "0shg3q933cvf18j1gmxill48d4sl4mvxj2qkj6yya9hvcqh5544r"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cereal")))
-    (native-inputs
-     (list ghc-quickcheck ghc-fail ghc-test-framework
-           ghc-test-framework-quickcheck2))
-    (home-page "https://hackage.haskell.org/package/cereal")
+    (native-inputs (list ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-quickcheck2))
+    (home-page "https://github.com/GaloisInc/cereal")
     (synopsis "Binary serialization library")
-    (description "This package provides a binary serialization library,
+    (description
+     "This package provides a binary serialization library,
 similar to @code{binary}, that introduces an @code{isolate} primitive for
 parser isolation, and labeled blocks for better error messages.")
     (license license:bsd-3)))
@@ -1682,6 +1646,7 @@ parser isolation, and labeled blocks for better error messages.")
 @code{Sources}, @code{Sinks}, and @code{Conduits}.")
     (license license:bsd-3)))
 
+;; XXX: bytestring <0.11, time >=1.5 && <1.10
 (define-public ghc-cgi
   (package
     (name "ghc-cgi")
@@ -1699,6 +1664,14 @@ parser isolation, and labeled blocks for better error messages.")
      (list ghc-exceptions ghc-multipart ghc-network-uri ghc-network))
     (native-inputs
      (list ghc-doctest ghc-quickcheck))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "cgi.cabal"
+               (("\\b(bytestring|time)\\s+[^,]+" all dep)
+                dep)))))))
     (home-page
      "https://github.com/cheecheeo/haskell-cgi")
     (synopsis "Library for writing CGI programs")
@@ -1709,19 +1682,17 @@ parser isolation, and labeled blocks for better error messages.")
 (define-public ghc-charset
   (package
     (name "ghc-charset")
-    (version "0.3.8")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "charset" version))
-       (sha256
-        (base32
-         "1rw6y2insgljbi5l1nwqwv9v865sswjly9rvwipd8zajkgks7aks"))))
+    (version "0.3.9")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "charset" version))
+              (sha256
+               (base32
+                "12wrphd5j1asb3n6awbph4n695mfmnzk6yzggrp387hx960qfkyb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "charset")))
-    (inputs
-     (list ghc-semigroups ghc-unordered-containers))
-    (home-page "https://github.com/ekmett/charset")
+    (inputs (list ghc-unordered-containers ghc-semigroups))
+    (home-page "http://github.com/ekmett/charset")
     (synopsis "Fast unicode character sets for Haskell")
     (description "This package provides fast unicode character sets for
 Haskell, based on complemented PATRICIA tries.")
@@ -1730,26 +1701,21 @@ Haskell, based on complemented PATRICIA tries.")
 (define-public ghc-chart
   (package
     (name "ghc-chart")
-    (version "1.9.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "Chart" version))
-       (sha256
-        (base32
-         "0p69kq5kh40gd4y8wqabypmw67pqh42vaaw64zv9sf8j075g85ry"))))
+    (version "1.9.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "Chart" version))
+              (sha256
+               (base32
+                "0ylxin419s35xq1j4hcnylrch3m252wqdkfjp5b323qhv4a8y1im"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "Chart")))
-    (arguments
-     `(#:cabal-revision
-       ("2" "04mmsm54mdqcrypvgawhhbwjscmky3j7g5841bc71c0q6d33h2k4")))
-    (inputs
-     (list ghc-old-locale
-           ghc-lens
-           ghc-colour
-           ghc-data-default-class
-           ghc-operational
-           ghc-vector))
+    (inputs (list ghc-old-locale
+                  ghc-lens
+                  ghc-colour
+                  ghc-data-default-class
+                  ghc-operational
+                  ghc-vector))
     (home-page "https://github.com/timbod7/haskell-chart/wiki")
     (synopsis "Library for generating 2D charts and plots")
     (description
@@ -1771,8 +1737,8 @@ backends provided by the @code{Cairo} and @code{Diagrams} libraries.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "Chart-cairo")))
     (arguments
-     `(#:cabal-revision
-       ("2" "0z93znn3dpgj80iiz3a67m90x0j9ljr0jd1ws9jkzj7rk88014gp")))
+     `(#:cabal-revision ("3"
+                         "1d48i6y0lzj066swdb3x56jipxwlx1szwn7j43d50hxmcfjrsgc9")))
     (inputs
      (list ghc-old-locale
            ghc-cairo
@@ -1791,23 +1757,19 @@ backend for the Charts library.")
 (define-public ghc-chasingbottoms
   (package
     (name "ghc-chasingbottoms")
-    (version "1.3.1.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ChasingBottoms" version))
-       (sha256
-        (base32
-         "1flr56hd8ny0ddlv1agi0ikdjv5wgx0aba6xqdsn3nv6dyw9nbf3"))))
+    (version "1.3.1.12")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ChasingBottoms" version))
+              (sha256
+               (base32
+                "1vy9yq07p95qiap1pcp2bbbn1mqvp3spyrswpdz0qfcn06656650"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ChasingBottoms")))
-    (inputs
-     (list ghc-quickcheck ghc-random ghc-syb))
-    (home-page "https://hackage.haskell.org/package/ChasingBottoms")
+    (inputs (list ghc-quickcheck ghc-random ghc-syb))
+    (home-page "http://hackage.haskell.org/package/ChasingBottoms")
     (synopsis "Testing of partial and infinite values in Haskell")
     (description
-     ;; FIXME: There should be a @comma{} in the uref text, but it is not
-     ;; rendered properly.
      "This is a library for testing code involving bottoms or infinite values.
 For the underlying theory and a larger example involving use of QuickCheck,
 see the article
@@ -1954,20 +1916,20 @@ classy-prelude.")
 (define-public ghc-clock
   (package
     (name "ghc-clock")
-    (version "0.8.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "clock" version))
-       (sha256
-        (base32 "0qg4ljwmw28vvxjzr4sknh8220abjcx2b0sq3ljqprh3qw8b2p8b"))))
+    (version "0.8.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "clock" version))
+              (sha256
+               (base32
+                "1l850pf1dxjf3i15wc47d64gzkpzgvw0bq13fd8zvklq9kdyap44"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "clock")))
-    (inputs
-     (list ghc-tasty ghc-tasty-quickcheck))
-    (home-page "https://hackage.haskell.org/package/clock")
+    (native-inputs (list ghc-tasty ghc-tasty-quickcheck))
+    (home-page "https://github.com/corsis/clock")
     (synopsis "High-resolution clock for Haskell")
-    (description "A package for convenient access to high-resolution clock and
+    (description
+     "A package for convenient access to high-resolution clock and
 timer functions of different operating systems via a unified API.")
     (license license:bsd-3)))
 
@@ -2009,21 +1971,18 @@ sources, and does not require prior installation of the C library.")
 (define-public ghc-cmark-gfm
   (package
     (name "ghc-cmark-gfm")
-    (version "0.2.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "cmark-gfm" version))
-       (sha256
-        (base32
-         "1skzdg1icmhn0zrkhbnba4200ymah8sd5msk4qfgawrk77zilw7f"))))
+    (version "0.2.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "cmark-gfm" version))
+              (sha256
+               (base32
+                "0la4sd0cmv3zmn0kygbd77dknyh55h0b0qx5jg883hqnvnhaq721"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "cmark-gfm")))
-    (native-inputs
-     (list ghc-hunit))
+    (native-inputs (list ghc-hunit))
     (home-page "https://github.com/kivikakk/cmark-gfm-hs")
-    (synopsis
-     "Fast, accurate GitHub Flavored Markdown parser and renderer")
+    (synopsis "Fast, accurate GitHub Flavored Markdown parser and renderer")
     (description
      "This package provides Haskell bindings for libcmark-gfm, the reference
 parser for GitHub Flavored Markdown, a fully specified variant of Markdown.
@@ -2189,22 +2148,18 @@ Python.")
 (define-public ghc-concurrent-output
   (package
     (name "ghc-concurrent-output")
-    (version "1.10.12")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "concurrent-output" version))
-       (sha256
-        (base32
-         "081wpag1d5znr0ynrjvkc14xl816m88vz9hgfm3g3sp6ak7s3y47"))))
+    (version "1.10.16")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "concurrent-output" version))
+              (sha256
+               (base32
+                "0l4k0bkq5bddqraf14g3ngyzwff17f3ngg4axlilcl3zf3c4bamh"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "concurrent-output")))
-    (inputs
-     (list ghc-async ghc-exceptions ghc-ansi-terminal ghc-terminal-size))
-    (home-page
-     "https://hackage.haskell.org/package/concurrent-output")
-    (synopsis
-     "Ungarble output from several threads or commands")
+    (inputs (list ghc-async ghc-ansi-terminal ghc-terminal-size))
+    (home-page "http://hackage.haskell.org/package/concurrent-output")
+    (synopsis "Ungarble output from several threads or commands")
     (description
      "Lets multiple threads and external processes concurrently output to the
 console, without it getting all garbled up.
@@ -2254,35 +2209,35 @@ space as enumerator/iteratee and pipes.")
 (define-public ghc-conduit-algorithms
   (package
     (name "ghc-conduit-algorithms")
-    (version "0.0.11.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "conduit-algorithms" version))
-       (sha256
-        (base32
-         "0c1jwz30kkvimx7lb61782yk0kyfamrf5bqc3g1h7g51lk8bbv9i"))))
+    (version "0.0.13.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "conduit-algorithms" version))
+              (sha256
+               (base32
+                "1i5jq66xylcnk3yhv2m6lhyqfdrwr94w8v67jzwlvja15jv7mj9v"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "conduit-algorithms")))
-    (inputs
-     (list ghc-async
-           ghc-bzlib-conduit
-           ghc-conduit
-           ghc-conduit-combinators
-           ghc-conduit-extra
-           ghc-conduit-zstd
-           ghc-exceptions
-           ghc-lzma-conduit
-           ghc-monad-control
-           ghc-pqueue
-           ghc-resourcet
-           ghc-stm-conduit
-           ghc-streaming-commons
-           ghc-unliftio-core
-           ghc-vector))
-    (native-inputs
-     (list ghc-hunit ghc-test-framework ghc-test-framework-hunit
-           ghc-test-framework-th))
+    (inputs (list ghc-async
+                  ghc-bzlib-conduit
+                  ghc-conduit
+                  ghc-conduit-combinators
+                  ghc-conduit-extra
+                  ghc-conduit-zstd
+                  ghc-fingertree
+                  ghc-lzma-conduit
+                  ghc-monad-control
+                  ghc-resourcet
+                  ghc-stm-conduit
+                  ghc-streaming-commons
+                  ghc-unliftio-core
+                  ghc-vector))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-tasty-th))
     (home-page "https://github.com/luispedro/conduit-algorithms#readme")
     (synopsis "Conduit-based algorithms")
     (description
@@ -2328,35 +2283,27 @@ as well as a convenient Conduit module.")
 (define-public ghc-conduit-extra
   (package
     (name "ghc-conduit-extra")
-    (version "1.3.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "conduit-extra" version))
-       (sha256
-        (base32
-         "1n8js1y1rdswvp0bkjmmz19fag19bdxgwsrqz93yc09w43p8sr4a"))))
+    (version "1.3.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "conduit-extra" version))
+              (sha256
+               (base32
+                "0lzip3af77wxf3a3vilfymqhd26gkvabx2fkj22w74nq960c6l49"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "conduit-extra")))
-    (inputs
-     (list ghc-conduit
-           ghc-exceptions
-           ghc-monad-control
-           ghc-transformers-base
-           ghc-typed-process
-           ghc-async
-           ghc-attoparsec
-           ghc-blaze-builder
-           ghc-network
-           ghc-primitive
-           ghc-resourcet
-           ghc-streaming-commons
-           ghc-hspec
-           ghc-bytestring-builder
-           ghc-quickcheck))
-    (native-inputs
-     (list hspec-discover))
-    (home-page "https://github.com/snoyberg/conduit")
+    (inputs (list ghc-conduit
+                  ghc-async
+                  ghc-attoparsec
+                  ghc-network
+                  ghc-primitive
+                  ghc-resourcet
+                  ghc-streaming-commons
+                  ghc-unliftio-core
+                  ghc-typed-process
+                  hspec-discover))
+    (native-inputs (list ghc-hspec ghc-quickcheck ghc-transformers-base))
+    (home-page "http://github.com/snoyberg/conduit")
     (synopsis "Conduit adapters for common libraries")
     (description
      "The @code{conduit} package itself maintains relative small dependencies.
@@ -2395,25 +2342,17 @@ interface}.")
 (define-public ghc-config-ini
   (package
     (name "ghc-config-ini")
-    (version "0.2.4.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "config-ini" version))
-       (sha256
-        (base32 "0dfm4xb1sd713rcqzplzdgw68fyhj24i6lj8j3q8kldpmkl98lbf"))))
+    (version "0.2.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "config-ini" version))
+              (sha256
+               (base32
+                "07vgpydzd44ayhq9c3q1335vphw384z8baf0wd0mnarr48yfaz3g"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "config-ini")))
-    (arguments
-     ;; XXX The tests fail to compile: “The constructor ‘I1.Ini’ should have 2
-     ;; arguments, but has been given 1”.
-     `(#:tests? #f
-       #:cabal-revision
-       ("2" "0iwraaa0y1b3xdsg760j1wpylkqshky0k2djcg0k4s97lrwqpbcz")))
-    (native-inputs
-     (list ghc-doctest ghc-hedgehog ghc-ini ghc-microlens))
-    (inputs
-     (list ghc-megaparsec ghc-unordered-containers))
+    (inputs (list ghc-unordered-containers ghc-megaparsec))
+    (native-inputs (list ghc-ini ghc-hedgehog ghc-doctest ghc-microlens))
     (home-page "https://github.com/aisamanra/config-ini")
     (synopsis "Monadic Haskell DSL for parsing simple INI configuration files")
     (description
@@ -2496,28 +2435,25 @@ the choice of SSL/TLS, and SOCKS.")
 (define-public ghc-constraints
   (package
     (name "ghc-constraints")
-    (version "0.13")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "constraints" version))
-       (sha256
-        (base32
-         "143558jykvya7y8134dx30g6nh27q5s61nbq369p69igd1aayncj"))))
+    (version "0.13.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "constraints" version))
+              (sha256
+               (base32
+                "0d248szyp70k1qlivsimk0j5vz9hdx1alhismry5v35qyinr91j1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "constraints")))
-    (inputs
-     (list ghc-hashable ghc-semigroups ghc-transformers-compat
-           ghc-type-equality))
-    (native-inputs
-     (list ghc-hspec hspec-discover))
-    (home-page "https://github.com/ekmett/constraints/")
+    (inputs (list ghc-hashable ghc-transformers-compat ghc-type-equality
+                  ghc-semigroups-bootstrap))
+    (native-inputs (list ghc-hspec hspec-discover))
+    (home-page "http://github.com/ekmett/constraints/")
     (synopsis "Constraint manipulation")
     (description
      "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
 They stopped crashing the compiler in GHC 7.6.  This package provides
 a vocabulary for working with them.")
-    (license license:bsd-3)))
+    (license license:bsd-2)))
 
 (define-public ghc-contravariant
   (package
@@ -2543,18 +2479,16 @@ a vocabulary for working with them.")
 (define-public ghc-contravariant-extras
   (package
     (name "ghc-contravariant-extras")
-    (version "0.3.5.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "contravariant-extras" version))
-       (sha256
-        (base32
-         "0ikwzg0992j870yp0x2ssf4mv2hw2nml979apg493m72xnvr1jz9"))))
+    (version "0.3.5.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "contravariant-extras" version))
+              (sha256
+               (base32
+                "0r4bnl4gi6zd46h6fjkr33hw37rjxwwr00m08vgbzgkdp853g1ba"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "contravariant-extras")))
-    (inputs
-     (list ghc-contravariant ghc-template-haskell-compat-v0208))
+    (inputs (list ghc-contravariant ghc-template-haskell-compat-v0208))
     (home-page "https://github.com/nikita-volkov/contravariant-extras")
     (synopsis "Extras for the @code{ghc-contravariant} Haskell package")
     (description "This Haskell package provides extras for the
@@ -2591,19 +2525,18 @@ Free Monads, MPC'08}
 (define-public ghc-convertible
   (package
     (name "ghc-convertible")
-    (version "1.1.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "convertible" version))
-       (sha256
-        (base32
-         "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9"))))
+    (version "1.1.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "convertible" version))
+              (sha256
+               (base32
+                "1vwc6h1z88xkw4bq3js8x9x86jnk3amdskyksca77p0kwiqbs7lr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "convertible")))
-    (inputs
-     (list ghc-old-time ghc-old-locale))
-    (home-page "https://hackage.haskell.org/package/convertible")
+    (inputs (list ghc-old-time))
+    (native-inputs (list ghc-quickcheck))
+    (home-page "http://hackage.haskell.org/package/convertible")
     (synopsis "Typeclasses and instances for converting between types")
     (description
      "This package provides a typeclass with a single function that is
@@ -2684,20 +2617,16 @@ Accessor to access state in transformers State monad.")
 (define-public ghc-data-clist
   (package
     (name "ghc-data-clist")
-    (version "0.1.2.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "data-clist" version))
-       (sha256
-        (base32 "1mwfhnmvi3vicyjzl33m6pcipi2v887zazyqxygq258ndd010s9m"))))
+    (version "0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "data-clist" version))
+              (sha256
+               (base32
+                "04mj0d1yp0l27v2my51w9q5zpdrdhp29fdyvmwqgxxp8f6yiwfhw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "data-clist")))
-    (native-inputs
-     (list ghc-quickcheck))
-    (arguments
-     `(#:cabal-revision
-       ("1" "13hg7a3d4ky8b765dl03ryxg28lq8iaqj5ky3j51r0i1i4f2a9hy")))
+    (native-inputs (list ghc-quickcheck))
     (home-page "https://github.com/sw17ch/data-clist")
     (synopsis "Simple, functional, bidirectional circular list type")
     (description
@@ -2845,6 +2774,9 @@ package.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "data-fix")))
     (inputs (list ghc-hashable))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0z77i9y86wlc13396akl8qxq39rwpkhhcs5fadzk47bwn7v1gsmx")))
     (home-page "https://github.com/spell-music/data-fix")
     (synopsis "Fixpoint data types")
     (description
@@ -2898,42 +2830,38 @@ It includes hashing functions for all basic Haskell98 types.")
 (define-public ghc-dbus
   (package
     (name "ghc-dbus")
-    (version "1.2.17")
-    (source
-      (origin
-        (method url-fetch)
-        (uri
-         (hackage-uri "dbus" version))
-        (sha256
-          (base32
-            "0iyfnkxcnm1vl379ry88fqxgn2y8q6ilsvpic6ciassnyv5pcbrv"))))
+    (version "1.2.27")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "dbus" version))
+              (sha256
+               (base32
+                "0lkk9hd78h2ilvi0bj5jqq5q5lwyxzdlknwvckhwyxnlf3y6dz8z"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "dbus")))
-    (inputs
-      (list ghc-cereal
-            ghc-conduit
-            ghc-exceptions
-            ghc-lens
-            ghc-network
-            ghc-random
-            ghc-split
-            ghc-th-lift
-            ghc-vector
-            ghc-xml-conduit
-            ghc-xml-types))
-    (native-inputs
-      (list ghc-extra
-            ghc-quickcheck
-            ghc-resourcet
-            ghc-tasty
-            ghc-tasty-hunit
-            ghc-tasty-quickcheck))
-    ;; FIXME - Some tests try to talk to network.
-    (arguments `(#:tests? #f))
-    (home-page "https://github.com/rblaze/haskell-dbus")
+    (inputs (list ghc-cereal
+                  ghc-conduit
+                  ghc-lens
+                  ghc-network
+                  ghc-random
+                  ghc-split
+                  ghc-th-lift
+                  ghc-vector
+                  ghc-xml-conduit
+                  ghc-xml-types))
+    (native-inputs (list ghc-extra
+                         ghc-quickcheck
+                         ghc-resourcet
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ;; dbus-daemon spawned by testsuite.
+                         dbus))
+    (arguments (list #:tests? #f)) ; Network tests fail to connect.
+    (home-page "https://github.com/rblaze/haskell-dbus#readme")
     (synopsis "Client library for the D-Bus IPC system")
     (description
-      "D-Bus is a simple, message-based protocol for inter-process
+     "D-Bus is a simple, message-based protocol for inter-process
 communication, which allows applications to interact with other parts
 of the machine and the user's session using remote procedure
 calls.   D-Bus is a essential part of the modern Linux desktop, where
@@ -2980,8 +2908,8 @@ value.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "deepseq-generics")))
     (arguments
-     `(#:cabal-revision
-       ("6" "1qwnpdjsrqzn18pjmvv9aqz3l12fbdcimf62wkj33yfh69rx4s42")))
+     `(#:cabal-revision ("8"
+                         "0dcv4kf2g4xyacjpci9kql1gm706lkzhcyz9ks9jkbdvyvs8lf90")))
     (native-inputs
      (list ghc-hunit ghc-test-framework ghc-test-framework-hunit))
     (home-page "https://github.com/hvr/deepseq-generics")
@@ -3020,58 +2948,34 @@ providing an @code{rnf} implementation.")
 related modules split from the statistics library.")
     (license license:bsd-2)))
 
-(define-public ghc-descriptive
-  (package
-    (name "ghc-descriptive")
-    (version "0.9.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "descriptive" version))
-       (sha256
-        (base32
-         "0y5693zm2kvqjilybbmrcv1g6n6x2p6zjgi0k0axjw1sdhh1g237"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "descriptive")))
-    (inputs
-     (list ghc-aeson ghc-bifunctors ghc-scientific ghc-vector))
-    (native-inputs
-     (list ghc-hunit ghc-hspec))
-    (home-page
-     "https://github.com/chrisdone/descriptive")
-    (synopsis
-     "Self-describing consumers/parsers: forms, cmd-line args, JSON, etc.")
-    (description
-     "This package provides datatypes and functions for creating consumers
-and parsers with useful semantics.")
-    (license license:bsd-3)))
-
 (define-public ghc-diagrams-core
   (package
     (name "ghc-diagrams-core")
-    (version "1.5.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "diagrams-core" version))
-       (sha256
-        (base32
-         "0y3smp3hiyfdirdak3j4048cgqv7a5q9p2jb6z8na2llys5mrmdn"))))
+    (version "1.5.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "diagrams-core" version))
+              (sha256
+               (base32
+                "1gv1p5hrxi3hks0nb4l38gdgfq9bh9d86b6dxcyzqxrwxbxk1khn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "diagrams-core")))
-    (inputs
-     (list ghc-unordered-containers
-           ghc-semigroups
-           ghc-monoid-extras
-           ghc-dual-tree
-           ghc-lens
-           ghc-linear
-           ghc-adjunctions
-           ghc-distributive
-           ghc-profunctors))
-    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+    (inputs (list ghc-unordered-containers
+                  ghc-semigroups
+                  ghc-monoid-extras
+                  ghc-dual-tree
+                  ghc-lens
+                  ghc-linear
+                  ghc-adjunctions
+                  ghc-distributive
+                  ghc-profunctors))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1gahbyv00xyr4pcmpq4g95jyh7844fp8z0g9l2ybifv4s73vdrym")))
+    (home-page "https://diagrams.github.io")
     (synopsis "Core libraries for diagrams embedded domain-specific language")
-    (description "This package provides the core modules underlying
+    (description
+     "This package provides the core modules underlying
 diagrams, an embedded domain-specific language for compositional,
 declarative drawing.")
     (license license:bsd-3)))
@@ -3079,49 +2983,46 @@ declarative drawing.")
 (define-public ghc-diagrams-lib
   (package
     (name "ghc-diagrams-lib")
-    (version "1.4.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "diagrams-lib" version))
-       (sha256
-        (base32
-         "09np7kj8si8kcb854f95a0cq392mgbxif8lnazbpfsa1k87d9vzy"))))
+    (version "1.4.5.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "diagrams-lib" version))
+              (sha256
+               (base32
+                "1vx51g9znb4a9bf20pjd9zr98wmh39avk2i06217p0iidcw8whz6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "diagrams-lib")))
-    (inputs
-     (list ghc-semigroups
-           ghc-monoid-extras
-           ghc-dual-tree
-           ghc-diagrams-core
-           ghc-diagrams-solve
-           ghc-active
-           ghc-colour
-           ghc-data-default-class
-           ghc-fingertree
-           ghc-intervals
-           ghc-lens
-           ghc-tagged
-           ghc-optparse-applicative
-           ghc-juicypixels
-           ghc-hashable
-           ghc-linear
-           ghc-adjunctions
-           ghc-distributive
-           ghc-fsnotify
-           ghc-unordered-containers
-           ghc-profunctors
-           ghc-exceptions
-           ghc-cereal))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck
-           ghc-numeric-extras))
+    (inputs (list ghc-semigroups
+                  ghc-monoid-extras
+                  ghc-dual-tree
+                  ghc-diagrams-core
+                  ghc-diagrams-solve
+                  ghc-active
+                  ghc-colour
+                  ghc-data-default-class
+                  ghc-fingertree
+                  ghc-intervals
+                  ghc-lens
+                  ghc-tagged
+                  ghc-optparse-applicative
+                  ghc-juicypixels
+                  ghc-hashable
+                  ghc-linear
+                  ghc-adjunctions
+                  ghc-distributive
+                  ghc-fsnotify
+                  ghc-unordered-containers
+                  ghc-profunctors
+                  ghc-cereal))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck
+                         ghc-quickcheck ghc-numeric-extras))
     (arguments
-     `(#:cabal-revision
-       ("1" "1c7kpnbvxwdcmk5znqyig3l6s986ppj168ck5v72dfbp8cjvwa8i")))
-    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+     `(#:cabal-revision ("1"
+                         "14lxvlxdzkrhdgblgglr5k0rwak0yl4gzawqkfla04mkg6hkh5bb")))
+    (home-page "http://diagrams.github.io")
     (synopsis "Embedded domain-specific language for declarative graphics")
-    (description "Diagrams is a flexible, extensible embedded
+    (description
+     "Diagrams is a flexible, extensible embedded
 domain-specific language (EDSL) for creating graphics of many types.
 Graphics can be created in arbitrary vector spaces and rendered with
 multiple backends.  This package provides a standard library of
@@ -3159,33 +3060,31 @@ and cyclic tridiagonal linear systems.")
 (define-public ghc-diagrams-svg
   (package
     (name "ghc-diagrams-svg")
-    (version "1.4.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "diagrams-svg" version))
-       (sha256
-        (base32
-         "1ysv6cz0fngrndl4wjmw4hrdj2rik5fxa1dkxzwnlgf1xwpvxgk8"))))
+    (version "1.4.3.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "diagrams-svg" version))
+              (sha256
+               (base32
+                "002lgmq78c6rsvds9bgm6m4w8j6qpg260mc52hf97wj6m050l237"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "diagrams-svg")))
-    (inputs
-     (list ghc-base64-bytestring
-           ghc-colour
-           ghc-diagrams-core
-           ghc-diagrams-lib
-           ghc-monoid-extras
-           ghc-svg-builder
-           ghc-juicypixels
-           ghc-split
-           ghc-lens
-           ghc-hashable
-           ghc-optparse-applicative
-           ghc-semigroups))
+    (inputs (list ghc-base64-bytestring
+                  ghc-colour
+                  ghc-diagrams-core
+                  ghc-diagrams-lib
+                  ghc-monoid-extras
+                  ghc-svg-builder
+                  ghc-juicypixels
+                  ghc-split
+                  ghc-lens
+                  ghc-hashable
+                  ghc-optparse-applicative
+                  ghc-semigroups))
     (arguments
-     `(#:cabal-revision
-       ("4" "0irjf0g1barr06fy409r0ld2hypihrhh6n80ig3487xxny6gfzs0")))
-    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+     `(#:cabal-revision ("4"
+                         "026mkj9fz64rdrap25mp8cwdrzwj90h35qg9kkn078fac93aaq10")))
+    (home-page "https://diagrams.github.io/")
     (synopsis "Scalable Vector Grpahics backend for the diagrams framework")
     (description "This package provides a modular backend for rendering
 diagrams created with the diagrams embedded domain-specific
@@ -3217,19 +3116,18 @@ members are shared.")
 (define-public ghc-diff
   (package
     (name "ghc-diff")
-    (version "0.4.0")
+    (version "0.4.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "Diff" version))
               (sha256
                (base32
-                "1is9y5rlqyxacnj6kbi6h9laym5shp699r0hkj5p9d6qi84sr43j"))))
+                "0w166w5jksiqad7xf2ldjl2ykap0xf08byrl92qwp6r1qym4lppx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "Diff")))
-    (native-inputs
-     (list ghc-quickcheck ghc-test-framework
-           ghc-test-framework-quickcheck2))
-    (home-page "https://hub.darcs.net/sterlingclover/Diff")
+    (native-inputs (list ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-quickcheck2))
+    (home-page "http://hackage.haskell.org/package/Diff")
     (synopsis "O(ND) diff algorithm in Haskell")
     (description
      "This package provides an implementation of the standard diff algorithm,
@@ -3272,7 +3170,7 @@ disk space usage.")
      (list ghc-tagged ghc-base-orphans ghc-transformers-compat
            ghc-semigroups ghc-generic-deriving))
     (native-inputs
-     (list cabal-doctest ghc-doctest ghc-hspec hspec-discover))
+     (list ghc-doctest ghc-hspec hspec-discover))
     (home-page "https://github.com/ekmett/distributive/")
     (synopsis "Distributive functors for Haskell")
     (description "This package provides distributive functors for Haskell.
@@ -3304,28 +3202,27 @@ Writer monad), where list append quickly becomes too expensive.")
 (define-public ghc-doctemplates
   (package
     (name "ghc-doctemplates")
-    (version "0.9")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "doctemplates" version))
-       (sha256
-        (base32
-         "048h8ka849h1f0xxwkasjbrrwq03rfz2m7aqg5xc5286kp02w9ns"))))
+    (version "0.10.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "doctemplates" version))
+              (sha256
+               (base32
+                "0as0sc4x4ch5z233dqlb8xqg97xbfbzw2dqsz9rfq8rw10v9yx57"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "doctemplates")))
-    (inputs
-     (list ghc-aeson
-           ghc-doclayout
-           ghc-hsyaml
-           ghc-safe
-           ghc-scientific
-           ghc-text-conversions
-           ghc-unordered-containers
-           ghc-vector))
-    (native-inputs
-     (list ghc-glob ghc-tasty ghc-tasty-golden ghc-tasty-hunit
-           ghc-temporary))
+    (inputs (list ghc-safe
+                  ghc-text-conversions
+                  ghc-aeson
+                  ghc-hsyaml
+                  ghc-doclayout
+                  ghc-vector
+                  ghc-scientific))
+    (native-inputs (list ghc-glob ghc-tasty ghc-tasty-golden ghc-tasty-hunit
+                         ghc-temporary))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "17r6ig72bzqd59p11sjaf9y27pm4yig1a1s1igs57s88cy47qz05")))
     (home-page "https://github.com/jgm/doctemplates#readme")
     (synopsis "Pandoc-style document templates")
     (description
@@ -3335,31 +3232,29 @@ Writer monad), where list append quickly becomes too expensive.")
 (define-public ghc-doctest
   (package
     (name "ghc-doctest")
-    (version "0.17")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "doctest" version))
-       (sha256
-        (base32
-         "0f0knggq6yjcznyri35fll619q5jr8vcsbiyvdiz4prkawhaa4pz"))))
+    (version "0.20.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "doctest" version))
+              (sha256
+               (base32
+                "00jbpqvcqxx1nmf41li947d9d3ifwchzzp37mlag68hgnza6z9a4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "doctest")))
-    (arguments `(#:tests? #f))          ; FIXME: missing test framework
-    (inputs
-     (list ghc-base-compat ghc-code-page ghc-paths ghc-syb))
-    (native-inputs
-     (list ghc-hunit
-           ghc-quickcheck
-           ghc-hspec
-           ghc-mockery
-           ghc-setenv
-           ghc-silently
-           ghc-stringbuilder))
-    (home-page
-     "https://github.com/sol/doctest#readme")
+    (inputs (list ghc-base-compat ghc-code-page ghc-paths ghc-syb))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-hspec
+                         ghc-hspec-core
+                         ghc-mockery
+                         ghc-setenv
+                         ghc-silently
+                         ghc-stringbuilder
+                         hspec-discover))
+    (home-page "https://github.com/sol/doctest#readme")
     (synopsis "Test interactive Haskell examples")
-    (description "The doctest program checks examples in source code comments.
+    (description
+     "The doctest program checks examples in source code comments.
 It is modeled after doctest for Python, see
 @uref{https://docs.python.org/library/doctest.html, the Doctest website}.")
     (license license:expat)))
@@ -3389,21 +3284,23 @@ monadic interface for building graphs.")
 (define-public ghc-double-conversion
   (package
     (name "ghc-double-conversion")
-    (version "2.0.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "double-conversion" version))
-       (sha256
-        (base32
-         "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
+    (version "2.0.4.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "double-conversion" version))
+              (sha256
+               (base32
+                "0r7c1801gzdm5x1flmpx8ajxygbc9dl7sgdj0xn3bpm71wgvrf4s"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "double-conversion")))
-    (native-inputs
-     (list ghc-hunit ghc-test-framework ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2))
-    (home-page "https://github.com/bos/double-conversion")
-    (synopsis "Fast conversion between double precision floating point and text")
+    (native-inputs (list ghc-hunit ghc-test-framework ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1mpnx4m2pg5crfz9k8wamh5mgsha0np3ynnllrmglmwh54gvfjj3")))
+    (home-page "https://github.com/haskell/double-conversion")
+    (synopsis
+     "Fast conversion between double precision floating point and text")
     (description
      "This package provides a library that performs fast, accurate conversion
 between double precision floating point and text.")
@@ -3412,28 +3309,21 @@ between double precision floating point and text.")
 (define-public ghc-dual-tree
   (package
     (name "ghc-dual-tree")
-    (version "0.2.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "dual-tree" version))
-       (sha256
-        (base32
-         "0qyn7kb42wvlcvb1wbf1qx3isc2y6k3hzp5iq6ab0r0llw9g6qlg"))))
+    (version "0.2.3.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "dual-tree" version))
+              (sha256
+               (base32
+                "19nm34d166fhlkk7npx0iq9kbx7300a82bg75q1sx98jqfa4nffh"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "dual-tree")))
-    (arguments
-     `(#:tests? #f ; TODO: ghc-testing-feat does not build.
-       #:cabal-revision
-       ("1" "1babd7ybsgk73x57yl35q0n1i7mbbqmv4am710kq1hzg3in4g9dv")))
-    (inputs
-     (list ghc-semigroups ghc-newtype-generics ghc-monoid-extras))
-;    (native-inputs
-;     `(("ghc-quickcheck" ,ghc-quickcheck)
-;       ("ghc-testing-feat" ,ghc-testing-feat)))
-    (home-page "https://hackage.haskell.org/package/dual-tree")
+    (inputs (list ghc-semigroups ghc-monoid-extras))
+    (native-inputs (list ghc-quickcheck ghc-testing-feat))
+    (home-page "http://hackage.haskell.org/package/dual-tree")
     (synopsis "Rose trees with cached and accumulating monoidal annotations")
-    (description "Rose (@math{n}-ary) trees with both upwards- (i.e.
+    (description
+     "Rose (@math{n}-ary) trees with both upwards- (i.e.
 cached) and downwards-traveling (i.e. accumulating) monoidal
 annotations.  This is used as the core data structure underlying the
 @url{https://archives.haskell.org/projects.haskell.org/diagrams/,
@@ -3568,33 +3458,19 @@ but is otherwise agnostic to:
 (define-public ghc-either
   (package
     (name "ghc-either")
-    (version "5.0.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "either" version))
-       (sha256
-        (base32
-         "09yzki8ss56xhy9vggdw1rls86b2kf55hjl5wi0vbv02d8fxahq2"))))
+    (version "5.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "either" version))
+              (sha256
+               (base32
+                "1gl748ia68bldbqb2fl7vjv44g0y8ivn659fjmy1qyypgyb5p95z"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "either")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "03bgnq55lc6f1nx4p662gidfsyyfm3xm4fi84h77wnsppxrpa5j1")))
-    (inputs `(("ghc-bifunctors" ,ghc-bifunctors)
-              ("ghc-exceptions" ,ghc-exceptions)
-              ("ghc-free" ,ghc-free)
-              ("ghc-monad-control" ,ghc-monad-control)
-              ("ghc-manodrandom" ,ghc-monadrandom)
-              ("ghc-mmorph" ,ghc-mmorph)
-              ("ghc-profunctors" ,ghc-profunctors)
-              ("ghc-semigroups" ,ghc-semigroups)
-              ("ghc-semigroupoids" ,ghc-semigroupoids)
-              ("ghc-transformers-base" ,ghc-transformers-base)))
-    (native-inputs
-     (list ghc-quickcheck ghc-test-framework
-           ghc-test-framework-quickcheck2))
-    (home-page "https://github.com/ekmett/either")
+    (inputs (list ghc-bifunctors ghc-profunctors ghc-semigroupoids))
+    (native-inputs (list ghc-test-framework ghc-test-framework-quickcheck2
+                         ghc-quickcheck))
+    (home-page "http://github.com/ekmett/either/")
     (synopsis "Provides an either monad transformer for Haskell")
     (description "This Haskell package provides an either monad transformer.")
     (license license:bsd-3)))
@@ -3602,20 +3478,18 @@ but is otherwise agnostic to:
 (define-public ghc-email-validate
   (package
     (name "ghc-email-validate")
-    (version "2.3.2.15")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "email-validate" version))
-       (sha256
-        (base32
-         "0n67wss6k8lhwfkybkhsa04bbdfdv541sacbxlylkx2hqpj5r5gh"))))
+    (version "2.3.2.18")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "email-validate" version))
+              (sha256
+               (base32
+                "11bi5y5qmri62nl34nl5pv4zs59bjpjknw560yw5ds62gsi2sjcp"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "email-validate")))
-    (inputs
-     (list ghc-attoparsec ghc-hspec ghc-quickcheck ghc-doctest))
-    (home-page
-     "https://github.com/Porges/email-validate-hs")
+    (inputs (list ghc-attoparsec))
+    (native-inputs (list ghc-hspec ghc-quickcheck ghc-doctest))
+    (home-page "https://github.com/Porges/email-validate-hs")
     (synopsis "Email address validator for Haskell")
     (description
      "This Haskell package provides a validator that can validate an email
@@ -3653,18 +3527,17 @@ asynchronous exceptions.")
 (define-public ghc-equivalence
   (package
     (name "ghc-equivalence")
-    (version "0.3.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "equivalence" version))
-       (sha256
-        (base32 "167njzd1cf32aa7br90rjafrxy6hw3fxkk8awifqbxjrcwm5maqp"))))
+    (version "0.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "equivalence" version))
+              (sha256
+               (base32
+                "13q0lklm58n0l7bx0d4k1cw1i2il8hpdjp76lb79ix8lv7cxd2jr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "equivalence")))
-    (inputs
-     (list ghc-stmonadtrans ghc-transformers-compat ghc-fail
-           ghc-quickcheck))
+    (inputs (list ghc-stmonadtrans ghc-transformers-compat ghc-fail))
+    (native-inputs (list ghc-quickcheck))
     (home-page "https://github.com/pa-ba/equivalence")
     (synopsis "Maintaining an equivalence relation implemented as union-find")
     (description
@@ -3735,6 +3608,9 @@ This package provides an orphan instance.")
     (inputs
      (list ghc-exceptions ghc-transformers-compat ghc-unexceptionalio
            ghc-safe))
+    (arguments
+     `(#:cabal-revision ("4"
+                         "0sji6ny86f4j9ch1cyf2p1mcr5b2ighvw4bb9rssvypxb6k2r68f")))
     (home-page "https://github.com/gabriel439/haskell-errors-library")
     (synopsis "Error handling library for Haskell")
     (description "This library encourages an error-handling style that
@@ -3744,44 +3620,41 @@ directly uses the type system, rather than out-of-band exceptions.")
 (define-public ghc-esqueleto
   (package
     (name "ghc-esqueleto")
-    (version "3.5.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "esqueleto" version))
-       (sha256
-        (base32
-         "0z3cf49sha6q965qw2m08jfmb91ki2rsdpnr7l39lka5b4ffxjlz"))))
+    (version "3.5.8.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "esqueleto" version))
+              (sha256
+               (base32
+                "0k7h2hbxv14x0kq9w2wi83h0swzlri99ic9rj76540l39yqwjc5v"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "esqueleto")))
-    (arguments
-     `(#:tests? #f))  ; TODO: Cannot connect to mysql server.
-    (inputs
-     (list ghc-aeson
-           ghc-attoparsec
-           ghc-blaze-html
-           ghc-conduit
-           ghc-monad-logger
-           ghc-persistent
-           ghc-resourcet
-           ghc-tagged
-           ghc-unliftio
-           ghc-unordered-containers
-           openssl
-           zlib))
-    (native-inputs
-     (list ghc-hspec-core
-           ghc-hspec
-           ghc-mysql
-           ghc-mysql-simple
-           ghc-persistent-mysql
-           ghc-persistent-postgresql
-           ghc-persistent-sqlite
-           ghc-postgresql-simple
-           ghc-quickcheck))
+    (inputs (list ghc-aeson
+                  ghc-attoparsec
+                  ghc-blaze-html
+                  ghc-conduit
+                  ghc-monad-logger
+                  ghc-persistent
+                  ghc-resourcet
+                  ghc-tagged
+                  ghc-unliftio
+                  ghc-unordered-containers
+                  openssl
+                  zlib))
+    (native-inputs (list ghc-hspec
+                         ghc-hspec-core
+                         ghc-mysql
+                         ghc-mysql-simple
+                         ghc-persistent-mysql
+                         ghc-persistent-postgresql
+                         ghc-persistent-sqlite
+                         ghc-postgresql-simple
+                         ghc-quickcheck))
+    (arguments (list #:tests? #f)) ; Needs a running MySQLd.
     (home-page "https://github.com/bitemyapp/esqueleto")
     (synopsis "Type-safe embedded domain specific language for SQL queries")
-    (description "This library provides a type-safe embedded domain specific
+    (description
+     "This library provides a type-safe embedded domain specific
 language (EDSL) for SQL queries that works with SQL backends as provided by
 @code{ghc-persistent}.  Its language closely resembles SQL, so you don't have
 to learn new concepts, just new syntax, and it's fairly easy to predict the
@@ -3791,22 +3664,26 @@ generated SQL and optimize it for your backend.")
 (define-public ghc-exactprint
   (package
     (name "ghc-exactprint")
-    (version "0.6.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ghc-exactprint" version))
-       (sha256
-        (base32
-         "0a6baza962d4pz2m02hxmh8234i47zkizmwhsy68namr05dmlgpw"))))
+    (version "1.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ghc-exactprint" version))
+              (sha256
+               (base32
+                "07m4cg47knrrvpyimnbc0nq9176vkzwwa64b2iqfj6azn6q2hagp"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ghc-exactprint")))
-    (inputs
-     (list ghc-paths ghc-syb ghc-free))
-    (native-inputs
-     (list ghc-hunit ghc-diff ghc-silently ghc-filemanip))
-    (home-page
-     "https://hackage.haskell.org/package/ghc-exactprint")
+    (inputs (list ghc-ordered-containers
+                  ghc-data-default
+                  ghc-paths
+                  ghc-syb
+                  ghc-free
+                  ghc-fail))
+    (native-inputs (list ghc-hunit ghc-diff ghc-silently ghc-filemanip))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1v6my8bnhjhw7k3v2q9iwjpz9lj5g6ilvlzdq6svcabxahmzbr2c")))
+    (home-page "http://hackage.haskell.org/package/ghc-exactprint")
     (synopsis "ExactPrint for GHC")
     (description
      "Using the API Annotations available from GHC 7.10.2, this library
@@ -3884,22 +3761,21 @@ versions of GHC (i.e., < 6.10).")
 (define-public ghc-extra
   (package
     (name "ghc-extra")
-    (version "1.7.9")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "extra" version))
-       (sha256
-        (base32
-         "17fzmxwrv0w7inhq7kia36prc2nsx845r9v56sihqvr17fk2cvpn"))))
+    (version "1.7.12")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "extra" version))
+              (sha256
+               (base32
+                "0g5h8fp0nq4k9asiknw0bhvb10zpfnsixfp0n3xz0rc83pnajwg5"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "extra")))
-    (inputs
-     (list ghc-clock ghc-semigroups ghc-quickcheck
-           ghc-quickcheck-instances))
-    (home-page "https://github.com/ndmitchell/extra")
+    (inputs (list ghc-clock))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck-instances))
+    (home-page "https://github.com/ndmitchell/extra#readme")
     (synopsis "Extra Haskell functions")
-    (description "This library provides extra functions for the standard
+    (description
+     "This library provides extra functions for the standard
 Haskell libraries.  Most functions are simple additions, filling out missing
 functionality.  A few functions are available in later versions of GHC, but
 this package makes them available back to GHC 7.2.")
@@ -3933,21 +3809,19 @@ when used with GHC versions which already provide the
 (define-public ghc-fast-logger
   (package
     (name "ghc-fast-logger")
-    (version "3.0.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "fast-logger" version))
-       (sha256
-        (base32
-         "1mbnah6n8lig494523czcd95dfn01f438qai9pf20wpa2gdbz4x6"))))
+    (version "3.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "fast-logger" version))
+              (sha256
+               (base32
+                "1rx866swvqq7lzngv4bx7qinnwmm3aa2la8caljvbfbi0xz6wps3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "fast-logger")))
-    (inputs
-     (list ghc-auto-update ghc-easy-file ghc-unix-time ghc-unix-compat))
-    (native-inputs
-     (list hspec-discover ghc-hspec))
-    (home-page "https://hackage.haskell.org/package/fast-logger")
+    (inputs (list ghc-auto-update ghc-easy-file ghc-unix-time ghc-unix-compat
+                  ghc-bytestring-builder hspec-discover))
+    (native-inputs (list ghc-hspec))
+    (home-page "https://github.com/kazu-yamamoto/logger")
     (synopsis "Fast logging system")
     (description "This library provides a fast logging system for Haskell.")
     (license license:bsd-3)))
@@ -3955,37 +3829,35 @@ when used with GHC versions which already provide the
 (define-public ghc-feed
   (package
     (name "ghc-feed")
-    (version "1.3.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "feed" version))
-       (sha256
-        (base32
-         "0kv3vx3njqlhwvkmf12m1gmwl8jj97kfa60da2362vwdavhcf4dk"))))
+    (version "1.3.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "feed" version))
+              (sha256
+               (base32
+                "0marh7qmggq1z5339nid3gil7k786d3yk79b0rwfkxxaxmr41xd8"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "feed")))
-    (arguments `(#:tests? #f)) ; TODO: Fail.
-    (inputs
-     (list ghc-base-compat
-           ghc-old-locale
-           ghc-old-time
-           ghc-safe
-           ghc-time-locale-compat
-           ghc-utf8-string
-           ghc-xml-conduit
-           ghc-xml-types))
-    (native-inputs
-     (list ghc-doctest-driver-gen
-           ghc-doctest
-           ghc-hunit
-           ghc-markdown-unlit
-           ghc-syb
-           ghc-test-framework
-           ghc-test-framework-hunit))
-    (home-page "https://github.com/bergmark/feed")
+    (inputs (list ghc-base-compat
+                  ghc-old-locale
+                  ghc-old-time
+                  ghc-safe
+                  ghc-time-locale-compat
+                  ghc-utf8-string
+                  ghc-xml-types
+                  ghc-xml-conduit))
+    (native-inputs (list ghc-hunit
+                         ghc-markdown-unlit
+                         ghc-syb
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-doctest
+                         ghc-doctest-driver-gen))
+    (arguments (list #:tests? #f)) ; Must be installed before testing.
+    (home-page "https://github.com/haskell-party/feed")
     (synopsis "Haskell package for handling various syndication formats")
-    (description "This Haskell package includes tools for generating and
+    (description
+     "This Haskell package includes tools for generating and
 consuming feeds in both RSS (Really Simple Syndication) and Atom format.")
     (license license:bsd-3)))
 
@@ -4004,15 +3876,14 @@ consuming feeds in both RSS (Really Simple Syndication) and Atom format.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "fgl")))
     (arguments
-     `(#:phases
+     `(#:cabal-revision ("1"
+                         "0d5b88j42a3f50b7kbksszvwvcgr59f8pcg3p6cvzq9f4n7y51s7")
+       #:phases
        (modify-phases %standard-phases
          (add-before 'configure 'update-constraints
            (lambda _
              (substitute* "fgl.cabal"
-               (("QuickCheck >= 2\\.8 && < 2\\.13")
-                "QuickCheck >= 2.8 && < 2.14")
-               (("hspec >= 2\\.1 && < 2\\.7")
-                "hspec >= 2.1 && < 2.8")))))))
+               (("hspec >= 2\\.1 && < 2\\.8") "hspec")))))))
     (inputs
      (list ghc-hspec ghc-quickcheck))
     (home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell")
@@ -4039,6 +3910,13 @@ encourages inductive, recursive definitions of graph algorithms.")
     (properties '((upstream-name . "fgl-arbitrary")))
     (inputs
      (list ghc-fgl ghc-quickcheck ghc-hspec))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "fgl-arbitrary.cabal"
+               (("hspec >= 2\\.1 && < 2\\.8") "hspec")))))))
     (home-page "https://hackage.haskell.org/package/fgl-arbitrary")
     (synopsis "QuickCheck support for fgl")
     (description
@@ -4091,24 +3969,31 @@ directories.  It includes code for pattern matching, finding files, modifying
 file contents, and more.")
     (license license:bsd-3)))
 
+;; Deprecated.
 (define-public ghc-filepath-bytestring
   (package
     (name "ghc-filepath-bytestring")
-    (version "1.4.2.1.8")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "filepath-bytestring" version))
-       (sha256
-        (base32
-         "0qrrvbjpjsk75ghqrdqzwqg7wjgm3rr9kk7p04ax98ilv90pm0ip"))))
+    (version "1.4.2.1.12")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "filepath-bytestring" version))
+              (sha256
+               (base32
+                "0i8j724fz8h1bcqvlvp3sxmgyrvx2sim74cvzkpc9m05yn9p27sq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "filepath-bytestring")))
-    (native-inputs
-     (list ghc-quickcheck))
-    (home-page "https://hackage.haskell.org/package/filepath-bytestring")
+    (native-inputs (list ghc-quickcheck))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "filepath-bytestring.cabal"
+               (("filepath >= 1\\.4\\.2 && <= 1\\.4\\.2\\.1") "filepath")))))))
+    (home-page "http://hackage.haskell.org/package/filepath-bytestring")
     (synopsis "Library for manipulating RawFilePaths in a cross-platform way")
-    (description "This package provides a drop-in replacement for the standard
+    (description
+     "This package provides a drop-in replacement for the standard
 @code{filepath} library, operating on @code{RawFilePath} values rather than
 @code{FilePath} values to get the speed benefits of using @code{ByteStrings}.")
     (license license:bsd-3)))
@@ -4138,22 +4023,22 @@ an executable.")
 (define-public ghc-fingertree
   (package
     (name "ghc-fingertree")
-    (version "0.1.4.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "fingertree" version))
-       (sha256
-        (base32
-         "0zvandj8fysck7ygpn0dw5bhrhmj1s63i326nalxbfkh2ls4iacm"))))
+    (version "0.1.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "fingertree" version))
+              (sha256
+               (base32
+                "0wdzpli8bpgk8lrsp105zb0y5gn1r2029laclvhz264bza93q9pk"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "fingertree")))
-    (native-inputs
-     (list ghc-hunit ghc-quickcheck ghc-test-framework
-           ghc-test-framework-hunit ghc-test-framework-quickcheck2))
-    (home-page "https://hackage.haskell.org/package/fingertree")
+    (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (home-page "http://hackage.haskell.org/package/fingertree")
     (synopsis "Generic finger-tree structure")
-    (description "This library provides finger trees, a general sequence
+    (description
+     "This library provides finger trees, a general sequence
 representation with arbitrary annotations, for use as a base for
 implementations of various collection types.  It includes examples, as
 described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
@@ -4163,15 +4048,16 @@ simple general-purpose data structure\".")
 (define-public ghc-finite-typelits
   (package
     (name "ghc-finite-typelits")
-    (version "0.1.4.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "finite-typelits" version))
-       (sha256
-        (base32 "0iyp9fyd2ki9qcmk9infz9p6rjhsx9jrs3f5yz0yqs8vj5na81yj"))))
+    (version "0.1.6.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "finite-typelits" version))
+              (sha256
+               (base32
+                "0f047dywlxiz3pl3rq6maym9wpwjwl4zjqfwlwnj0yiv7dmlaiih"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "finite-typelits")))
+    (native-inputs (list ghc-quickcheck))
     (home-page "https://github.com/mniip/finite-typelits")
     (synopsis "Finitely many values, indexed by type-level naturals")
     (description
@@ -4225,31 +4111,30 @@ completely unverified though.")
 (define-public ghc-foldl
   (package
     (name "ghc-foldl")
-    (version "1.4.12")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "foldl" version))
-       (sha256
-        (base32
-         "0zf4yljh3s2ddxa7dhzdglmylj14kfldhkclc44g37zvjq6kcnag"))))
+    (version "1.4.13")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "foldl" version))
+              (sha256
+               (base32
+                "14vlhgf40qmwkznwza37z4www3q1v5acsx4nw5vmg25wdnc8ibfw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "foldl")))
-    (outputs '("out" "static" "doc"))
-    (inputs (list ghc-comonad
-                  ghc-contravariant
-                  ghc-hashable
+    (inputs (list ghc-random
                   ghc-primitive
+                  ghc-vector
+                  ghc-unordered-containers
+                  ghc-hashable
+                  ghc-contravariant
                   ghc-profunctors
-                  ghc-random
                   ghc-semigroupoids
-                  ghc-semigroups
-                  ghc-unordered-containers
-                  ghc-vector))
+                  ghc-comonad
+                  ghc-semigroups))
     (native-inputs (list ghc-doctest))
-    (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library")
+    (home-page "http://hackage.haskell.org/package/foldl")
     (synopsis "Composable, streaming, and efficient left folds for Haskell")
-    (description "This Haskell library provides strict left folds that stream
+    (description
+     "This Haskell library provides strict left folds that stream
 in constant memory, and you can combine folds using @code{Applicative} style
 to derive new folds.  Derived folds still traverse the container just once
 and are often as efficient as hand-written folds.")
@@ -4258,27 +4143,15 @@ and are often as efficient as hand-written folds.")
 (define-public ghc-foundation
   (package
     (name "ghc-foundation")
-    (version "0.0.26.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "foundation" version))
-       (sha256
-        (base32
-         "1hri3raqf6nhh6631gfm2yrkv4039gb0cqfa9cqmjp8bbqv28w5d"))))
+    (version "0.0.29")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "foundation" version))
+              (sha256
+               (base32
+                "1hbkh6a3g6wsj2z48pjimd7djkm82mdxfwc24bnmmzag8amrp0rl"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "foundation")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         ;; This test is broken.  For details, see
-         ;; https://github.com/haskell-foundation/foundation/issues/530
-         (add-after 'unpack 'patch-tests
-           (lambda _
-             (substitute* "tests/Test/Foundation/Number.hs"
-               ((", testDividible proxy") ""))
-             #t)))))
-    (outputs '("out" "static" "doc"))
     (inputs (list ghc-basement))
     (home-page "https://github.com/haskell-foundation/foundation")
     (synopsis "Alternative prelude with batteries and no dependencies")
@@ -4297,37 +4170,33 @@ Foundation has the following goals:
 @item Numerical classes that better represent mathematical things (no more
    all-in-one @code{Num});
 @item I/O system with less lazy IO.
-@end enumerate\n")
+@end enumerate
+")
     (license license:bsd-3)))
 
 (define-public ghc-free
   (package
     (name "ghc-free")
-    (version "5.1.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "free" version))
-       (sha256
-        (base32
-         "121b81wxjk30nc27ivwzxjxi1dcwc30y0gy8l6wac3dxwvkx2c5j"))))
+    (version "5.1.10")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "free" version))
+              (sha256
+               (base32
+                "0whff0r0nvii5l9z9crw7v0rj0wwblwbnfp99515siyxjkzs9phj"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "free")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-prelude-extras
-           ghc-profunctors
-           ghc-exceptions
-           ghc-bifunctors
-           ghc-comonad
-           ghc-distributive
-           ghc-semigroupoids
-           ghc-semigroups
-           ghc-transformers-base
-           ghc-transformers-compat))
-    (home-page "https://github.com/ekmett/free/")
+    (inputs (list ghc-comonad
+                  ghc-distributive
+                  ghc-indexed-traversable
+                  ghc-semigroupoids
+                  ghc-th-abstraction
+                  ghc-transformers-base
+                  ghc-profunctors))
+    (home-page "http://github.com/ekmett/free/")
     (synopsis "Unrestricted monads for Haskell")
-    (description "This library provides free monads, which are useful for many
+    (description
+     "This library provides free monads, which are useful for many
 tree-like structures and domain specific languages.  If @code{f} is a
 @code{Functor} then the free @code{Monad} on @code{f} is the type of trees
 whose nodes are labeled with the constructors of @code{f}.  The word \"free\"
@@ -4367,22 +4236,19 @@ specific Windows, Mac, and Linux file system event notification.")
 (define-public ghc-generic-deriving
   (package
     (name "ghc-generic-deriving")
-    (version "1.14.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "generic-deriving" version))
-       (sha256
-        (base32
-         "19qpahcfhs9nqqv6na8znybrvpw885cajbdnrfylxbsmm0sys4s7"))))
+    (version "1.14.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "generic-deriving" version))
+              (sha256
+               (base32
+                "0bxacg6b1vz135x93vf7jk6129m08hdyj7426ymaylfl2w8kapi6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "generic-deriving")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-th-abstraction))
-    (native-inputs
-     (list ghc-hspec hspec-discover))
-    (home-page "https://hackage.haskell.org/package/generic-deriving")
+    (inputs (list ghc-th-abstraction))
+    ;(native-inputs (list ghc-hspec))
+    (arguments (list #:tests? #f)) ;; Cannot resolve package cycle.
+    (home-page "https://github.com/dreixel/generic-deriving")
     (synopsis "Generalise the deriving mechanism to arbitrary classes")
     (description "This package provides functionality for generalising the
 deriving mechanism in Haskell to arbitrary classes.")
@@ -4391,23 +4257,17 @@ deriving mechanism in Haskell to arbitrary classes.")
 (define-public ghc-generic-random
   (package
     (name "ghc-generic-random")
-    (version "1.2.0.0")
+    (version "1.5.0.1")
     (source
      (origin
        (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/generic-random/"
-             "generic-random-" version ".tar.gz"))
+       (uri (hackage-uri "generic-random" version))
        (sha256
-        (base32 "130lmblycxnpqbsl7vf6a90zccibnvcb5zaclfajcn3by39007lv"))))
+        (base32 "02iczjf2xc4sxfi234nf6irfj5slvf3p5hpaxl8r5nc8hy052d6x"))))
     (build-system haskell-build-system)
     (properties `((upstream-name . "generic-random")))
     (inputs (list ghc-quickcheck))
-    (native-inputs
-     (list ghc-inspection-testing))
-    (arguments
-     `(#:cabal-revision
-       ("1" "1d0hx41r7yq2a86ydnfh2fv540ah8cz05l071s2z4wxcjw0ymyn4")))
+    (native-inputs (list ghc-inspection-testing ghc-inspection-testing))
     (home-page
      "https://github.com/lysxia/generic-random")
     (synopsis
@@ -4429,83 +4289,47 @@ trivially terminating generator given explicitly (@code{genericArbitraryRec}
 and @code{withBaseCase}) or implicitly (@code{genericArbitrary'}).")
     (license license:expat)))
 
-(define-public ghc-generic-random-1.3.0.1
-  (package
-    (inherit ghc-generic-random)
-    (version "1.4.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "generic-random" version))
-       (sha256
-        (base32 "12rvb1dzrfjc46n9vdcw3yv773iih8vwhrac3hpzq70yp2z77jdw"))))
-    (arguments '())))
-
 (define-public ghc-generics-sop
   (package
     (name "ghc-generics-sop")
-    (version "0.5.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "generics-sop" version))
-       (sha256
-        (base32
-         "1n65wjdbb9fswa43ys5k6c746c905877lw5ij33y66iabj5w7dw1"))))
+    (version "0.5.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "generics-sop" version))
+              (sha256
+               (base32
+                "098blydb7c7wg77dn658r0zb1z20vfkar1him1rqlq0da90437b3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "generics-sop")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-sop-core ghc-th-abstraction))
-    (home-page "https://github.com/well-typed/generics-sop")
+    (inputs (list ghc-sop-core ghc-th-abstraction))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1s8bx25yrjqy1cj9y1s1m8a8qlby9dxjzin16yymz7g39fqcqxz8")))
+    (home-page "http://hackage.haskell.org/package/generics-sop")
     (synopsis "Generic Programming using True Sums of Products for Haskell")
-    (description "This Haskell package supports the definition of generic
+    (description
+     "This Haskell package supports the definition of generic
 functions.  Datatypes are viewed in a uniform, structured way: the choice
 between constructors is represented using an n-ary sum, and the arguments of
 each constructor are represented using an n-ary product.")
     (license license:bsd-3)))
 
-(define-public ghc-geniplate-mirror
-  (package
-    (name "ghc-geniplate-mirror")
-    (version "0.7.8")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "geniplate-mirror" version))
-       (sha256
-        (base32 "1kw4q7l556sfd82r2p0z3cv4sg8kcr45wb4s2sy996bs3ymn8fjb"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "geniplate-mirror")))
-    (home-page "https://github.com/danr/geniplate")
-    (synopsis "Use Template Haskell to generate Uniplate-like functions")
-    (description
-     "Use Template Haskell to generate Uniplate-like functions.  This is a
-maintained mirror of the @uref{https://hackage.haskell.org/package/geniplate,
-geniplate} package, written by Lennart Augustsson.")
-    (license license:bsd-3)))
-
 (define-public ghc-genvalidity
   (package
     (name "ghc-genvalidity")
-    (version "0.11.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "genvalidity" version))
-       (sha256
-        (base32
-         "16bd5dx0ngc8z7mij23i2l3a8v3c112x8ksd623alik18zx7pi8j"))))
+    (version "1.1.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "genvalidity" version))
+              (sha256
+               (base32
+                "08xvbgzhi9f2s3g81zzd8yhrn66mr84m0dvp478nrbck19jdg5sq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "genvalidity")))
-    (inputs
-     (list ghc-quickcheck ghc-validity))
-    (native-inputs
-     (list ghc-hspec hspec-discover ghc-hspec-core))
-    (home-page
-     "https://github.com/NorfairKing/validity")
-    (synopsis
-     "Testing utilities for the @code{validity} library")
+    (inputs (list ghc-quickcheck ghc-random ghc-validity))
+    (native-inputs (list ghc-hspec ghc-hspec-core hspec-discover))
+    (home-page "https://github.com/NorfairKing/validity#readme")
+    (synopsis "Testing utilities for the @code{validity} library")
     (description
      "This package provides testing utilities that are useful in conjunction
 with the @code{Validity} typeclass.")
@@ -4514,28 +4338,19 @@ with the @code{Validity} typeclass.")
 (define-public ghc-genvalidity-property
   (package
     (name "ghc-genvalidity-property")
-    (version "0.5.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "genvalidity-property" version))
-       (sha256
-        (base32
-         "0cvzc4z4771vpycwfgcj0yswyglzl6cl1h2wrfhs224nrcmk5a7z"))))
+    (version "1.0.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "genvalidity-property" version))
+              (sha256
+               (base32
+                "1nxcdq04rkckrb3v49pjx378n5s828k24x7hix6manyxqmd3hplw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "genvalidity-property")))
-    (inputs
-     (list ghc-quickcheck
-           ghc-genvalidity
-           ghc-hspec
-           hspec-discover
-           ghc-pretty-show
-           ghc-validity))
-    (native-inputs (list ghc-doctest))
-    (home-page
-     "https://github.com/NorfairKing/validity")
-    (synopsis
-     "Standard properties for functions on @code{Validity} types")
+    (inputs (list ghc-quickcheck ghc-genvalidity ghc-hspec ghc-pretty-show
+                  ghc-validity hspec-discover))
+    (home-page "https://github.com/NorfairKing/validity#readme")
+    (synopsis "Standard properties for functions on @code{Validity} types")
     (description
      "This package supplements the @code{Validity} typeclass with standard
 properties for functions operating on them.")
@@ -4589,16 +4404,19 @@ info for more informative bug reports.")
 (define-public ghc-glob
   (package
     (name "ghc-glob")
-    (version "0.10.1")
+    (version "0.10.2")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "Glob" version))
        (sha256
         (base32
-         "05fknrb114qvfzv6324ngx0fz43cwgrhrc700l3h2is9jinlgr6a"))))
+         "1h3kh46qds4nqvixm4myy1kb5slg53f44hfn8aymrlr7hjn75xka"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "Glob")))
+    (arguments
+     `(#:cabal-revision
+       ("3" "1080rd5073g87rfm5whimb72b75105lqanybrbsfi14gmvndnbfx")))
     (inputs
      (list ghc-dlist ghc-semigroups ghc-transformers-compat))
     (native-inputs
@@ -4613,21 +4431,20 @@ matching patterns against file paths.")
 (define-public ghc-gluraw
   (package
     (name "ghc-gluraw")
-    (version "2.0.0.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "GLURaw" version))
-       (sha256
-        (base32
-         "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq"))))
+    (version "2.0.0.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "GLURaw" version))
+              (sha256
+               (base32
+                "1b3rnva77k9naw5bl573bqgmsq7n9i8rrrvfvhbjcndqgmzhkini"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "GLURaw")))
-    (inputs
-     (list ghc-openglraw))
-    (home-page "https://wiki.haskell.org/Opengl")
+    (inputs (list ghc-openglraw))
+    (home-page "http://www.haskell.org/haskellwiki/Opengl")
     (synopsis "Raw Haskell bindings GLU")
-    (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
+    (description
+     "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
 utility library.  It is basically a 1:1 mapping of GLU's C API, intended as a
 basis for a nicer interface.")
     (license license:bsd-3)))
@@ -4657,32 +4474,18 @@ programs.")
 (define-public ghc-gnuplot
   (package
     (name "ghc-gnuplot")
-    (version "0.5.6.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "gnuplot" version))
-       (sha256
-        (base32 "1rfq94lnsyjr8y9p5r56jpllv3p8rvh9xxzjji016b6r5adi8cnb"))))
+    (version "0.5.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "gnuplot" version))
+              (sha256
+               (base32
+                "1glahh3si5bpazsklnpwxx4h4ivgb4wyngc032797zq1496fhhm3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "gnuplot")))
-    (inputs
-     (list ghc-temporary
-           ghc-utility-ht
-           ghc-data-accessor-transformers
-           ghc-data-accessor
-           ghc-semigroups
-           gnuplot))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'fix-path-to-gnuplot
-           (lambda* (#:key inputs #:allow-other-keys)
-             (let ((gnuplot (assoc-ref inputs "gnuplot")))
-               (substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
-                 (("(gnuplotName = ).*$" all cmd)
-                  (string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
-    (home-page "https://wiki.haskell.org/Gnuplot")
+    (inputs (list ghc-temporary ghc-utility-ht ghc-data-accessor-transformers
+                  ghc-data-accessor ghc-semigroups))
+    (home-page "http://www.haskell.org/haskellwiki/Gnuplot")
     (synopsis "2D and 3D plots using gnuplot")
     (description "This package provides a Haskell module for creating 2D and
 3D plots using gnuplot.")
@@ -4710,6 +4513,9 @@ programs.")
     (native-inputs
      (list ghc-hspec graphviz ghc-fgl-arbitrary ghc-quickcheck
            hspec-discover))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "110yp1h2jrswllnx2ks772g10v9h4vqxc07b33wfaksyim9769bp")))
     (home-page "https://hackage.haskell.org/package/graphviz")
     (synopsis "Bindings to Graphviz for graph visualisation")
     (description
@@ -4752,20 +4558,17 @@ monoid with invertibility.")
 (define-public ghc-gtk2hs-buildtools
   (package
     (name "ghc-gtk2hs-buildtools")
-    (version "0.13.8.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "gtk2hs-buildtools" version))
-       (sha256
-        (base32
-         "102x753jbc90lfm9s0ng5kvm0risqwpar331xwsd752as0bms142"))))
+    (version "0.13.8.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "gtk2hs-buildtools" version))
+              (sha256
+               (base32
+                "0fcm0v32hm9j908nyziia16ahb181y9hqppsy18clx2prvj480rv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "gtk2hs-buildtools")))
-    (inputs
-     (list ghc-random ghc-hashtables))
-    (native-inputs
-     (list ghc-alex ghc-happy))
+    (inputs (list ghc-random ghc-hashtables))
+    (native-inputs (list ghc-alex ghc-happy))
     (home-page "https://projects.haskell.org/gtk2hs/")
     (synopsis "Tools to build the Gtk2Hs suite of user interface libraries")
     (description
@@ -4780,42 +4583,37 @@ tools are not needed to actually run Gtk2Hs programs.")
 (define-public ghc-hackage-security
   (package
     (name "ghc-hackage-security")
-    (version "0.6.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hackage-security" version))
-       (sha256
-        (base32
-         "05rgz31cmp52137j4jk0074z8lfgk8mrf2x56bzw28asmxrv8qli"))))
+    (version "0.6.2.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hackage-security" version))
+              (sha256
+               (base32
+                "0rm0avcc1k247qbrajhzi3vz92cgcc4nr3kbhhfmfm8rjxv0bvjj"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hackage-security")))
-    (arguments
-     `(#:cabal-revision
-       ("8" "1xpzcdpfz0agbv75sadsylq6r8pq7zr0pyzbzrz0nz130yixsv5f")
-       #:tests? #f)) ; Tests fail because of framework updates.
-    (inputs
-     (list ghc-base16-bytestring
-           ghc-base64-bytestring
-           ghc-cryptohash-sha256
-           ghc-ed25519
-           ghc-lukko
-           ghc-network
-           ghc-network-uri
-           ghc-tar
-           ghc-zlib))
-    (native-inputs
-     (list ghc-aeson
-           ghc-quickcheck
-           ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck
-           ghc-temporary
-           ghc-unordered-containers
-           ghc-vector))
+    (inputs (list ghc-base16-bytestring
+                  ghc-base64-bytestring
+                  ghc-ed25519
+                  ghc-cryptohash-sha256
+                  ghc-tar
+                  ghc-zlib
+                  ghc-lukko
+                  ghc-cabal-syntax
+                  ghc-network-uri
+                  ghc-network))
+    (native-inputs (list ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-quickcheck
+                         ghc-aeson
+                         ghc-vector
+                         ghc-unordered-containers
+                         ghc-temporary))
     (home-page "https://github.com/haskell/hackage-security")
     (synopsis "Hackage security library")
-    (description "This Hackage security library provides both server and
+    (description
+     "This Hackage security library provides both server and
 client utilities for securing @uref{http://hackage.haskell.org/, the
 Hackage package server}.  It is based on
 @uref{http://theupdateframework.com/, The Update Framework}, a set of
@@ -4827,14 +4625,14 @@ Tor project}.")
 (define-public ghc-haddock
   (package
     (name "ghc-haddock")
-    (version "2.24.2")
+    (version "2.26.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "haddock" version))
        (sha256
         (base32
-         "1ha4hrnidwkmwalqwd1ixa2933as5n4sj1lvz0cx89a3png7r930"))))
+         "0jqp37pbz4zjqc3dm0jkcsdqsh2ql9ygnr06m75bbk330yqchnl3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haddock")))
     (arguments
@@ -4860,20 +4658,28 @@ Tor project}.")
 (define-public ghc-haddock-api
   (package
     (name "ghc-haddock-api")
-    (version "2.24.2")
+    (version "2.26.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "haddock-api" version))
        (sha256
         (base32
-         "1jj2csi85nlywsyvnbwhclfdz27j2kyfbhrl9cm7av0243br9vg1"))))
+         "0ris5m61vig5nh5y2ddm98midl3v51vzgfgvsfyhm3nwk5hif6ay"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haddock-api")))
     (inputs
      (list ghc-paths ghc-haddock-library))
     (native-inputs
      (list ghc-quickcheck ghc-hspec hspec-discover))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "haddock-api.cabal"
+               (("haddock-library \\^>= 1\\.9\\.0") "haddock-library")
+               (("hspec           \\^>= 2.8") "hspec")))))))
     (home-page "https://www.haskell.org/haddock/")
     (synopsis "API for documentation-generation tool Haddock")
     (description "This package provides an API to Haddock, the
@@ -4893,7 +4699,16 @@ documentation-generation tool for Haskell libraries.")
          "15ak06q8yp11xz1hwr0sg2jqi3r78p1n89ik05hicqvxl3awf1pq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haddock-library")))
-    (arguments `(#:tests? #f)) ; TODO: optparse-applicative ==0.15.*, tree-diff ==0.1.*
+    (arguments
+     `(#:cabal-revision ("3"
+                         "1fnfcr3gvdjrya0czr3k2sqv4xmmvyv66yni2mckfppra93mcglg")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "haddock-library.cabal"
+               (("(base-compat|hspec|optparse-applicative|tree-diff)\\s+[^,]+" all dep)
+                dep)))))))
     (native-inputs
      (list ghc-base-compat
            ghc-hspec
@@ -4999,24 +4814,22 @@ Happy works in a similar way to the yacc tool for C.")
 (define-public ghc-hashable
   (package
     (name "ghc-hashable")
-    (version "1.3.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hashable" version))
-       (sha256
-        (base32
-         "1d4sn4xjf0swrfg8pl93ipavbj12ch3a9aykhkl6mjnczc9m8bl2"))))
+    (version "1.4.1.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hashable" version))
+              (sha256
+               (base32
+                "11sycr73821amdz8g0k8c97igi4z7f9xdvgaxlkxhsp6h310bcz1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hashable")))
-    (arguments
-     `(#:tests? #f ; TODO: Tests require random<1.2
-       #:cabal-revision
-       ("2" "16va8hx4ynw0n5s2warhs13ilj7hrs5fcdn140h1fiix480as36n")))
-    (native-inputs
-     (list ghc-test-framework ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2 ghc-hunit ghc-quickcheck))
-    (home-page "https://github.com/tibbe/hashable")
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-random
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (home-page "http://github.com/haskell-unordered-containers/hashable")
     (synopsis "Class for types that can be converted to a hash value")
     (description
      "This package defines a class, @code{Hashable}, for types that can be
@@ -5035,55 +4848,29 @@ combine hash values.")
     (native-inputs '())
     (properties '((hidden? #t)))))
 
-(define-public ghc-hashable-time
-  (package
-    (name "ghc-hashable-time")
-    (version "0.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hashable-time" version))
-       (sha256
-        (base32
-         "1zw2gqagpbwq1hgx5rlvy6mhsnb15cxg3pmhawwv0ylfihmx2yxh"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "hashable-time")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "151gxiprdlj3masa95vvrxal9nwa72n3p1y15xyj4hp7mvvl4s2l")))
-    (inputs
-     (list ghc-hashable ghc-time-compat))
-    (home-page "https://hackage.haskell.org/package/hashable-time")
-    (synopsis "Hashable instances for Data.Time")
-    (description
-     "This package provides @code{Hashable} instances for types in
-@code{Data.Time}.")
-    (license license:bsd-3)))
-
 (define-public ghc-hashtables
   (package
     (name "ghc-hashtables")
-    (version "1.2.4.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hashtables" version))
-       (sha256
-        (base32 "0vgggm7bqq55zmqj6qji89bfj3k1rdkikkfhyg81vsqf0f3bzhqa"))))
+    (version "1.3.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hashtables" version))
+              (sha256
+               (base32
+                "1hsrihk948xfpy14qrhar50b41kp60i1rx8bkadjg1xb4bml0gbg"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hashtables")))
-    (inputs
-     (list ghc-hashable ghc-primitive ghc-vector))
-    (native-inputs
-     (list ghc-mwc-random
-           ghc-quickcheck
-           ghc-hunit
-           ghc-test-framework
-           ghc-test-framework-quickcheck2
-           ghc-test-framework-hunit))
-    (home-page "https://github.com/gregorycollins/hashtables")
+    (inputs (list ghc-hashable ghc-primitive ghc-vector))
+    (native-inputs (list ghc-mwc-random
+                         ghc-quickcheck
+                         ghc-hunit
+                         ghc-test-framework
+                         ghc-test-framework-quickcheck2
+                         ghc-test-framework-hunit))
+    (home-page "http://github.com/gregorycollins/hashtables")
     (synopsis "Haskell Mutable hash tables in the ST monad")
-    (description "This package provides a Haskell library including a
+    (description
+     "This package provides a Haskell library including a
 couple of different implementations of mutable hash tables in the ST
 monad, as well as a typeclass abstracting their common operations, and
 a set of wrappers to use the hash tables in the IO monad.")
@@ -5092,23 +4879,31 @@ a set of wrappers to use the hash tables in the IO monad.")
 (define-public ghc-haskeline
   (package
     (name "ghc-haskeline")
-    (version "0.8.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "haskeline" version))
-       (sha256
-        (base32
-         "0gqsa5s0drim9m42hv4wrq61mnvcdylxysfxfw3acncwilfrn9pb"))))
+    (version "0.8.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "haskeline" version))
+              (sha256
+               (base32
+                "1pr7zik1138cj0463867i1qqb2bgsq716mryap18jx7zb9f1b7gc"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haskeline")))
-    (inputs (list ghc-exceptions))
-    (native-inputs (list ghc-hunit))
-    ;; FIXME: Tests failing
-    (arguments `(#:tests? #f))
+    (native-inputs (list ghc-hunit which))
+    (arguments
+      (list
+       #:tests? #f ; Cannot run binary haskeline-examples-Test, which is just
+                   ; built, even with PATH and LD_LIBRARY_PATH set.
+       #:cabal-revision
+       '("3" "101qavk0fmc4c6qa307kswz3345psskxqyxhk6hmykynjm05jjrv")
+       #:phases
+       #~(modify-phases %standard-phases
+           (add-before 'configure 'patch-which
+             (lambda* (#:key inputs #:allow-other-keys)
+               (substitute* "tests/Unit.hs"
+                 (("\"which\"")
+                  (string-append "\"" (search-input-file inputs "/bin/which") "\""))))))))
     (home-page "https://github.com/judah/haskeline")
-    (synopsis
-     "Command-line interface for user input, written in Haskell")
+    (synopsis "Command-line interface for user input, written in Haskell")
     (description
      "Haskeline provides a user interface for line input in command-line
 programs.  This library is similar in purpose to readline, but since it is
@@ -5121,43 +4916,38 @@ Haskeline runs both on POSIX-compatible systems and on Windows.")
 (define-public ghc-haskell-lexer
   (package
     (name "ghc-haskell-lexer")
-    (version "1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "haskell-lexer" version))
-       (sha256
-        (base32 "1mb3np20ig0hbgnfxrzr3lczq7ya4p76g20lvnxch8ikck61afii"))))
+    (version "1.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "haskell-lexer" version))
+              (sha256
+               (base32
+                "0jgkv1api3w7i9j5z01h7qdx2i9cp93h54hp9hj1bw9hk9bdmvn8"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haskell-lexer")))
-    (home-page "https://hackage.haskell.org/package/haskell-lexer")
+    (home-page "https://github.com/yav/haskell-lexer")
     (synopsis "Fully compliant Haskell 98 lexer")
-    (description
-     "This package provides a fully compliant Haskell 98 lexer.")
-    (license license:bsd-3)))
+    (description "This package provides a fully compliant Haskell 98 lexer.")
+    (license license:expat)))
 
 (define-public ghc-haskell-src
   (package
     (name "ghc-haskell-src")
-    (version "1.0.3.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "haskell-src" version))
-       (sha256
-        (base32
-         "0cjigvshk4b8wqdk0v0hz9ag1kyjjsmqsy4a1m3n28ac008cg746"))))
+    (version "1.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "haskell-src" version))
+              (sha256
+               (base32
+                "1spkhv83hy5v1lxs44l3w53vk8zj7gnx42c40hrkj4fcz6apdiwb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haskell-src")))
+    (inputs (list ghc-happy ghc-syb))
     (arguments
-     `(#:cabal-revision
-       ("4" "0cyqdw77clzz7mq0b4c0jg2d1kdz9xii41268w2psmqmfpyn29pc")))
-    (inputs
-     (list ghc-happy ghc-syb))
-    (home-page
-     "https://hackage.haskell.org/package/haskell-src")
-    (synopsis
-     "Support for manipulating Haskell source code")
+     `(#:cabal-revision ("1"
+                         "0dfjzq0sxxcalqxygp2svx4890qx8b4amad0xldwy1f4xrp3lsnb")))
+    (home-page "http://hackage.haskell.org/package/haskell-src")
+    (synopsis "Support for manipulating Haskell source code")
     (description
      "The @code{haskell-src} package provides support for manipulating Haskell
 source code.  The package provides a lexer, parser and pretty-printer, and a
@@ -5218,23 +5008,20 @@ patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
 (define-public ghc-haskell-src-meta
   (package
     (name "ghc-haskell-src-meta")
-    (version "0.8.7")
+    (version "0.8.11")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "haskell-src-meta" version))
               (sha256
                (base32
-                "1yy2dfb1ip1zqx3xh28g92209555abzvxrxiwcl95j27zzqxc6in"))))
+                "1wks0xb7ah2gj9n0ffbcaskjihy45l99qkf2h9k13cyfvqkzp9rw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "haskell-src-meta")))
-    (inputs
-     (list ghc-haskell-src-exts ghc-syb ghc-th-orphans))
-    (native-inputs
-     (list ghc-hunit ghc-tasty ghc-tasty-hunit))
-    (home-page "https://hackage.haskell.org/package/haskell-src-meta")
+    (inputs (list ghc-haskell-src-exts ghc-syb ghc-th-orphans))
+    (native-inputs (list ghc-hunit ghc-tasty ghc-tasty-hunit))
+    (home-page "http://hackage.haskell.org/package/haskell-src-meta")
     (synopsis "Parse source to template-haskell abstract syntax")
-    (description
-     "This package provides tools to parse Haskell sources to the
+    (description "This package provides tools to parse Haskell sources to the
 template-haskell abstract syntax.")
     (license license:bsd-3)))
 
@@ -5253,7 +5040,7 @@ template-haskell abstract syntax.")
     (properties '((upstream-name . "hasktags")))
     (arguments
      `(#:cabal-revision
-       ("1" "0q39ssdgm6lcmqj92frjvr53i34divx53zli0qar39mx8ka1l8ml")))
+       ("2" "0f3v6k3bvsczz0z5i09286c0i74wz782vayzyp5lndqvrx3b4g0x")))
     (inputs
      (list ghc-system-filepath ghc-optparse-applicative))
     (native-inputs
@@ -5314,52 +5101,25 @@ descriptions.")
 (define-public ghc-hindent
   (package
     (name "ghc-hindent")
-    (version "5.3.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hindent" version))
-       (sha256
-        (base32
-         "129gkn8qg68wsd60mq8yk7hrqsc8sd8v56xn41m5ii3hriq1mmv7"))))
+    (version "5.3.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hindent" version))
+              (sha256
+               (base32
+                "1pc20iza3v0ljzbx6cycm1j1kbmz8h95xwfq47fd6zfmsrx9w6vn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hindent")))
-    (arguments
-     `(#:modules ((guix build haskell-build-system)
-                  (guix build utils)
-                  (guix build emacs-utils))
-       #:imported-modules (,@%haskell-build-system-modules
-                           (guix build emacs-utils))
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'install 'emacs-install
-           (lambda* (#:key inputs outputs #:allow-other-keys)
-             (let* ((out   (assoc-ref outputs "out"))
-                    (elisp-file "elisp/hindent.el")
-                    (dest  (string-append out "/share/emacs/site-lisp"))
-                    (emacs (search-input-file inputs "/bin/emacs")))
-               (make-file-writable elisp-file)
-               (emacs-substitute-variables elisp-file
-                 ("hindent-process-path"
-                  (string-append out "/bin/hindent")))
-               (install-file elisp-file dest)
-               (emacs-generate-autoloads "hindent" dest)))))))
-    (inputs
-     (list ghc-haskell-src-exts
-           ghc-monad-loops
-           ghc-utf8-string
-           ghc-exceptions
-           ghc-yaml
-           ghc-unix-compat
-           ghc-path
-           ghc-path-io
-           ghc-optparse-applicative))
-    (native-inputs
-     `(("ghc-hspec" ,ghc-hspec)
-       ("ghc-diff" ,ghc-diff)
-       ("emacs" ,emacs-minimal)))
-    (home-page
-     "https://github.com/commercialhaskell/hindent")
+    (inputs (list ghc-haskell-src-exts
+                  ghc-monad-loops
+                  ghc-utf8-string
+                  ghc-yaml
+                  ghc-unix-compat
+                  ghc-path
+                  ghc-path-io
+                  ghc-optparse-applicative))
+    (native-inputs (list ghc-hspec ghc-diff))
+    (home-page "https://github.com/mihaimaruseac/hindent")
     (synopsis "Extensible Haskell pretty printer")
     (description
      "This package provides automatic formatting for Haskell files.  Both a
@@ -5390,47 +5150,47 @@ accessed or modified.")
 (define-public ghc-hledger-lib
   (package
     (name "ghc-hledger-lib")
-    (version "1.21")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hledger-lib" version))
-       (sha256
-        (base32
-         "00prslqk8vnbyz388cpc0nsamzy8xcjzday5q9n3m9lx4p2dhb5y"))))
+    (version "1.27.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hledger-lib" version))
+              (sha256
+               (base32
+                "0w2jnpyfc6pp3n5fzdjd78hdh9vv9w98xwd2j6dw98rm6hlapwhb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hledger-lib")))
-    (inputs
-     (list ghc-aeson
-           ghc-aeson-pretty
-           ghc-ansi-terminal
-           ghc-base-compat-batteries
-           ghc-blaze-markup
-           ghc-call-stack
-           ghc-cassava
-           ghc-cassava-megaparsec
-           ghc-cmdargs
-           ghc-data-default
-           ghc-decimal
-           ghc-extra
-           ghc-file-embed
-           ghc-glob
-           ghc-hashtables
-           ghc-megaparsec
-           ghc-old-time
-           ghc-parser-combinators
-           ghc-pretty-simple
-           ghc-regex-tdfa
-           ghc-safe
-           ghc-tabular
-           ghc-tasty
-           ghc-tasty-hunit
-           ghc-timeit
-           ghc-uglymemo
-           ghc-unordered-containers
-           ghc-utf8-string))
+    (inputs (list ghc-decimal
+                  ghc-glob
+                  ghc-aeson
+                  ghc-aeson-pretty
+                  ghc-ansi-terminal
+                  ghc-blaze-markup
+                  ghc-breakpoint
+                  ghc-call-stack
+                  ghc-cassava
+                  ghc-cassava-megaparsec
+                  ghc-cmdargs
+                  ghc-data-default
+                  ghc-doclayout
+                  ghc-extra
+                  ghc-file-embed
+                  ghc-hashtables
+                  ghc-megaparsec
+                  ghc-microlens
+                  ghc-microlens-th
+                  ghc-parser-combinators
+                  ghc-pretty-simple
+                  ghc-regex-tdfa
+                  ghc-safe
+                  ghc-tabular
+                  ghc-tasty
+                  ghc-tasty-hunit
+                  ghc-timeit
+                  ghc-uglymemo
+                  ghc-unordered-containers
+                  ghc-utf8-string))
     (native-inputs (list ghc-doctest))
-    (home-page "https://hledger.org")
+    (home-page "http://hledger.org")
     (synopsis "Reusable library providing the core functionality of hledger")
     (description
      "A reusable library containing hledger's core functionality.
@@ -5574,10 +5334,11 @@ determine the hostname.")
                 "0jnay5j13vpz6i1rkaj3j0d9v8jfpri499xn3l7wd01f81f5ncs4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hourglass")))
+    (arguments (list #:tests? #f)) ; Tests incompatible with newer versions.
     (inputs
      (list ghc-old-locale))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
+    ;(native-inputs
+    ; (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
     (home-page "https://github.com/vincenthz/hs-hourglass")
     (synopsis "Simple time-related library for Haskell")
     (description
@@ -5591,38 +5352,35 @@ representations of current time.")
 (define-public ghc-hpack
   (package
     (name "ghc-hpack")
-    (version "0.34.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hpack" version))
-       (sha256
-        (base32
-         "0gmm6jgi1sgyilphww6apq1x04grqznm7xhyb7g1rj5j7my40ws2"))))
+    (version "0.35.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hpack" version))
+              (sha256
+               (base32
+                "1hpc6bwx94v943p73l12nnncbs656f2fn7q3hb4qs13xrxygzl4g"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hpack")))
-    (inputs
-     (list ghc-aeson
-           ghc-bifunctors
-           ghc-cryptonite
-           ghc-glob
-           ghc-http-client
-           ghc-http-client-tls
-           ghc-http-types
-           ghc-infer-license
-           ghc-scientific
-           ghc-unordered-containers
-           ghc-vector
-           ghc-yaml))
-    (native-inputs
-     (list ghc-hspec
-           ghc-hunit
-           ghc-interpolate
-           ghc-mockery
-           ghc-quickcheck
-           ghc-temporary
-           hspec-discover))
-    (home-page "https://github.com/sol/hpack")
+    (inputs (list ghc-glob
+                  ghc-aeson
+                  ghc-bifunctors
+                  ghc-cryptonite
+                  ghc-http-client
+                  ghc-http-client-tls
+                  ghc-http-types
+                  ghc-infer-license
+                  ghc-scientific
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-yaml))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-hspec
+                         ghc-interpolate
+                         ghc-mockery
+                         ghc-temporary
+                         hspec-discover))
+    (home-page "https://github.com/sol/hpack#readme")
     (synopsis "Tools for an alternative Haskell package format")
     (description
      "Hpack is a format for Haskell packages.  It is an alternative to the
@@ -5692,8 +5450,8 @@ MODS-format XML intermediate.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "hslogger")))
     (arguments
-     `(#:cabal-revision
-       ("3" "04mda3bwr2a00f5nbkqc84d46lmqfsk3gibzg3amdh74ngb451xq")))
+     `(#:cabal-revision ("6"
+                         "0xiqjl646kxynsccc2q1q91sch7pfx3274yl2745fsqhpb115df1")))
     (inputs
      (list ghc-network ghc-old-locale))
     (native-inputs
@@ -5709,29 +5467,29 @@ handler built in.")
 (define-public ghc-hslua
   (package
     (name "ghc-hslua")
-    (version "1.3.0.2")
+    (version "2.2.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "hslua" version))
               (sha256
                (base32
-                "0p39xm0mmxzs5x6aim11qkb7npn0d9h7li2kwfhry0dijd1vm18i"))))
+                "1q587cjwb29jsf71hhmra6djr2sycbx2hr0rhwlgvb8ax699vkv3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hslua")))
-    (arguments
-     `(#:configure-flags '("-fsystem-lua")
-       #:extra-directories ("lua")))
-    (inputs
-     (list lua ghc-base-compat))
-    (native-inputs
-     (list ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck
-           ghc-quickcheck
-           ghc-quickcheck-instances
-           ghc-fail
-           ghc-semigroups))
-    (home-page "https://hackage.haskell.org/package/hslua")
+    (inputs (list ghc-hslua-aeson
+                  ghc-hslua-core
+                  ghc-hslua-classes
+                  ghc-hslua-marshalling
+                  ghc-hslua-objectorientation
+                  ghc-hslua-packaging))
+    (native-inputs (list ghc-lua
+                         ghc-lua-arbitrary
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-tasty-hslua
+                         ghc-tasty
+                         ghc-tasty-hunit))
+    (home-page "https://hslua.org/")
     (synopsis "Lua language interpreter embedding in Haskell")
     (description
      "The Scripting.Lua module is a wrapper of the Lua language interpreter as
@@ -5741,23 +5499,22 @@ described in @url{https://www.lua.org/}.")
 (define-public ghc-hslua-module-system
   (package
     (name "ghc-hslua-module-system")
-    (version "0.2.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hslua-module-system" version))
-       (sha256
-        (base32
-         "0hk2splyasbplnggknjhlb423axc5b32xq8aq8zal4vvwlqhzvf1"))))
+    (version "1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-module-system" version))
+              (sha256
+               (base32
+                "0lacf9jzd53r75dk5nvkx0nwgiakpkingjnz58bhjfnvi81r6ddn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hslua-module-system")))
-    (inputs
-     (list ghc-hslua ghc-temporary))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-lua ghc-tasty-hunit))
-    (home-page "https://github.com/hslua/hslua-module-system")
+    (inputs (list ghc-hslua-core ghc-hslua-packaging ghc-hslua-marshalling
+                  ghc-temporary))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua))
+    (home-page "https://github.com/hslua/hslua")
     (synopsis "Lua module wrapper around Haskell's System module")
-    (description "This library provides access to system information and
+    (description
+     "This library provides access to system information and
 functionality to Lua scripts via Haskell's @code{System} module.  Intended
 usage for this package is to preload it by adding the loader function to
 @code{package.preload}.  Note that the Lua @code{package} library must have
@@ -5767,21 +5524,18 @@ already been loaded before the loader can be added.")
 (define-public ghc-hslua-module-text
   (package
     (name "ghc-hslua-module-text")
-    (version "0.3.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hslua-module-text" version))
-       (sha256
-        (base32
-         "1vmd15n905i2pcsx748hz3h9kv5nnv74y663rj57q8mp0b40cbfl"))))
+    (version "1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-module-text" version))
+              (sha256
+               (base32
+                "0xq5ndgjhs37d73s8lvm0pndwjpj2pqb67pr0ckjap8yzhjna7fq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hslua-module-text")))
-    (inputs
-     (list ghc-hslua))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-lua ghc-tasty-hunit))
-    (home-page "https://github.com/hslua/hslua-module-text")
+    (inputs (list ghc-hslua-core ghc-hslua-packaging ghc-hslua-marshalling))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua))
+    (home-page "https://github.com/hslua/hslua")
     (synopsis "Lua module for text")
     (description
      "This package provides a UTF-8 aware subset of Lua's @code{string} module
@@ -5792,28 +5546,23 @@ for Haskell.  The functions provided by this module are @code{upper},
 (define-public ghc-hsyaml
   (package
     (name "ghc-hsyaml")
-    (version "0.2.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "HsYAML" version))
-       (sha256
-        (base32
-         "10qzhsg789h37q22hm9p27dx4rhbykcbxp7p3pvkws8fr7ajgxv0"))))
+    (version "0.2.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "HsYAML" version))
+              (sha256
+               (base32
+                "0a7nbvpl4p8kwbbjfn1dj6s3fif5k8zhbckdvyz1k74pj3yb8ns6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "HsYAML")))
+    (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-quickcheck))
     (arguments
-     `(#:tests? #f ; TODO: Loops.
-       #:cabal-revision
-       ("2" "0f7867jfzlmlqnkv3fjrzjvvfzjlvhbm10kmg7n0qk69ic8grkbc")))
-;    (native-inputs
-;     `(("ghc-hsyaml" ,ghc-hsyaml)
-;       ("ghc-quickcheck" ,ghc-quickcheck)
-;       ("ghc-tasty" ,ghc-tasty)
-;       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+     `(#:cabal-revision ("1"
+                         "0jmbgrjywcblrd8k6zzv2b5givdz83f479y15v5gs0r93z25xpmv")))
     (home-page "https://github.com/haskell-hvr/HsYAML")
     (synopsis "Pure Haskell YAML 1.2 parser")
-    (description "This library provides a
+    (description
+     "This library provides a
 @url{http://yaml.org/spec/1.2/spec.html, YAML 1.2} parser implementation
 for Haskell.  Its features include:
 
@@ -5843,34 +5592,31 @@ for user-defined custom schemas).
 (define-public ghc-http-api-data
   (package
     (name "ghc-http-api-data")
-    (version "0.4.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "http-api-data" version))
-       (sha256
-        (base32
-         "0xzfvxxh33ivlnrnzmm19cni3jgb5ph18n9hykkw3d6l3rhwzcnl"))))
+    (version "0.4.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "http-api-data" version))
+              (sha256
+               (base32
+                "171bw2a44pg50d3y77gw2y9vmx72laky7hnn5hw6r93pnjmlf9yz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "http-api-data")))
     (inputs (list ghc-attoparsec
                   ghc-attoparsec-iso8601
+                  ghc-base-compat
                   ghc-cookie
                   ghc-hashable
                   ghc-http-types
+                  ghc-tagged
                   ghc-time-compat
                   ghc-unordered-containers
                   ghc-uuid-types))
-    (native-inputs
-     (list cabal-doctest
-           ghc-nats
-           ghc-hunit
-           ghc-hspec
-           ghc-quickcheck
-           ghc-quickcheck-instances
-           ghc-doctest
-           hspec-discover))
-    (home-page "https://github.com/fizruk/http-api-data")
+    (native-inputs (list ghc-hunit ghc-hspec ghc-quickcheck
+                         ghc-quickcheck-instances hspec-discover))
+    (arguments
+     `(#:cabal-revision ("6"
+                         "0q4rhz81r5v0z1mn7x9q0ldbfv1a2cp3dpw8s2j96halsq34l4zl")))
+    (home-page "http://github.com/fizruk/http-api-data")
     (synopsis "Convert to/from HTTP API data like URL pieces, headers and
 query parameters")
     (description "This Haskell package defines typeclasses used for converting
@@ -5968,19 +5714,18 @@ license from a given license file.")
 (define-public ghc-ini
   (package
     (name "ghc-ini")
-    (version "0.4.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ini" version))
-       (sha256
-        (base32 "0mvwii8jbh2ll54qb9dij5m66c6324s2y4vrwz1qr4wz40m3qa8l"))))
+    (version "0.4.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ini" version))
+              (sha256
+               (base32
+                "0dp9c48vli8z6058yajnqg9hyf9swglk8ga4wcwl03aal7n8r7gp"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ini")))
+    (inputs (list ghc-attoparsec ghc-unordered-containers))
     (native-inputs (list ghc-hspec))
-    (inputs
-     (list ghc-attoparsec ghc-unordered-containers))
-    (home-page "https://github.com/chrisdone/ini")
+    (home-page "https://github.com/andreasabel/ini")
     (synopsis
      "Haskell library to easily handle configuration files in the INI format")
     (description
@@ -5991,23 +5736,24 @@ read and write configuration files in the simple INI format.")
 (define-public ghc-inline-c
   (package
     (name "ghc-inline-c")
-    (version "0.9.1.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "inline-c" version))
-       (sha256
-        (base32
-         "0a0m3bhh910c5g46cwkxgflsgw5ab7lzymwll9hijyvwgnsw3h7i"))))
+    (version "0.9.1.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "inline-c" version))
+              (sha256
+               (base32
+                "06az494fp2nh6fnibq28yw8jsrpj4jq1swyx53a328qv04cbhrym"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "inline-c")))
-    (inputs
-     (list ghc-ansi-wl-pprint ghc-hashable ghc-parsers
-           ghc-unordered-containers ghc-vector))
-    (native-inputs
-     (list ghc-quickcheck ghc-hspec ghc-raw-strings-qq ghc-regex-posix
-           ghc-split))
-    (home-page "https://hackage.haskell.org/package/inline-c")
+    (inputs (list ghc-ansi-wl-pprint ghc-hashable ghc-parsers
+                  ghc-unordered-containers ghc-vector))
+    (native-inputs (list ghc-quickcheck
+                         ghc-hspec
+                         ghc-quickcheck
+                         ghc-raw-strings-qq
+                         ghc-regex-posix
+                         ghc-split))
+    (home-page "http://hackage.haskell.org/package/inline-c")
     (synopsis "Write Haskell source files including C code inline")
     (description
      "inline-c lets you seamlessly call C libraries and embed high-performance
@@ -6019,21 +5765,18 @@ minimal overhead.  No FFI required.")
 (define-public ghc-inline-c-cpp
   (package
     (name "ghc-inline-c-cpp")
-    (version "0.4.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "inline-c-cpp" version))
-       (sha256
-        (base32
-         "0bqrhyic3cw1pqg7knsmkqx5swpr4kvf9bmz0mhmqbl6brmv5il0"))))
+    (version "0.5.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "inline-c-cpp" version))
+              (sha256
+               (base32
+                "0m14nb9brpnh2cgq8gg6182mdcmn45hf734la68dnhq23sn63lpx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "inline-c-cpp")))
-    (inputs
-     (list ghc-inline-c ghc-safe-exceptions))
-    (native-inputs
-     (list ghc-hspec))
-    (home-page "https://hackage.haskell.org/package/inline-c-cpp")
+    (inputs (list ghc-inline-c ghc-safe-exceptions))
+    (native-inputs (list ghc-hspec ghc-vector))
+    (home-page "http://hackage.haskell.org/package/inline-c-cpp")
     (synopsis "Lets you embed C++ code into Haskell")
     (description
      "This package provides utilities to inline C++ code into Haskell using
@@ -6053,7 +5796,6 @@ minimal overhead.  No FFI required.")
          "0zzapclfabc76g8jzsbsqwdllx2zn0gp4raq076ib6v0mfgry2lv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "integer-logarithms")))
-    (arguments `(#:tests? #f)) ; TODO: Needs tasty<1.4
     (native-inputs
      (list ghc-quickcheck
            ghc-smallcheck
@@ -6061,6 +5803,17 @@ minimal overhead.  No FFI required.")
            ghc-tasty-hunit
            ghc-tasty-quickcheck
            ghc-tasty-smallcheck))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0z81yksgx20d0rva41blsjcp3jsp1qy9sy385fpig0l074fzv6ym")
+       #:phases
+       (modify-phases %standard-phases
+         ;; Needs tasty<1.4
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "integer-logarithms.cabal"
+               (("(tasty)\\s+[^,]+" all dep)
+                dep)))))))
     (home-page "https://github.com/Bodigrim/integer-logarithms")
     (synopsis "Integer logarithms")
     (description
@@ -6153,32 +5906,32 @@ which represets a closed, convex set of floating point values.")
 (define-public ghc-invariant
   (package
     (name "ghc-invariant")
-    (version "0.5.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "invariant" version))
-       (sha256
-        (base32
-         "1jlp0gbfjsx7k08275djh8m3v4rpg8llw5gdkg9s9qfx0lc0mymr"))))
+    (version "0.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "invariant" version))
+              (sha256
+               (base32
+                "07ffgcfpacsdihcmcmx2m1gp8czlg28657bxncxjykjiiiwjlaxm"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "invariant")))
-    (inputs
-     (list ghc-bifunctors
-           ghc-comonad
-           ghc-contravariant
-           ghc-profunctors
-           ghc-semigroups
-           ghc-statevar
-           ghc-tagged
-           ghc-th-abstraction
-           ghc-transformers-compat
-           ghc-unordered-containers))
-    (native-inputs
-     (list ghc-hspec ghc-quickcheck hspec-discover))
+    (inputs (list ghc-bifunctors
+                  ghc-comonad
+                  ghc-contravariant
+                  ghc-profunctors
+                  ghc-statevar
+                  ghc-tagged
+                  ghc-th-abstraction
+                  ghc-transformers-compat
+                  ghc-unordered-containers))
+    (native-inputs (list ghc-hspec ghc-quickcheck hspec-discover))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0551ll1swnrmq09j89jqnxl4qnirbbpdpsdym23adaf36qdd7v37")))
     (home-page "https://github.com/nfrisby/invariant-functors")
     (synopsis "Haskell98 invariant functors")
-    (description "Haskell98 invariant functors (also known as exponential
+    (description
+     "Haskell98 invariant functors (also known as exponential
 functors).  For more information, see Edward Kmett's article
 @uref{http://comonad.com/reader/2008/rotten-bananas/, Rotten Bananas}.")
     (license license:bsd-2)))
@@ -6186,31 +5939,24 @@ functors).  For more information, see Edward Kmett's article
 (define-public ghc-io-streams
   (package
     (name "ghc-io-streams")
-    (version "1.5.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "io-streams" version))
-       (sha256
-        (base32
-         "1y3sqmxrwiksz7pl4hf3vzvg8p8n00qnv98nj5xbpcadlh468rny"))))
+    (version "1.5.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "io-streams" version))
+              (sha256
+               (base32
+                "1zn4iyd18g9jc1qdgixp6hi56nj7czy4jdz2xca59hcn2q2xarfk"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "io-streams")))
-    (inputs
-     (list ghc-attoparsec
-           ghc-bytestring-builder
-           ghc-network
-           ghc-primitive
-           ghc-vector
-           ghc-zlib-bindings))
-    (native-inputs
-     (list ghc-hunit
-           ghc-quickcheck
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2
-           ghc-zlib))
-    (home-page "https://hackage.haskell.org/package/io-streams")
+    (inputs (list ghc-attoparsec ghc-primitive ghc-vector ghc-zlib-bindings
+                  ghc-network))
+    (native-inputs (list ghc-zlib
+                         ghc-hunit
+                         ghc-quickcheck
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2))
+    (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.")
@@ -6230,8 +5976,8 @@ primitives for I/O using streams.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "io-streams-haproxy")))
     (arguments
-     `(#:cabal-revision
-       ("3" "02k9halblgnynlm781ahc81yxla8z7cck1gikm8555v78rf5hv7x")))
+     `(#:cabal-revision ("6"
+                         "024aw98q1x3fb1xq07qki3z446w6lk5gyjl13shy0dbrd5aafh92")))
     (inputs
      (list ghc-attoparsec ghc-io-streams ghc-network))
     (native-inputs
@@ -6248,23 +5994,22 @@ through a forwarding proxy that is configured to speak this protocol.")
 (define-public ghc-iproute
   (package
     (name "ghc-iproute")
-    (version "1.7.11")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "iproute" version))
-       (sha256
-        (base32
-         "12wa59b1zgjqp8dmygq2x44ml0cb89fhn1k0zkj4aqz7rhkwsp90"))))
+    (version "1.7.12")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "iproute" version))
+              (sha256
+               (base32
+                "0qvb4d7nw8f6j4s09cnpn6z1rdwcwknwklfrhsgivg7wg4aisxgi"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "iproute")))
-    (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
-                               ; exported by ghc-byteorder.  Doctest issue.
-    (inputs
-     (list ghc-appar ghc-byteorder ghc-network ghc-safe))
-    (home-page "https://www.mew.org/~kazu/proj/iproute/")
+    (inputs (list ghc-appar ghc-byteorder ghc-network ghc-semigroups))
+    (native-inputs (list ghc-doctest ghc-hspec ghc-quickcheck ghc-safe
+                         hspec-discover))
+    (home-page "http://www.mew.org/~kazu/proj/iproute/")
     (synopsis "IP routing table")
-    (description "IP Routing Table is a tree of IP ranges to search one of
+    (description
+     "IP Routing Table is a tree of IP ranges to search one of
 them on the longest match base.  It is a kind of TRIE with one way branching
 removed.  Both IPv4 and IPv6 are supported.")
     (license license:bsd-3)))
@@ -6272,24 +6017,26 @@ removed.  Both IPv4 and IPv6 are supported.")
 (define-public ghc-ipynb
   (package
     (name "ghc-ipynb")
-    (version "0.1.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ipynb" version))
-       (sha256
-        (base32
-         "0qky4l5aaiq7ypwbxh0mr7s572290fi596f18dg68qpyzc49a9kx"))))
+    (version "0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ipynb" version))
+              (sha256
+               (base32
+                "1iwia4sxg40m4d290gys72wabqmkqx24ywsaranwzk2wx5s3sx4s"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ipynb")))
-    (inputs
-     (list ghc-unordered-containers ghc-base64-bytestring ghc-aeson
-           ghc-semigroups))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit ghc-microlens-aeson ghc-microlens))
-    (home-page "https://hackage.haskell.org/package/ipynb")
+    (inputs (list ghc-unordered-containers ghc-base64-bytestring ghc-aeson
+                  ghc-semigroups))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-microlens-aeson
+                         ghc-microlens))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0fl9x5amq0g5dg57dcgc0g4ir0r1fdbx06aldsqdwzdc9zs97v6k")))
+    (home-page "http://hackage.haskell.org/package/ipynb")
     (synopsis "Data structure for working with Jupyter notebooks")
-    (description "This library defines a data structure for representing
+    (description
+     "This library defines a data structure for representing
 Jupyter notebooks, along with @code{ToJSON} and @code{FromJSON}
 instances for conversion to and from JSON .ipynb files.")
     (license license:bsd-3)))
@@ -6346,18 +6093,16 @@ Notation, JSON} is a lightweight data-interchange format.")
 (define-public ghc-juicypixels
   (package
     (name "ghc-juicypixels")
-    (version "3.3.6")
+    (version "3.3.7")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "JuicyPixels" version))
               (sha256
                (base32
-                "1f8giivsqxma19ax78dr7j4gir12iyfqn2mlsd27zzl8dn7dy6w1"))))
+                "1rrvapzcj0q8sigxq1zq2k4h88i1r2hyca4p7pkqa1b4pk6vhdny"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "JuicyPixels")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-zlib ghc-vector ghc-primitive))
+    (inputs (list ghc-zlib ghc-vector ghc-primitive))
     (home-page "https://github.com/Twinside/Juicy.Pixels")
     (synopsis "Picture loading and serialization library")
     (description
@@ -6368,29 +6113,29 @@ TIFF and GIF formats.")
 (define-public ghc-kan-extensions
   (package
     (name "ghc-kan-extensions")
-    (version "5.2.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "kan-extensions" version))
-       (sha256
-        (base32
-         "1rkjxwc2k2425d2shdra6wzd4f4dpj76hxmq8mish4f0lz9gxxml"))))
+    (version "5.2.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "kan-extensions" version))
+              (sha256
+               (base32
+                "08mddsk9v75mahp1jqn28vglygmdil1g37drcj3ivbqc0k6dq55r"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "kan-extensions")))
-    (inputs
-     (list ghc-adjunctions
-           ghc-comonad
-           ghc-contravariant
-           ghc-distributive
-           ghc-free
-           ghc-invariant
-           ghc-semigroupoids
-           ghc-tagged
-           ghc-transformers-compat))
-    (home-page "https://github.com/ekmett/kan-extensions/")
+    (inputs (list ghc-adjunctions
+                  ghc-comonad
+                  ghc-contravariant
+                  ghc-distributive
+                  ghc-invariant
+                  ghc-free
+                  ghc-profunctors
+                  ghc-semigroupoids
+                  ghc-tagged
+                  ghc-transformers-compat))
+    (home-page "http://github.com/ekmett/kan-extensions/")
     (synopsis "Kan extensions library")
-    (description "This library provides Kan extensions, Kan lifts, various
+    (description
+     "This library provides Kan extensions, Kan lifts, various
 forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
     (license license:bsd-3)))
 
@@ -6483,73 +6228,67 @@ with @code{wc} (for a web service).")
 (define-public ghc-lens
   (package
     (name "ghc-lens")
-    (version "4.19.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lens" version))
-       (sha256
-        (base32
-         "0fy2vr5r11cc6ana8m2swqgs3zals4kims55vd6119bi76p5iy2j"))))
+    (version "5.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lens" version))
+              (sha256
+               (base32
+                "08mkm2mjvhmwg9hc4kd4cd6dgmcszs1p2mzp1nmri7lqbpy9jknc"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lens")))
+    (inputs (list ghc-assoc
+                  ghc-base-orphans
+                  ghc-bifunctors
+                  ghc-call-stack
+                  ghc-comonad
+                  ghc-contravariant
+                  ghc-distributive
+                  ghc-free
+                  ghc-hashable
+                  ghc-indexed-traversable
+                  ghc-indexed-traversable-instances
+                  ghc-kan-extensions
+                  ghc-parallel
+                  ghc-profunctors
+                  ghc-reflection
+                  ghc-semigroupoids
+                  ghc-strict
+                  ghc-tagged
+                  ghc-th-abstraction
+                  ghc-these
+                  ghc-transformers-compat
+                  ghc-unordered-containers
+                  ghc-vector))
+    (native-inputs (list ghc-quickcheck
+                         ghc-test-framework
+                         ghc-test-framework-quickcheck2
+                         ghc-hunit
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-simple-reflect))
     (arguments
-     `(#:tests? #f ; TODO: Needs vector<0.12.2
-       #:cabal-revision
-       ("6" "1k08my9rh1il3ibiyhljxkgndfgk143pn5a6nyzjnckw3la09myl")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-base-orphans
-           ghc-bifunctors
-           ghc-distributive
-           ghc-exceptions
-           ghc-free
-           ghc-kan-extensions
-           ghc-parallel
-           ghc-reflection
-           ghc-semigroupoids
-           ghc-vector
-           ghc-call-stack
-           ghc-comonad
-           ghc-contravariant
-           ghc-hashable
-           ghc-profunctors
-           ghc-semigroups
-           ghc-tagged
-           ghc-transformers-compat
-           ghc-unordered-containers
-           ghc-void
-           ghc-generic-deriving
-           ghc-nats
-           ghc-simple-reflect
-           hlint))
-    (native-inputs
-     (list cabal-doctest
-           ghc-doctest
-           ghc-hunit
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2
-           ghc-quickcheck))
-    (home-page "https://github.com/ekmett/lens/")
+     `(#:cabal-revision ("1"
+                         "19z3k7ikpfa96b86yabxghfqpnq9d0ayy4gdlvci3ycvws0s8cy6")))
+    (home-page "http://github.com/ekmett/lens/")
     (synopsis "Lenses, Folds and Traversals")
-    (description "This library provides @code{Control.Lens}.  The combinators
+    (description
+     "This library provides @code{Control.Lens}.  The combinators
 in @code{Control.Lens} provide a highly generic toolbox for composing families
 of getters, folds, isomorphisms, traversals, setters and lenses and their
 indexed variants.")
-    (license license:bsd-3)))
+    (license license:bsd-2)))
 
 (define-public ghc-lens-family-core
   (package
     (name "ghc-lens-family-core")
-    (version "2.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lens-family-core" version))
-       (sha256
-        (base32
-         "0ni6s873hy2h3b316835ssmlyr05yinb3a8jq5b01p9ppp9zrd0r"))))
+    (version "2.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lens-family-core" version))
+              (sha256
+               (base32
+                "1dkkd33wh2ykgis92dpshjxz6d2d41dvjj4zz6b7mdy8frr9jnhv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lens-family-core")))
     (home-page
@@ -6576,19 +6315,16 @@ lenses and traversals for those who require Haskell 98.")
 (define-public ghc-libffi
   (package
     (name "ghc-libffi")
-    (version "0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "libffi" version))
-       (sha256
-        (base32
-         "0g7jnhng3j7z5517aaqga0144aamibsbpgm3yynwyfzkq1kp0f28"))))
+    (version "0.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "libffi" version))
+              (sha256
+               (base32
+                "1w9ssmjx521f4lmaynmh1zargl2zmfvvpq2bldsvnwldfdgikbkn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "libffi")))
-    (native-inputs (list pkg-config))
-    (inputs (list libffi))
-    (home-page "https://hackage.haskell.org/package/libffi")
+    (home-page "http://haskell.org/haskellwiki/Library/libffi")
     (synopsis "Haskell binding to libffi")
     (description
      "A binding to libffi, allowing C functions of types only known at runtime
@@ -6622,22 +6358,21 @@ Music Player Daemon.")
 (define-public ghc-lib-parser
   (package
     (name "ghc-lib-parser")
-    (version "8.10.7.20210828")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ghc-lib-parser" version))
-       (sha256
-        (base32
-         "178v4f7q9ndqmlhg2vhlk6ifm3ilajlrz8iw84vggzs7rp0fnlx0"))))
+    (version "9.2.5.20221107")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ghc-lib-parser" version))
+              (sha256
+               (base32
+                "1xh8rm5lwbh96g4v34whkcbb1yjsyvx3rwwycj30lrglhqk7f4c4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ghc-lib-parser")))
     (outputs '("out" "static" "doc")) ; documentation is 39M
-    (native-inputs
-     (list ghc-alex ghc-happy))
+    (native-inputs (list ghc-alex ghc-happy))
     (home-page "https://github.com/digital-asset/ghc-lib")
     (synopsis "The GHC API, decoupled from GHC versions")
-    (description "This library implements the GHC API.  It is like the
+    (description
+     "This library implements the GHC API.  It is like the
 compiler-provided @code{ghc} package, but it can be loaded on many
 compiler versions.")
     (license license:bsd-3)))
@@ -6701,29 +6436,27 @@ LibYAML C library.")
 (define-public ghc-lifted-async
   (package
     (name "ghc-lifted-async")
-    (version "0.10.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lifted-async" version))
-       (sha256
-        (base32
-         "0j4f5471qfxkxy84ri87bcvp30ikh4m30imcggwn8m5v8igp218d"))))
+    (version "0.10.2.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lifted-async" version))
+              (sha256
+               (base32
+                "1kq96cp9czf358gykai2vcmynnd7zivqja4pb3f8bif9ypln9vai"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lifted-async")))
-    (inputs
-     (list ghc-async
-           ghc-lifted-base
-           ghc-transformers-base
-           ghc-monad-control
-           ghc-constraints
-           ghc-hunit
-           ghc-tasty
-           ghc-tasty-expected-failure
-           ghc-tasty-hunit
-           ghc-tasty-th))
+    (inputs (list ghc-async ghc-lifted-base ghc-transformers-base
+                  ghc-monad-control ghc-constraints))
+    (native-inputs (list ghc-hunit
+                         ghc-tasty
+                         ghc-tasty-expected-failure
+                         ghc-tasty-hunit
+                         ghc-tasty-th
+                         ghc-tasty-hunit
+                         ghc-tasty-th))
     (home-page "https://github.com/maoe/lifted-async")
-    (synopsis "Run lifted IO operations asynchronously and wait for their results")
+    (synopsis
+     "Run lifted IO operations asynchronously and wait for their results")
     (description
      "This package provides IO operations from @code{async} package lifted to any
 instance of @code{MonadBase} or @code{MonadBaseControl}.")
@@ -6758,40 +6491,35 @@ Kaseorg.")
 (define-public ghc-linear
   (package
     (name "ghc-linear")
-    (version "1.21.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "linear" version))
-       (sha256
-        (base32
-         "0ax6prmc7b53w0lz5ddc40wrjj9bm7wldpp57283gx9hdf8qrb35"))))
+    (version "1.21.10")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "linear" version))
+              (sha256
+               (base32
+                "1d3s1p4imkifn7dccqci2qiwcg99x22kf250hzh4fh4xghi361xr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "linear")))
-    (inputs
-     (list ghc-adjunctions
-           ghc-base-orphans
-           ghc-bytes
-           ghc-cereal
-           ghc-distributive
-           ghc-hashable
-           ghc-lens
-           ghc-reflection
-           ghc-semigroups
-           ghc-semigroupoids
-           ghc-tagged
-           ghc-transformers-compat
-           ghc-unordered-containers
-           ghc-vector
-           ghc-void))
-    (native-inputs
-     (list cabal-doctest
-           ghc-doctest
-           ghc-simple-reflect
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-hunit))
-    (home-page "https://github.com/ekmett/linear/")
+    (inputs (list ghc-adjunctions
+                  ghc-base-orphans
+                  ghc-bytes
+                  ghc-cereal
+                  ghc-distributive
+                  ghc-hashable
+                  ghc-indexed-traversable
+                  ghc-lens
+                  ghc-random
+                  ghc-reflection
+                  ghc-semigroups
+                  ghc-semigroupoids
+                  ghc-tagged
+                  ghc-transformers-compat
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-void))
+    (native-inputs (list ghc-simple-reflect ghc-test-framework
+                         ghc-test-framework-hunit ghc-hunit))
+    (home-page "http://github.com/ekmett/linear/")
     (synopsis "Linear algebra library for Haskell")
     (description
      "This package provides types and combinators for linear algebra on free
@@ -6801,28 +6529,21 @@ vector spaces.")
 (define-public ghc-listlike
   (package
     (name "ghc-listlike")
-    (version "4.7.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri
-        (hackage-uri "ListLike" version))
-       (sha256
-        (base32
-         "08jip0q2f9qc95wcqka2lrqpf8r7sswsi5104w73kyrbmfirqnrd"))))
+    (version "4.7.8")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ListLike" version))
+              (sha256
+               (base32
+                "1l9pfjy7gh7xqnzflixp37d6lsppmlffzmmq75xn9r8ij3r2jycs"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ListLike")))
-    (inputs
-     (list ghc-vector
-           ghc-dlist
-           ghc-fmlist
-           ghc-hunit
-           ghc-quickcheck
-           ghc-random
-           ghc-utf8-string))
-    (home-page "https://github.com/JohnLato/listlike")
+    (inputs (list ghc-vector ghc-dlist ghc-fmlist ghc-utf8-string))
+    (native-inputs (list ghc-hunit ghc-quickcheck ghc-random))
+    (home-page "http://github.com/ddssff/listlike")
     (synopsis "Generic support for list-like structures")
-    (description "The ListLike module provides a common interface to the
+    (description
+     "The ListLike module provides a common interface to the
 various Haskell types that are list-like.  Predefined interfaces include
 standard Haskell lists, Arrays, ByteStrings, and lazy ByteStrings.
 Custom types can easily be made ListLike instances as well.
@@ -6832,105 +6553,54 @@ ByteString, for types that support input and output, and for types that
 can handle infinite lists.")
     (license license:bsd-3)))
 
-(define-public ghc-llvm-hs-pure
-  (package
-    (name "ghc-llvm-hs-pure")
-    (version "9.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "llvm-hs-pure" version))
-       (sha256
-        (base32
-         "0pxb5ah8r5pzpz2ibqw3g9g1isigb4z7pbzfrwr8kmcjn74ab3kf"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "llvm-hs-pure")))
-    (inputs
-     (list ghc-attoparsec ghc-fail ghc-unordered-containers))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck))
-    (home-page "https://github.com/llvm-hs/llvm-hs/")
-    (synopsis "Pure Haskell LLVM functionality (no FFI)")
-    (description "llvm-hs-pure is a set of pure Haskell types and functions
-for interacting with LLVM.  It includes an algebraic datatype (ADT) to represent
-LLVM IR.  The llvm-hs package builds on this one with FFI bindings to LLVM, but
-llvm-hs-pure does not require LLVM to be available.")
-    (license license:bsd-3)))
-
-(define-public ghc-llvm-hs
-  (package
-    (name "ghc-llvm-hs")
-    (version "9.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "llvm-hs" version))
-       (sha256
-        (base32
-         "0723xgh45h9cyxmmjsvxnsp8bpn1ljy4qgh7a7vqq3sj9d6wzq00"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "llvm-hs")))
-    (inputs
-     (list ghc-attoparsec ghc-exceptions ghc-utf8-string ghc-llvm-hs-pure
-           llvm-9))
-    (native-inputs
-     (list ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck
-           ghc-quickcheck
-           ghc-temporary
-           ghc-pretty-show
-           ghc-temporary))
-    (home-page "https://github.com/llvm-hs/llvm-hs/")
-    (synopsis "General purpose LLVM bindings for Haskell")
-    (description "llvm-hs is a set of Haskell bindings for LLVM.  Unlike other
-current Haskell bindings, it uses an algebraic datatype (ADT) to represent LLVM
-IR, and so offers two advantages: it handles almost all of the stateful
-complexities of using the LLVM API to build IR; and it supports moving IR not
-only from Haskell into LLVM C++ objects, but the other direction - from LLVM C++
-into Haskell.")
-    (license license:bsd-3)))
-
 (define-public ghc-logging-facade
   (package
     (name "ghc-logging-facade")
-    (version "0.3.0")
+    (version "0.3.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "logging-facade" version))
               (sha256
                (base32
-                "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf"))))
+                "0rn12j77gn3p84khrmbn5kq6fyj44i3z1hrdm29apikp7csv65ib"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "logging-facade")))
-    (native-inputs
-     (list ghc-hspec hspec-discover))
-    (home-page "https://hackage.haskell.org/package/logging-facade")
+    ;(arguments (list #:tests? #f))
+    (inputs (list ghc-call-stack))
+    (native-inputs (list ghc-hspec hspec-discover))
+    (home-page "https://github.com/sol/logging-facade#readme")
     (synopsis "Simple logging abstraction that allows multiple back-ends")
     (description
      "This package provides a simple logging abstraction that allows multiple
 back-ends.")
     (license license:expat)))
 
+(define-public ghc-logging-facade-bootstrap
+  (package
+    (inherit ghc-logging-facade)
+    (name "ghc-logging-facade-bootstrap")
+    (arguments `(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
 (define-public ghc-logict
   (package
     (name "ghc-logict")
-    (version "0.7.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "logict" version))
-       (sha256
-        (base32
-         "1d22b7r8lnak5k8ars166cxbk1lv7gf8g0qs604irsx2s474ybi7"))))
+    (version "0.8.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "logict" version))
+              (sha256
+               (base32
+                "0mpv50ifb3x9vfmgi1p9piwcgz8d19x0wdj789wxyhxwjpr6v4py"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "logict")))
     (inputs (list ghc-fail))
-    (native-inputs
-     (list ghc-async ghc-tasty ghc-tasty-hunit))
-    (home-page "http://code.haskell.org/~dolio/")
+    (native-inputs (list ghc-async ghc-tasty ghc-tasty-hunit))
+    (home-page "https://github.com/Bodigrim/logict#readme")
     (synopsis "Backtracking logic-programming monad")
-    (description "This library provides a continuation-based, backtracking,
+    (description
+     "This library provides a continuation-based, backtracking,
 logic programming monad.  An adaptation of the two-continuation implementation
 found in the paper \"Backtracking, Interleaving, and Terminating Monad
 Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
@@ -6940,28 +6610,24 @@ online}.")
 (define-public ghc-lucid
   (package
     (name "ghc-lucid")
-    (version "2.9.12.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lucid" version))
-       (sha256
-        (base32
-         "0nky4pqxd6828kg3js90ks6r3hxs5x48ibfz37pw2dr7y1nygq21"))))
+    (version "2.11.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lucid" version))
+              (sha256
+               (base32
+                "13krwrvv0w24rnl7pc7qhv18c6030fkxpx7sxkffdm8sr9173xfw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lucid")))
-    (inputs
-     (list ghc-blaze-builder ghc-hashable ghc-mmorph
-           ghc-unordered-containers))
-    (native-inputs
-     (list ghc-hunit ghc-hspec ghc-bifunctors))
+    (inputs (list ghc-blaze-builder ghc-hashable ghc-mmorph))
+    (native-inputs (list ghc-hunit ghc-hspec ghc-bifunctors))
     (arguments
-     `(#:cabal-revision
-       ("1"
-        "1xllyf26ypk37k807g5v6fl1449mhpvk18dljmqgwj723n0v8rpj")))
+     `(#:cabal-revision ("1"
+                         "0wipmh3xcs00x8lbq5j780rdc2klfj67nzni21qc1pdbhr2whn9d")))
     (home-page "https://github.com/chrisdone/lucid")
     (synopsis "Haskell DSL for rendering HTML")
-    (description "Clear to write, read and edit Haskell DSL for HTML.
+    (description
+     "Clear to write, read and edit Haskell DSL for HTML.
 
 @itemize @bullet
 @item
@@ -6976,23 +6642,17 @@ Same combinator can be used for attributes and elements
 (define-public ghc-lzma
   (package
     (name "ghc-lzma")
-    (version "0.0.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lzma" version))
-       (sha256
-        (base32
-         "0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg"))))
+    (version "0.0.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lzma" version))
+              (sha256
+               (base32
+                "0fy11i7fanrsbh8w7cclwx0i6csn5df6vl38dh2112aqw6n7h382"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lzma")))
-    (arguments
-     '(#:tests? #f ; requires older versions of QuickCheck and tasty.
-       #:cabal-revision
-       ("6" "1sh2g5wkh0m6646cxnii0k20f0crwdcnprfl9jfg7gxn5875bkip")))
-    (native-inputs
-     (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit
-           ghc-tasty-quickcheck))
+    (native-inputs (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
     (home-page "https://github.com/hvr/lzma")
     (synopsis "LZMA/XZ compression and decompression")
     (description
@@ -7004,26 +6664,23 @@ monadic incremental interface is provided as well.")
 (define-public ghc-lzma-conduit
   (package
     (name "ghc-lzma-conduit")
-    (version "1.2.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lzma-conduit" version))
-       (sha256
-        (base32
-         "1z6q16hzp2r5a4gdbg9akky5l9bfarzzhzswrgvh0v28ax400whb"))))
+    (version "1.2.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lzma-conduit" version))
+              (sha256
+               (base32
+                "1pmvmchrg429b2yk485x0066lxcr37cbyczlyp3ala2iaq8hm61z"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lzma-conduit")))
-    (inputs
-     (list ghc-conduit ghc-lzma ghc-resourcet))
-    (native-inputs
-     (list ghc-base-compat
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2
-           ghc-hunit
-           ghc-quickcheck))
-    (home-page "https://github.com/alphaHeavy/lzma-conduit")
+    (inputs (list ghc-conduit ghc-lzma ghc-resourcet))
+    (native-inputs (list ghc-base-compat
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2
+                         ghc-hunit
+                         ghc-quickcheck))
+    (home-page "http://github.com/alphaHeavy/lzma-conduit")
     (synopsis "Conduit interface for lzma/xz compression")
     (description
      "This package provides a @code{Conduit} interface for the LZMA
@@ -7054,16 +6711,18 @@ than its name.")
 (define-public ghc-managed
   (package
     (name "ghc-managed")
-    (version "1.0.8")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "managed" version))
-       (sha256
-        (base32
-         "00wzfy9facwgimrilz7bxaigr79w10733h8zfgyhll644p2rnz38"))))
+    (version "1.0.9")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "managed" version))
+              (sha256
+               (base32
+                "0vx8aim8bcyyvxxnmi1xkbl3kwrvskjn99z3y8h458g7nsinsisd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "managed")))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "017h9533j7rlxlsf65ynxpva59yr0qwrdmvhp7if141i98ld4664")))
     (home-page "https://hackage.haskell.org/package/managed")
     (synopsis "Monad for managed values")
     (description
@@ -7144,20 +6803,16 @@ functions are often useful in statistical and numerical computing.")
 (define-public ghc-megaparsec
   (package
     (name "ghc-megaparsec")
-    (version "9.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "megaparsec" version))
-       (sha256
-        (base32
-         "00953zvxfyjibw8c1ssmixxh0cwn59pz24zbh6s34rk3v14vqa3j"))))
+    (version "9.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "megaparsec" version))
+              (sha256
+               (base32
+                "0d52dbcz9nlqkkfqfs9kck5kmvkfzf3628z4ik4gr7hbbkjh72x4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "megaparsec")))
-    (inputs
-     (list ghc-case-insensitive ghc-parser-combinators ghc-scientific))
-    (native-inputs
-     (list ghc-quickcheck ghc-hspec ghc-hspec-expectations hspec-discover))
+    (inputs (list ghc-case-insensitive ghc-parser-combinators ghc-scientific))
     (home-page "https://github.com/mrkkrp/megaparsec")
     (synopsis "Monadic parser combinators")
     (description
@@ -7169,19 +6824,20 @@ speed, flexibility, and quality of parse errors.")
 (define-public ghc-memory
   (package
     (name "ghc-memory")
-    (version "0.15.0")
+    (version "0.17.0")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "memory" version))
               (sha256
                (base32
-                "0a9mxcddnqn4359hk59d6l2zbh0vp154yb5vs1a8jw4l38n8kzz3"))))
+                "0yl3ivvn7i9wbx910b7bzj9c3g0jjjk91j05wj74qb5zx2yyf9rk"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "memory")))
-    (inputs
-     (list ghc-basement ghc-foundation))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
+    (inputs (list ghc-basement))
+    (native-inputs (list ghc-foundation))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1gybf726kz17jm1am0rphi0srmyqyza45y6jdqbq0b8sspm8kggb")))
     (home-page "https://github.com/vincenthz/hs-memory")
     (synopsis "Memory abstractions for Haskell")
     (description
@@ -7240,14 +6896,14 @@ stripped.  As the result, this package has no dependencies.")
 (define-public ghc-microlens-aeson
   (package
     (name "ghc-microlens-aeson")
-    (version "2.3.1")
+    (version "2.5.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "microlens-aeson" version))
        (sha256
         (base32
-         "074mzpk7av6i0xf7xy42jpzgljlmyw805md1vz4sqy85m99f0ikr"))))
+         "0h5q0b2b4y28llhq28mb28kpdv2iifz0qkbbhmrwrz2bs6arr3d2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "microlens-aeson")))
     (inputs
@@ -7269,20 +6925,20 @@ microlens.")
 (define-public ghc-microlens-ghc
   (package
     (name "ghc-microlens-ghc")
-    (version "0.4.13")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "microlens-ghc" version))
-       (sha256
-        (base32
-         "1r6x788br3f9rksj0dmk1nyh5mfvd9zzasclf1mi3rxhb7c0j926"))))
+    (version "0.4.13.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "microlens-ghc" version))
+              (sha256
+               (base32
+                "1258p84jj4kv6l71ijwjzpvzvqxxsqbvs5vrksi24mlf29gaxqi0"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "microlens-ghc")))
     (inputs (list ghc-microlens))
-    (home-page "https://github.com/monadfix/microlens")
+    (home-page "http://github.com/monadfix/microlens")
     (synopsis "Use @code{microlens} with GHC libraries like @code{array}")
-    (description "This library provides everything that @code{microlens}
+    (description
+     "This library provides everything that @code{microlens}
 provides plus instances to make @code{each}, @code{at}, and @code{ix}
 usable with arrays, @code{ByteString}, and containers.  This package is
 a part of the @uref{http://hackage.haskell.org/package/microlens,
@@ -7293,21 +6949,18 @@ microlens} family; see the readme
 (define-public ghc-microlens-mtl
   (package
     (name "ghc-microlens-mtl")
-    (version "0.2.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "microlens-mtl" version))
-       (sha256
-        (base32
-         "0ijy7xyd5lbc3calhcrhy8czkf3fjcxrv68p7kd2a5b352rfi7fp"))))
+    (version "0.2.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "microlens-mtl" version))
+              (sha256
+               (base32
+                "1ilz0zyyk9f6h97gjsaqq65njfs23fk3wxhigvj4z0brf7rnlssd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "microlens-mtl")))
-    (inputs
-     (list ghc-microlens ghc-transformers-compat))
-    (home-page "https://github.com/monadfix/microlens")
-    (synopsis
-     "@code{microlens} support for Reader/Writer/State from mtl")
+    (inputs (list ghc-microlens ghc-transformers-compat))
+    (home-page "http://github.com/monadfix/microlens")
+    (synopsis "@code{microlens} support for Reader/Writer/State from mtl")
     (description
      "This package contains functions (like @code{view} or @code{+=}) which
 work on @code{MonadReader}, @code{MonadWriter}, and @code{MonadState} from the
@@ -7319,25 +6972,23 @@ readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
 (define-public ghc-microlens-platform
   (package
     (name "ghc-microlens-platform")
-    (version "0.4.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "microlens-platform" version))
-       (sha256
-        (base32
-         "0yf0z0glq2d6mpclzswc64h9w2cck4fd8l8ffm89pyb0a5n8m4c7"))))
+    (version "0.4.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "microlens-platform" version))
+              (sha256
+               (base32
+                "0z8snyzy18kqj32fb89mzgscjrg6w2z0jkkj4b9vl2jvbps0gkg6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "microlens-platform")))
-    (inputs
-     (list ghc-hashable
-           ghc-microlens
-           ghc-microlens-ghc
-           ghc-microlens-mtl
-           ghc-microlens-th
-           ghc-unordered-containers
-           ghc-vector))
-    (home-page "https://github.com/monadfix/microlens")
+    (inputs (list ghc-hashable
+                  ghc-microlens
+                  ghc-microlens-ghc
+                  ghc-microlens-mtl
+                  ghc-microlens-th
+                  ghc-unordered-containers
+                  ghc-vector))
+    (home-page "http://github.com/monadfix/microlens")
     (synopsis "Feature-complete microlens")
     (description
      "This package exports a module which is the recommended starting point
@@ -7361,23 +7012,22 @@ readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
 (define-public ghc-microlens-th
   (package
     (name "ghc-microlens-th")
-    (version "0.4.3.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "microlens-th" version))
-       (sha256
-        (base32
-         "1dg2xhj85fy8q39m5dd94kjlabjyxgc0336vzkg0174l6l110l1c"))))
+    (version "0.4.3.11")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "microlens-th" version))
+              (sha256
+               (base32
+                "1vjjaclfxr0kvlpmj8zh7f6ci4n4b8vynqd67zszx42al7gal6pj"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "microlens-th")))
     (inputs (list ghc-microlens ghc-th-abstraction))
     (native-inputs (list ghc-tagged))
-    (home-page
-     "https://github.com/aelve/microlens")
+    (home-page "http://github.com/monadfix/microlens")
     (synopsis "Automatic generation of record lenses for
 @code{ghc-microlens}")
-    (description "This Haskell package lets you automatically generate lenses
+    (description
+     "This Haskell package lets you automatically generate lenses
 for data types; code was extracted from the lens package, and therefore
 generated lenses are fully compatible with ones generated by lens (and can be
 used both from lens and microlens).")
@@ -7386,36 +7036,26 @@ used both from lens and microlens).")
 (define-public ghc-missingh
   (package
     (name "ghc-missingh")
-    (version "1.4.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "MissingH" version))
-       (sha256
-        (base32
-         "196cniya5wzcv2d777nr0f7hinclpals4ia1mkzzv35870pqr6lw"))))
+    (version "1.5.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "MissingH" version))
+              (sha256
+               (base32
+                "0c92fdv32nq51kfdizi3lpxmnvscsgk6marfzaycd7k05aka8byb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "MissingH")))
+    (inputs (list ghc-hslogger
+                  ghc-old-locale
+                  ghc-old-time
+                  ghc-regex-compat
+                  ghc-network-bsd
+                  ghc-network))
+    (native-inputs (list ghc-hunit))
     (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "MissingH.cabal"
-               (("(random)\\s+[^,]+" all dep)
-                dep)))))))
-    (inputs
-     (list ghc-network
-           ghc-hunit
-           ghc-regex-compat
-           ghc-hslogger
-           ghc-random
-           ghc-old-time
-           ghc-old-locale))
-    (native-inputs
-     (list ghc-errorcall-eq-instance ghc-quickcheck ghc-hunit))
-    ;; ‘Official’ <http://software.complete.org/missingh> redirects to a 404.
-    (home-page "https://github.com/haskell-hvr/missingh")
+     `(#:cabal-revision ("2"
+                         "11d922r06p00gcgzhb29hhjkq8ajy1xbqdiwdpbmhp2ar7fw7g9l")))
+    (home-page "http://hackage.haskell.org/package/MissingH")
     (synopsis "Large utility library")
     (description
      "MissingH is a library of all sorts of utility functions for Haskell
@@ -7447,19 +7087,20 @@ do on-demand loading.")
 (define-public ghc-mmorph
   (package
     (name "ghc-mmorph")
-    (version "1.1.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "mmorph" version))
-       (sha256
-        (base32
-         "0bq9m3hlfax1826gg5yhih79x33rvfx59wdh8yf43azd7l74bys6"))))
+    (version "1.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "mmorph" version))
+              (sha256
+               (base32
+                "1022d8mm523dihkf85mqsqxpm9rnyicmv91c8rm4csv7xdc80cv1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "mmorph")))
-    (inputs
-     (list ghc-transformers-compat))
-    (home-page "https://hackage.haskell.org/package/mmorph")
+    (inputs (list ghc-transformers-compat ghc-fail))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "1582vcpjiyimb1vwnhgq8gp805iziwa8sivv2frir0cgq4z236yz")))
+    (home-page "http://hackage.haskell.org/package/mmorph")
     (synopsis "Monad morphisms")
     (description
      "This library provides monad morphism utilities, most commonly used for
@@ -7488,6 +7129,16 @@ manipulating monad transformer stacks.")
      "The mockery package provides support functions for automated testing.")
     (license license:expat)))
 
+(define-public ghc-mockery-bootstrap
+  (package
+    (inherit ghc-mockery)
+    (name "ghc-mockery-bootstrap")
+    (arguments `(#:tests? #f))
+    (inputs (modify-inputs (package-inputs ghc-mockery)
+              (replace "ghc-logging-facade" ghc-logging-facade-bootstrap)))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
 (define-public ghc-monad-control
   (package
     (name "ghc-monad-control")
@@ -7514,31 +7165,33 @@ a subset of @code{MonadBase} into which generic control operations such as
 (define-public ghc-monad-logger
   (package
     (name "ghc-monad-logger")
-    (version "0.3.36")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "monad-logger" version))
-       (sha256
-        (base32
-         "12rw0k01gkhiqjm2fhxgkmribksmizhj14xphfn8fkd86wzl0vbh"))))
+    (version "0.3.37")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "monad-logger" version))
+              (sha256
+               (base32
+                "1z275a428zcj73zz0cpfha2adwiwqqqp7klx3kbd3i9rl20xa106"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "monad-logger")))
-    (inputs (list ghc-transformers-compat
-                  ghc-stm-chans
-                  ghc-lifted-base
-                  ghc-resourcet
-                  ghc-conduit
+    (inputs (list ghc-conduit
                   ghc-conduit-extra
                   ghc-fast-logger
-                  ghc-transformers-base
+                  ghc-lifted-base
                   ghc-monad-control
                   ghc-monad-loops
-                  ghc-blaze-builder
-                  ghc-exceptions))
-    (home-page "https://github.com/kazu-yamamoto/logger")
+                  ghc-resourcet
+                  ghc-stm-chans
+                  ghc-transformers-base
+                  ghc-transformers-compat
+                  ghc-unliftio-core))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "1dzkw08b4ijacdw0vcfxlr13rd819x2yj7b6sr9jrrwicd45zm1z")))
+    (home-page "https://github.com/snoyberg/monad-logger#readme")
     (synopsis "Provides a class of monads which can log messages for Haskell")
-    (description "This Haskell package uses a monad transformer approach
+    (description
+     "This Haskell package uses a monad transformer approach
 for logging.
 
 This package provides Template Haskell functions for determining source
@@ -7635,6 +7288,9 @@ and other added capabilities layered on top of the @code{Par} monad.")
     (properties '((upstream-name . "MonadRandom")))
     (inputs (list ghc-transformers-compat ghc-primitive ghc-fail
                   ghc-random))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1diy29if7w1c9ckc465mrrb52fm0zmd8zzym1h5ryh5a58qafwhr")))
     (home-page "https://github.com/byorgey/MonadRandom")
     (synopsis "Random-number generation monad for Haskell")
     (description "This Haskell package provides support for computations
@@ -7693,21 +7349,20 @@ data structures as non-empty.")
 (define-public ghc-monoid-extras
   (package
     (name "ghc-monoid-extras")
-    (version "0.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "monoid-extras" version))
-       (sha256
-        (base32
-         "0ki1d3b1xpf653qj7brlqdgngghwrnmapy5gja75iiydfx2506a1"))))
+    (version "0.6.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "monoid-extras" version))
+              (sha256
+               (base32
+                "1qaxp0cf2cvzvfpk7x9mjz1zmlpjfzxij8v2n45w89s7bq9ckvlw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "monoid-extras")))
-    (inputs
-     (list ghc-groups ghc-semigroupoids))
-    (home-page "https://hackage.haskell.org/package/monoid-extras")
+    (inputs (list ghc-groups ghc-semigroupoids))
+    (home-page "http://hackage.haskell.org/package/monoid-extras")
     (synopsis "Various extra monoid-related definitions and utilities")
-    (description "This package provides various extra monoid-related
+    (description
+     "This package provides various extra monoid-related
 definitions and utilities, such as monoid actions, monoid coproducts,
 semi-direct products, \"deletable\" monoids, \"split\" monoids, and
 \"cut\" monoids.")
@@ -7769,16 +7424,16 @@ the top of your file to get all of the ExceptT instances in scope.")
 (define-public ghc-murmur-hash
   (package
     (name "ghc-murmur-hash")
-    (version "0.1.0.9")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "murmur-hash" version))
-       (sha256
-        (base32 "1bb58kfnzvx3mpc0rc0dhqc1fk36nm8prd6gvf20gk6lxaadpfc9"))))
+    (version "0.1.0.10")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "murmur-hash" version))
+              (sha256
+               (base32
+                "145z91zkx8jdd3y181pi8z9imqjgpk99cl55pbda4fl201hasbz9"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "murmur-hash")))
-    (home-page "https://github.com/nominolo/murmur-hash")
+    (home-page "http://github.com/nominolo/murmur-hash")
     (synopsis "MurmurHash2 implementation for Haskell")
     (description
      "This package provides an implementation of MurmurHash2, a good, fast,
@@ -7890,26 +7545,20 @@ ncurses.")
 (define-public ghc-network
   (package
     (name "ghc-network")
-    (version "3.1.1.1")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "network" version))
-       (sha256
-        (base32
-         "16ic2hgvadyiy0zfnyd2zknf8rxqmwzpy5mw5x9apwpzfc0mkvyp"))))
+    (version "3.1.2.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "network" version))
+              (sha256
+               (base32
+                "119xqsyj44ix0z79mzfpww0cd9936bki1xa7cwykvbx1y7z20xkz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "network")))
-    ;; The regression tests depend on an unpublished module.
-    (arguments `(#:tests? #f))
-    (native-inputs
-     (list ghc-hunit ghc-doctest ghc-test-framework
-           ghc-test-framework-hunit))
+    (native-inputs (list ghc-hunit ghc-temporary ghc-hspec ghc-quickcheck
+                         ghc-doctest hspec-discover))
     (home-page "https://github.com/haskell/network")
     (synopsis "Low-level networking interface")
-    (description
-     "This package provides a low-level networking interface.")
+    (description "This package provides a low-level networking interface.")
     (license license:bsd-3)))
 
 (define-public ghc-network-bsd
@@ -7960,19 +7609,19 @@ byte order.")
 (define-public ghc-network-info
   (package
     (name "ghc-network-info")
-    (version "0.2.0.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "network-info" version))
-       (sha256
-        (base32
-         "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n"))))
+    (version "0.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "network-info" version))
+              (sha256
+               (base32
+                "015lm3b8n8sb16qsffjxz1jvijyy0z600ch0sm8h6a685wqqhbcv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "network-info")))
-    (home-page "https://github.com/jystic/network-info")
+    (home-page "http://github.com/jacobstanley/network-info")
     (synopsis "Access the local computer's basic network configuration")
-    (description "This Haskell library provides simple read-only access to the
+    (description
+     "This Haskell library provides simple read-only access to the
 local computer's networking configuration.  It is currently capable of
 getting a list of all the network interfaces and their respective
 IPv4, IPv6 and MAC addresses.")
@@ -8008,26 +7657,22 @@ sending UDP datagrams over multicast (class D) addresses.")
 (define-public ghc-network-uri
   (package
     (name "ghc-network-uri")
-    (version "2.6.4.1")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "network-uri" version))
-       (sha256
-        (base32
-         "111m485rx2kyqdymi1x6sl08hi6lp34q3f41yqcx99086swnv1ap"))))
+    (version "2.6.4.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "network-uri" version))
+              (sha256
+               (base32
+                "0a3jg6aykwm1yw32nh137hi6r86w2640xwl1p18352bf29rqj64w"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "network-uri")))
-    (inputs
-     (list ghc-th-compat))
-    (native-inputs
-     (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit
-           ghc-tasty-quickcheck))
-    (home-page
-     "https://github.com/haskell/network-uri")
+    (inputs (list ghc-th-compat))
+    (native-inputs (list ghc-hunit ghc-tasty ghc-tasty-hunit
+                         ghc-tasty-quickcheck ghc-quickcheck))
+    (home-page "https://github.com/haskell/network-uri")
     (synopsis "Library for URI manipulation")
-    (description "This package provides an URI manipulation interface.  In
+    (description
+     "This package provides an URI manipulation interface.  In
 @code{network-2.6} the @code{Network.URI} module was split off from the
 @code{network} package into this package.")
     (license license:bsd-3)))
@@ -8035,21 +7680,23 @@ sending UDP datagrams over multicast (class D) addresses.")
 (define-public ghc-newtype-generics
   (package
     (name "ghc-newtype-generics")
-    (version "0.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "newtype-generics" version))
-       (sha256
-        (base32
-         "04bymwhkvlsgcsd0v630mndrzf0xnh3v81ba6nfzwcvbg3ksr2wa"))))
+    (version "0.6.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "newtype-generics" version))
+              (sha256
+               (base32
+                "0km7cp041bgdgrxrbrawz611mcylxp943880a2yg228a09961b51"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "newtype-generics")))
-    (native-inputs
-     (list ghc-hspec hspec-discover))
-    (home-page "https://github.com/sjakobi/newtype-generics")
+    (native-inputs (list ghc-hspec hspec-discover))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0xgc7sxs1p3qibgwbikjdrhn47j7m4gk5x1wrv9hncks6hd6hsyf")))
+    (home-page "http://github.com/sjakobi/newtype-generics")
     (synopsis "Typeclass and set of functions for working with newtypes")
-    (description "The @code{Newtype} typeclass represents the packing and
+    (description
+     "The @code{Newtype} typeclass represents the packing and
 unpacking of a newtype, and allows you to operate under that newtype with
 functions such as @code{ala}.  Generics support was added in version 0.4,
 making this package a full replacement for the original newtype package,
@@ -8132,19 +7779,19 @@ standard library.")
 (define-public ghc-objectname
   (package
     (name "ghc-objectname")
-    (version "1.1.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ObjectName" version))
-       (sha256
-        (base32
-         "046jm94rmm46cicd31pl54vdvfjvhd9ffbfycy2lxzc0fliyznvj"))))
+    (version "1.1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ObjectName" version))
+              (sha256
+               (base32
+                "0xdkfc97salzj5s3fvmwk4k0097dcd8c4xcr5ghhv9mz0wcxm9gz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ObjectName")))
-    (home-page "https://hackage.haskell.org/package/ObjectName")
+    (home-page "https://github.com/svenpanne/ObjectName")
     (synopsis "Helper library for Haskell OpenGL")
-    (description "This tiny package contains the class ObjectName, which
+    (description
+     "This tiny package contains the class ObjectName, which
 corresponds to the general notion of explicitly handled identifiers for API
 objects, e.g. a texture object name in OpenGL or a buffer object name in
 OpenAL.")
@@ -8241,8 +7888,8 @@ traditionally so named type-wrapper for attaching typeclass instances.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "OpenGL")))
     (arguments
-     `(#:cabal-revision
-       ("1" "1748mrb6r9mpf5jbrx436lwbg8w6dadyy8dhxw2dwnrj5z7zf741")))
+     `(#:cabal-revision ("2"
+                         "1nhlswxgxn8l1ysjq3fp3w5pvx6651d33036i8dlbqygzrn6iwmh")))
     (inputs
      (list ghc-objectname ghc-gluraw ghc-statevar ghc-openglraw))
     (home-page "https://wiki.haskell.org/Opengl")
@@ -8255,23 +7902,24 @@ version 1.3).")
 (define-public ghc-openglraw
   (package
     (name "ghc-openglraw")
-    (version "3.3.4.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "OpenGLRaw" version))
-       (sha256
-        (base32
-         "0gmsmysqzpm13qnyq4vvqxm4dzw25nayfd9wi5x645pympm6jqbm"))))
+    (version "3.3.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "OpenGLRaw" version))
+              (sha256
+               (base32
+                "07nk0rgm6jcxz6yshwhv5lj5frs6371w3hdjxwa4biws2kmbs6hj"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "OpenGLRaw")))
+    (inputs (list ghc-fixed ghc-half glu))
     (arguments
-     `(#:extra-directories ("glu")))
-    (inputs
-     (list ghc-half ghc-fixed glu))
-    (home-page "https://wiki.haskell.org/Opengl")
+     `(#:extra-directories ("glu")
+       #:cabal-revision ("1"
+                         "15abvqkxc08lx9d44323izccfp7bqfiljnd587zn80vdvmkzs6zc")))
+    (home-page "http://www.haskell.org/haskellwiki/Opengl")
     (synopsis "Raw Haskell bindings for the OpenGL graphics system")
-    (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
+    (description
+     "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
 graphics system and lots of OpenGL extensions.  It is basically a 1:1 mapping
 of OpenGL's C API, intended as a basis for a nicer interface.  OpenGLRaw
 offers access to all necessary functions, tokens and types plus a general
@@ -8285,20 +7933,19 @@ found at runtime, a userError is thrown.")
 (define-public ghc-operational
   (package
     (name "ghc-operational")
-    (version "0.2.4.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "operational" version))
-       (sha256
-        (base32
-         "1hwmwbsxzwv68b39rv4gn3da6irv8zm89gqrkc3rdsgwi5ziyn3i"))))
+    (version "0.2.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "operational" version))
+              (sha256
+               (base32
+                "0aa1pxymvkhbs0x03ikfiap2skzyf2z7307kz5adkmb3qmykcqa2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "operational")))
-    (inputs
-     (list ghc-random))
+    (inputs (list ghc-random))
     (home-page "http://wiki.haskell.org/Operational")
-    (synopsis "Implementation of difficult monads made easy with operational semantics")
+    (synopsis
+     "Implementation of difficult monads made easy with operational semantics")
     (description
      "This library makes it easy to implement monads with tricky control
 flow. This is useful for: writing web applications in a sequential style,
@@ -8388,23 +8035,17 @@ easily work with command-line options.")
 (define-public ghc-optparse-applicative
   (package
     (name "ghc-optparse-applicative")
-    (version "0.16.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "optparse-applicative" version))
-       (sha256
-        (base32
-         "16nnrkmgd28h540f17nb017ziq4gbzgkxpdraqicaczkca1jf1b2"))))
+    (version "0.17.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "optparse-applicative" version))
+              (sha256
+               (base32
+                "097p1bkvw9r3rvcr65w53yw14drb0s46ldkkl1jbmq5g7m6jwnw2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "optparse-applicative")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "0401ik87gm9gjpch6lmkczygp59na3f1j7bcs6mc2r929c2xgsqn")))
-    (inputs
-     (list ghc-transformers-compat ghc-ansi-wl-pprint))
-    (native-inputs
-     (list ghc-quickcheck))
+    (inputs (list ghc-transformers-compat ghc-ansi-wl-pprint))
+    (native-inputs (list ghc-quickcheck))
     (home-page "https://github.com/pcapriotti/optparse-applicative")
     (synopsis "Utilities and combinators for parsing command line options")
     (description "This package provides utilities and combinators for parsing
@@ -8488,20 +8129,18 @@ require aeson
 (define-public ghc-text-conversions
   (package
     (name "ghc-text-conversions")
-    (version "0.3.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "text-conversions" version))
-       (sha256
-        (base32 "0kbxin1q8xj9sgdl185gncrdjwcfzndp8sl5qll8y93l60yq8dxi"))))
+    (version "0.3.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "text-conversions" version))
+              (sha256
+               (base32
+                "0pbjlzsjd3m8np5p6iq7zb0bx6n40d8jha76r8s07s4wg2x0yxy8"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "text-conversions")))
-    (inputs
-     (list ghc-base16-bytestring ghc-base64-bytestring ghc-errors))
-    (native-inputs
-     (list ghc-hspec hspec-discover))
-    (home-page "https://github.com/cjdev/text-conversions#readme")
+    (inputs (list ghc-base16-bytestring ghc-base64-bytestring))
+    (native-inputs (list ghc-hspec hspec-discover))
+    (home-page "https://github.com/cjdev/text-conversions")
     (synopsis "Safe conversions between textual types")
     (description "Safe conversions between textual types")
     (license license:isc)))
@@ -8509,27 +8148,24 @@ require aeson
 (define-public ghc-text-short
   (package
     (name "ghc-text-short")
-    (version "0.1.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "text-short" version))
-       (sha256
-        (base32
-         "0xyrxlb602z8bc9sr2y1fag0x56a20yj5qrkvy7iwc6hnznrynxz"))))
+    (version "0.1.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "text-short" version))
+              (sha256
+               (base32
+                "1nid00c1rg5c1z7l9mwk3f2izc2sps2mip2hl30q985dwb6wcpm3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "text-short")))
     (inputs (list ghc-hashable))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
-           ghc-quickcheck-instances))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck))
     (arguments
-     `(#:tests? #f ; TODO: Needs tasty<1.3
-       #:cabal-revision
-       ("3" "1wjy98ihhipzr34b310sgjjq3cc12aydhckbrgr21kxkzwglm4nv")))
-    (home-page "https://hackage.haskell.org/package/text-short")
+     `(#:cabal-revision ("1"
+                         "0gmmwwchy9312kz8kr5jhiamqrnjqxdqg1wkrww4289yfj1p7dzb")))
+    (home-page "http://hackage.haskell.org/package/text-short")
     (synopsis "Memory-efficient representation of Unicode text strings")
-    (description "This package provides the @code{ShortText} type which
+    (description
+     "This package provides the @code{ShortText} type which
 is suitable for keeping many short strings in memory.  This is similar
 to how @code{ShortByteString} relates to @code{ByteString}.
 
@@ -8543,19 +8179,17 @@ plus the length of the UTF-8 encoded payload.")
 (define-public ghc-text-zipper
   (package
     (name "ghc-text-zipper")
-    (version "0.11")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "text-zipper" version))
-       (sha256
-        (base32 "07l1pyx93gv95cn1wh1di129axhm9sqsn4znykliacv60ld854ys"))))
+    (version "0.12")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "text-zipper" version))
+              (sha256
+               (base32
+                "00k7d6qfznhp6l2ihw3pppkn580pwd7ac7wx9vidil4y9hjagaw6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "text-zipper")))
-    (native-inputs
-     (list ghc-hspec ghc-quickcheck hspec-discover))
-    (inputs
-     (list ghc-vector))
+    (inputs (list ghc-vector))
+    (native-inputs (list ghc-hspec ghc-quickcheck hspec-discover))
     (home-page "https://github.com/jtdaugherty/text-zipper/")
     (synopsis "Text editor zipper library")
     (description
@@ -8571,20 +8205,21 @@ Implementations using both of these examples are provided.")
 (define-public ghc-doclayout
   (package
     (name "ghc-doclayout")
-    (version "0.3.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "doclayout" version))
-       (sha256
-        (base32 "1p9kgjlf7y4p1symvkwndgs4lvyw2c45bsgld09y9r4aiqbhdrxp"))))
+    (version "0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "doclayout" version))
+              (sha256
+               (base32
+                "18xkzywfw0hl3hgbq9z36hs040vb0iz9yygx33cybxfi4i0dwbkx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "doclayout")))
-    (inputs
-     (list ghc-safe ghc-emojis))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-golden ghc-tasty-hunit
-           ghc-tasty-quickcheck))
+    (inputs (list ghc-emojis ghc-safe))
+    (native-inputs (list ghc-tasty ghc-tasty-golden ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0djwb7nrdablc0iy1qakrxpd4m7nn0w94vhb78il3jhjbj2ji179")))
     (home-page "https://github.com/jgm/doclayout")
     (synopsis "Pretty-printing library for laying out text documents")
     (description
@@ -8593,93 +8228,93 @@ with several features not present in pretty-printing libraries designed for
 code.  It was designed for use in @code{Pandoc}.")
     (license license:bsd-3)))
 
-(define-public ghc-pandoc
+(define-public pandoc
   (package
-    (name "ghc-pandoc")
-    (version "2.14.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "pandoc" version))
-       (sha256
-        (base32
-         "1pgd6125mrvzj2faxbsfmackb7kchzcr6bjkrwqbyn9hzxdzbqw2"))))
+    (name "pandoc")
+    (version "2.19.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "pandoc" version))
+              (sha256
+               (base32
+                "0ia2gpl345lwymk38y89sgcqjci7sjmxbi228idg6nkaqfa3ds1n"))
+              (modules '((guix build utils)))
+              (snippet
+               '(begin
+                  ;; Fix test case.
+                  (substitute* "test/writer.ms"
+                    (("\\\\\\[u2212\\]") "-"))))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "pandoc")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'find-library
-           (lambda _
-             (substitute* "test/Tests/Command.hs"
-               (("= dynlibEnv")
-                (format #f "= [(\"LD_LIBRARY_PATH\" , \"~a/dist/build\")]"
-                        (getcwd))))
-             #t)))))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-aeson
-           ghc-aeson-pretty
-           ghc-attoparsec
-           ghc-base64-bytestring
-           ghc-base-compat
-           ghc-blaze-html
-           ghc-blaze-markup
-           ghc-case-insensitive
-           ghc-citeproc
-           ghc-commonmark-extensions
-           ghc-commonmark
-           ghc-commonmark-pandoc
-           ghc-connection
-           ghc-data-default
-           ghc-doclayout
-           ghc-doctemplates
-           ghc-emojis
-           ghc-file-embed
-           ghc-glob
-           ghc-haddock-library
-           ghc-hslua
-           ghc-hslua-module-path
-           ghc-hslua-module-system
-           ghc-hslua-module-text
-           ghc-hsyaml
-           ghc-http-client
-           ghc-http-client-tls
-           ghc-http
-           ghc-http-types
-           ghc-ipynb
-           ghc-jira-wiki-markup
-           ghc-juicypixels
-           ghc-network
-           ghc-network-uri
-           ghc-pandoc-types
-           ghc-random
-           ghc-safe
-           ghc-scientific
-           ghc-sha
-           ghc-skylighting-core
-           ghc-skylighting
-           ghc-split
-           ghc-syb
-           ghc-tagsoup
-           ghc-temporary
-           ghc-texmath
-           ghc-text-conversions
-           ghc-unicode-collation
-           ghc-unicode-transforms
-           ghc-unordered-containers
-           ghc-xml-conduit
-           ghc-xml
-           ghc-zip-archive
-           ghc-zlib))
-    (native-inputs
-     (list ghc-tasty
-           ghc-tasty-golden
-           ghc-tasty-hunit
-           ghc-tasty-lua
-           ghc-tasty-quickcheck
-           ghc-diff
-           ghc-quickcheck))
+    (inputs (list ghc-glob
+                  ghc-juicypixels
+                  ghc-sha
+                  ghc-aeson
+                  ghc-aeson-pretty
+                  ghc-attoparsec
+                  ghc-blaze-html
+                  ghc-blaze-markup
+                  ghc-case-insensitive
+                  ghc-citeproc
+                  ghc-commonmark
+                  ghc-commonmark-extensions
+                  ghc-commonmark-pandoc
+                  ghc-connection
+                  ghc-data-default
+                  ghc-doclayout
+                  ghc-doctemplates
+                  ghc-base64
+                  ghc-emojis
+                  ghc-file-embed
+                  ghc-gridtables
+                  ghc-haddock-library
+                  ghc-hslua-module-doclayout
+                  ghc-hslua-module-path
+                  ghc-hslua-module-system
+                  ghc-hslua-module-text
+                  ghc-hslua-module-version
+                  ghc-http-client
+                  ghc-http-client-tls
+                  ghc-http-types
+                  ghc-ipynb
+                  ghc-jira-wiki-markup
+                  ghc-lpeg
+                  ghc-network
+                  ghc-network-uri
+                  ghc-pandoc-lua-marshal
+                  ghc-pandoc-types
+                  ghc-pretty-show
+                  ghc-random
+                  ghc-safe
+                  ghc-scientific
+                  ghc-skylighting
+                  ghc-skylighting-core
+                  ghc-split
+                  ghc-syb
+                  ghc-tagsoup
+                  ghc-temporary
+                  ghc-texmath
+                  ghc-text-conversions
+                  ghc-unicode-collation
+                  ghc-unicode-transforms
+                  ghc-xml
+                  ghc-xml-conduit
+                  ghc-xml-types
+                  ghc-yaml
+                  ghc-zip-archive
+                  ghc-zlib
+                  ghc-servant-server
+                  ghc-wai
+                  ghc-hslua
+                  ghc-hslua-aeson
+                  ghc-wai-extra
+                  ghc-warp))
+    (native-inputs (list ghc-diff
+                         ghc-tasty
+                         ghc-tasty-golden
+                         ghc-tasty-hunit
+                         ghc-tasty-lua
+                         ghc-tasty-quickcheck))
     (home-page "https://pandoc.org")
     (synopsis "Conversion between markup formats")
     (description
@@ -8693,167 +8328,26 @@ definition lists, tables, and other features.  A compatibility mode is
 provided for those who need a drop-in replacement for Markdown.pl.")
     (license license:gpl2+)))
 
-(define-public pandoc
-  (package
-    (inherit ghc-pandoc)
-    (name "pandoc")
-    (arguments
-     `(#:configure-flags
-       (list "-fstatic"
-             ;; Do not build trypandoc; this is the default but it's better to
-             ;; be explicit.
-             "-f-trypandoc"
-             ;; TODO: Without these we cannot link the Haskell libraries
-             ;; statically.  It would be nice if we could also build the
-             ;; shared libraries.
-             "--disable-shared"
-             "--disable-executable-dynamic"
-             ;; That's where we place all static libraries
-             "--extra-lib-dirs=static-libs/"
-             "--ghc-option=-static")
-       #:modules ((guix build haskell-build-system)
-                  (guix build utils)
-                  (ice-9 match)
-                  (srfi srfi-1))
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'create-simple-paths-module
-           (lambda* (#:key outputs #:allow-other-keys)
-             (call-with-output-file "Paths_pandoc.hs"
-               (lambda (port)
-                 (format port "\
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE NoRebindableSyntax #-}
-{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
-module Paths_pandoc (version,getDataDir,getDataFileName) where
-import Prelude
-import Data.Version (Version(..))
-import System.Info
-version :: Version
-version = Version [~a] []
-
-datadir :: FilePath
-datadir = \"~a/share/\" ++
-  arch ++ \"-\" ++
-  os ++ \"-\" ++
-  compilerName ++ \"-~a/pandoc-~a\"
-
-getDataDir :: IO FilePath
-getDataDir = return datadir
-
-getDataFileName :: FilePath -> IO FilePath
-getDataFileName name = do
-  dir <- getDataDir
-  return (dir ++ \"/\" ++ name)
-"
-                         (string-map (lambda (chr) (if (eq? chr #\.) #\, chr))
-                                     ,(package-version ghc-pandoc))
-                         (assoc-ref outputs "out")
-                         ,(package-version ghc)
-                         ,(package-version ghc-pandoc))))
-             #t))
-         (add-after 'unpack 'prepare-static-libraries
-           (lambda* (#:key inputs #:allow-other-keys)
-             (mkdir-p (string-append (getcwd) "/static-libs"))
-             (for-each
-              (lambda (input)
-                (when (or (string-prefix? "static-" (car input))
-                          (string-prefix? "ghc" (car input)))
-                  (match (find-files (cdr input) "\\.a$")
-                    ((and (first . rest) libs)
-                     (for-each (lambda (lib)
-                                 (let ((target (string-append (getcwd) "/static-libs/"
-                                                              (basename lib))))
-                                   (unless (file-exists? target)
-                                     (symlink first target))))
-                               libs))
-                    (_ #f))))
-              inputs)
-             #t))
-         (delete 'check)
-         ;; Remove libraries. If you need them, install ghc-pandoc instead.
-         (add-after 'register 'delete-libraries
-           (lambda* (#:key outputs #:allow-other-keys)
-             (delete-file-recursively (string-append (assoc-ref outputs "out") "/lib"))))
-         (add-after 'install 'post-install-check
-           (assoc-ref %standard-phases 'check)))))
-    (outputs '("out" "doc" "static"))
-    (inputs
-     (let* ((direct-inputs (package-inputs ghc-pandoc))
-            (all-static-inputs
-             (map (lambda (pkg)
-                    (list (string-append "static-" (package-name pkg))
-                          pkg "static"))
-                  (delete-duplicates
-                   (append (map cadr direct-inputs)
-                           (filter (lambda (pkg)
-                                     (and
-                                      (string-prefix? "ghc-" (package-name pkg))
-                                      (not (string=? "ghc-next" (package-name pkg)))))
-                                   (package-closure
-                                    (map cadr direct-inputs))))))))
-       `(("zlib:static" ,zlib "static")
-         ,@all-static-inputs
-         ,@direct-inputs)))
-    (native-inputs
-     (let* ((direct-inputs (package-native-inputs ghc-pandoc))
-            (all-static-inputs
-             (map (lambda (pkg)
-                    (list (string-append "static-" (package-name pkg))
-                          pkg "static"))
-                  (delete-duplicates
-                   (append (map cadr direct-inputs)
-                           (filter (lambda (pkg)
-                                     (and
-                                      (string-prefix? "ghc-" (package-name pkg))
-                                      (not (string=? "ghc-next" (package-name pkg)))))
-                                   (package-closure
-                                    (map cadr direct-inputs))))))))
-       `(,@all-static-inputs
-         ,@direct-inputs)))))
+(define-public ghc-pandoc
+  (deprecated-package "ghc-pandoc" pandoc))
 
 (define-public ghc-pandoc-types
   (package
     (name "ghc-pandoc-types")
-    (version "1.22.1")
+    (version "1.22.2.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "pandoc-types" version))
               (sha256
                (base32
-                "0z2j306jsiriwhib0201hsllwyck7qcvqci5c25frwsmknr3mls2"))))
+                "17b5c4b9jmx2gca1wk9vlnvvlzdw21qiqc0bpikkkiv7kl99drsc"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "pandoc-types")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         ;; None of the directory names are actually used.  By generating a
-         ;; simpler module without references to store names we avoid
-         ;; introducing references in the pandoc executable.
-         (add-after 'unpack 'create-simple-paths-module
-           (lambda _
-             (call-with-output-file "Paths_pandoc_types.hs"
-               (lambda (port)
-                 (format port "\
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE NoRebindableSyntax #-}
-{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
-module Paths_pandoc_types (version) where
-import Data.Version (Version(..))
-version :: Version
-version = Version [~a] []
-" (string-map (lambda (chr) (if (eq? chr #\.) #\, chr)) ,version))))
-             #t)))))
-    (inputs
-     (list ghc-syb ghc-aeson))
-    (native-inputs
-     (list ghc-quickcheck
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2
-           ghc-string-qq
-           ghc-hunit))
-    (home-page "https://pandoc.org")
+    (inputs (list ghc-syb ghc-aeson ghc-quickcheck))
+    (native-inputs (list ghc-test-framework ghc-test-framework-hunit
+                         ghc-test-framework-quickcheck2 ghc-hunit
+                         ghc-string-qq))
+    (home-page "https://pandoc.org/")
     (synopsis "Types for representing a structured document")
     (description
      "This module defines the @code{Pandoc} data structure, which is used by
@@ -8876,8 +8370,8 @@ building up, manipulating and serialising @code{Pandoc} structures.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "parallel")))
     (arguments
-     `(#:cabal-revision
-       ("3" "1lv3y3zrdfc09nsiqxg7mzcahgnqi6z9caspd4lvifhhfrqy2722")))
+     `(#:cabal-revision ("5"
+                         "1q45wzpf2sda0244l55gakl3g5zqhcb27m86nhl3vslcjc35mpbf")))
     (home-page "https://hackage.haskell.org/package/parallel")
     (synopsis "Parallel programming library")
     (description
@@ -8930,14 +8424,13 @@ is also parametric in the input stream type.")
 (define-public ghc-parser-combinators
   (package
     (name "ghc-parser-combinators")
-    (version "1.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "parser-combinators" version))
-       (sha256
-        (base32
-         "0k95nvgnl5820y094yfh7b868l0xd1diclm4kx9560p5rm02w5h3"))))
+    (version "1.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "parser-combinators" version))
+              (sha256
+               (base32
+                "0is45q3q6ngfqvzpwwga9phbwk45v7g1q2x1rlm95a7q946yy44k"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "parser-combinators")))
     (home-page "https://github.com/mrkkrp/parser-combinators")
@@ -8950,28 +8443,26 @@ combinators.")
 (define-public ghc-parsers
   (package
     (name "ghc-parsers")
-    (version "0.12.10")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "parsers" version))
-       (sha256
-        (base32
-         "0v0smxbzk1qpdfkfqqmrzd2dngv3vxba10mkjn9nfm6a309izf8p"))))
+    (version "0.12.11")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "parsers" version))
+              (sha256
+               (base32
+                "068k7fm0s13z0jkkffc149cqcxnzpk1m066lp4ccdfcb41km1zwi"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "parsers")))
-    (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
-                               ; -package attoparsec-0.13.0.1"
-    (inputs
-     (list ghc-base-orphans
-           ghc-attoparsec
-           ghc-scientific
-           ghc-semigroups
-           ghc-charset
-           ghc-unordered-containers))
-    (home-page "https://github.com/ekmett/parsers/")
+    (inputs (list ghc-base-orphans
+                  ghc-charset
+                  ghc-scientific
+                  ghc-unordered-containers
+                  ghc-attoparsec
+                  ghc-semigroups))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck-instances))
+    (home-page "http://github.com/ekmett/parsers/")
     (synopsis "Parsing combinators")
-    (description "This library provides convenient combinators for working
+    (description
+     "This library provides convenient combinators for working
 with and building parsing combinator libraries.  Given a few simple instances,
 you get access to a large number of canned definitions.  Instances exist for
 the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
@@ -8981,31 +8472,24 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
 (define-public ghc-path
   (package
     (name "ghc-path")
-    (version "0.8.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "path" version))
-       (sha256
-        (base32
-         "0vzsa41q5sxs1ni72yv1vfpnc6r5mjdwnmdb6jrs6cszb2xlkjr4"))))
+    (version "0.9.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "path" version))
+              (sha256
+               (base32
+                "15xxsjdxxqxnh20iqhprbdyhldk2igl5gd4ld6hhk9nqgwqdcr0f"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "path")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "02vhx94mqapyigvayb6cj7p7snn354pb542n3qyvsm0gih52wlja")))
-    (inputs
-     (list ghc-aeson ghc-hashable))
-    (native-inputs
-     (list ghc-hspec
-           ghc-quickcheck
-           ghc-genvalidity
-           ghc-genvalidity-hspec
-           ghc-genvalidity-property
-           ghc-hspec
-           ghc-validity))
-    (home-page
-     "https://hackage.haskell.org/package/path")
+    (inputs (list ghc-aeson ghc-hashable))
+    (native-inputs (list ghc-hspec
+                         ghc-quickcheck
+                         ghc-genvalidity
+                         ghc-genvalidity-property
+                         ghc-genvalidity-hspec
+                         ghc-hspec
+                         ghc-validity))
+    (home-page "http://hackage.haskell.org/package/path")
     (synopsis "Support for well-typed paths")
     (description "This package introduces a type for paths upholding useful
 invariants.")
@@ -9014,32 +8498,21 @@ invariants.")
 (define-public ghc-path-io
   (package
     (name "ghc-path-io")
-    (version "1.6.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "path-io" version))
-       (sha256
-        (base32
-         "1dnc48hf8x83p0jy05qi8j8gmfmsy50swnql9ssdv74lsryp615n"))))
+    (version "1.7.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "path-io" version))
+              (sha256
+               (base32
+                "1jr1inh3x0a42rdh4q0jipbw8jsprdza1j5xkzd7nxcq0a143g9l"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "path-io")))
-    (arguments
-     `(#:cabal-revision
-       ("3" "0rsr9r2175lf7zcz2sns0mhxkvl21pm50sjidjq5v75nalrsw6rp")))
-    (inputs
-     (list ghc-dlist
-           ghc-exceptions
-           ghc-path
-           ghc-transformers-base
-           ghc-unix-compat
-           ghc-temporary))
-    (native-inputs
-     (list ghc-hspec))
-    (home-page
-     "https://github.com/mrkkrp/path-io")
+    (inputs (list ghc-dlist ghc-path ghc-temporary ghc-unix-compat))
+    (native-inputs (list ghc-hspec))
+    (home-page "https://github.com/mrkkrp/path-io")
     (synopsis "Functions for manipulating well-typed paths")
-    (description "This package provides an interface to the @code{directory}
+    (description
+     "This package provides an interface to the @code{directory}
 package for users of @code{path}.  It also implements some missing stuff like
 recursive scanning and copying of directories, working with temporary
 files/directories, and more.")
@@ -9140,83 +8613,81 @@ syntax and semantics as Perl 5.")
 (define-public ghc-persistent
   (package
     (name "ghc-persistent")
-    (version "2.13.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "persistent" version))
-       (sha256
-        (base32
-         "13lp9i94f57qhifdmr1vnsrra34526f7kqa1sybcaj2jh2v3q85k"))))
+    (version "2.13.3.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "persistent" version))
+              (sha256
+               (base32
+                "0z69yvk0rd29dp5qdhi4p587b891y90azrzzpa3g10cxp3gyywvm"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "persistent")))
-    (inputs
-     (list ghc-aeson
-           ghc-attoparsec
-           ghc-base64-bytestring
-           ghc-blaze-html
-           ghc-conduit
-           ghc-fast-logger
-           ghc-http-api-data
-           ghc-lift-type
-           ghc-monad-logger
-           ghc-path-pieces
-           ghc-resource-pool
-           ghc-resourcet
-           ghc-scientific
-           ghc-silently
-           ghc-th-lift-instances
-           ghc-unliftio-core
-           ghc-unliftio
-           ghc-unordered-containers
-           ghc-vector))
-    (native-inputs
-     (list ghc-hspec ghc-quickcheck ghc-quickcheck-instances
-           ghc-shakespeare))
-    (home-page "https://www.yesodweb.com/book/persistent")
+    (inputs (list ghc-conduit
+                  ghc-aeson
+                  ghc-attoparsec
+                  ghc-base64-bytestring
+                  ghc-blaze-html
+                  ghc-fast-logger
+                  ghc-http-api-data
+                  ghc-lift-type
+                  ghc-monad-logger
+                  ghc-path-pieces
+                  ghc-resource-pool
+                  ghc-resourcet
+                  ghc-scientific
+                  ghc-silently
+                  ghc-th-lift-instances
+                  ghc-unliftio
+                  ghc-unliftio-core
+                  ghc-unordered-containers
+                  ghc-vault
+                  ghc-vector))
+    (native-inputs (list ghc-hspec ghc-quickcheck ghc-quickcheck-instances
+                         ghc-shakespeare))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0kyipwaspzah6f88s51d61kr8i9g05grm2g0lnnw28jp06nggg5d")))
+    (home-page "http://www.yesodweb.com/book/persistent")
     (synopsis "Type-safe, multi-backend data serialization for Haskell")
-    (description "This Haskell package allows Haskell programs to access data
+    (description
+     "This Haskell package allows Haskell programs to access data
 storage systems like PostgreSQL, SQLite, and MariaDB in a type-safe way.")
     (license license:expat)))
 
 (define-public ghc-persistent-sqlite
   (package
     (name "ghc-persistent-sqlite")
-    (version "2.13.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "persistent-sqlite" version))
-       (sha256
-        (base32
-         "12za89crbk74mya4qxpw5fp5fqp64vwz5s8vbjd7m8r3j3vbw338"))))
+    (version "2.13.1.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "persistent-sqlite" version))
+              (sha256
+               (base32
+                "1z8650nv10f6yldn9sihk54c7mlcnkxwaj956igvs6q3x3s8aa1b"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "persistent-sqlite")))
-    (inputs
-     (list ghc-persistent
-           ghc-aeson
-           ghc-conduit
-           ghc-microlens-th
-           ghc-monad-logger
-           ghc-resource-pool
-           ghc-resourcet
-           ghc-unliftio-core
-           ghc-unordered-containers))
-    (native-inputs
-     (list ghc-persistent-template
-           ghc-persistent-test
-           ghc-exceptions
-           ghc-fast-logger
-           ghc-hspec
-           ghc-hunit
-           ghc-quickcheck
-           ghc-system-fileio
-           ghc-system-filepath
-           ghc-temporary))
-    (home-page
-     "https://www.yesodweb.com/book/persistent")
+    (inputs (list ghc-persistent
+                  ghc-aeson
+                  ghc-conduit
+                  ghc-microlens-th
+                  ghc-monad-logger
+                  ghc-resource-pool
+                  ghc-resourcet
+                  ghc-unliftio-core
+                  ghc-unordered-containers))
+    (native-inputs (list ghc-persistent-test
+                         ghc-fast-logger
+                         ghc-hspec
+                         ghc-hunit
+                         ghc-microlens
+                         ghc-quickcheck
+                         ghc-system-fileio
+                         ghc-system-filepath
+                         ghc-temporary))
+    (home-page "http://www.yesodweb.com/book/persistent")
     (synopsis "Backend for the persistent library using sqlite3")
-    (description "This Haskell package includes a thin sqlite3 wrapper based
+    (description
+     "This Haskell package includes a thin sqlite3 wrapper based
 on the direct-sqlite package, as well as the entire C library, so there are no
 system dependencies.")
     (license license:expat)))
@@ -9254,14 +8725,14 @@ functions for the ghc-persistent package.")
 (define-public ghc-persistent-test
   (package
     (name "ghc-persistent-test")
-    (version "2.13.0.3")
+    (version "2.13.1.2")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "persistent-test" version))
        (sha256
         (base32
-         "07q53jvhz00cf10k7a8fkvykgwcl10fgzh8k9gv1d248f336crvs"))))
+         "0cah2gyp5lm9hipm3wvcxnl14cmq51dajzcw3wcf9xd19sbm4k49"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "persistent-test")))
     (inputs
@@ -9342,6 +8813,9 @@ For further information, see
     (native-inputs
      (list ghc-quickcheck ghc-test-framework
            ghc-test-framework-quickcheck2))
+    (arguments
+     `(#:cabal-revision ("6"
+                         "16s8a1ijakhsk73ny2vrw6a8r2dszgncd0wk735ii6csg3l2c9pm")))
     (home-page
      "https://hackage.haskell.org/package/pipes")
     (synopsis "Compositional pipelines")
@@ -9399,8 +8873,8 @@ other end when progressing past the actual edge.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "polyparse")))
     (arguments
-     `(#:cabal-revision
-       ("2" "1n5q6w7x46cvcq7j1pg9jx9h72vcsc5di35rbkmwgjw6pq4w4gfl")))
+     `(#:cabal-revision ("5"
+                         "05qrn5pfdy45x1nkx7dvhnxs9j6d6cssws4kwn2sl3n9qmagr8mc")))
     (home-page
      "http://code.haskell.org/~malcolm/polyparse/")
     (synopsis
@@ -9417,18 +8891,19 @@ Strings.")
 (define-public ghc-pqueue
   (package
     (name "ghc-pqueue")
-    (version "1.4.1.3")
+    (version "1.4.3.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "pqueue" version))
        (sha256
         (base32
-         "1sz7hlnfd86hbwrgqxczmsjsl1ki0ryi9dgzscxlsgjkdgcdia2p"))))
+         "0kl608jw0xz0n4ysw7p3cvlm1s71xrysw8862cddrzbr38bv8jvq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "pqueue")))
+    (inputs (list ghc-indexed-traversable))
     (native-inputs
-     (list ghc-quickcheck))
+     (list ghc-tasty ghc-tasty-quickcheck))
     (home-page "https://hackage.haskell.org/package/pqueue")
     (synopsis "Reliable, persistent, fast priority queues")
     (description
@@ -9577,21 +9052,19 @@ examination.")
 (define-public ghc-pretty-simple
   (package
     (name "ghc-pretty-simple")
-    (version "4.0.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "pretty-simple" version))
-       (sha256
-        (base32 "1srvx854ml2gffnkxr2fm12xk8syjsk078rfzrq0a3idwgv46myw"))))
+    (version "4.1.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "pretty-simple" version))
+              (sha256
+               (base32
+                "0di7n3kq2bl0xqj9b1xxf3jznyy6cfyjs6hf6g0bi72rf4wprd1w"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "pretty-simple")))
-
-    (inputs
-     (list ghc-aeson ghc-optparse-applicative
-           ghc-prettyprinter-ansi-terminal ghc-prettyprinter))
-    (native-inputs
-     (list cabal-doctest ghc-doctest ghc-glob ghc-quickcheck))
+    (inputs (list ghc-prettyprinter ghc-prettyprinter-ansi-terminal
+                  ghc-optparse-applicative ghc-aeson))
+    (native-inputs (list ghc-doctest ghc-glob ghc-quickcheck))
+    (arguments (list #:tests? #f)) ; Could not find module ‘Build_doctests’
     (home-page "https://github.com/cdepillabout/pretty-simple")
     (synopsis "Pretty printer for data types with a 'Show' instance")
     (description
@@ -9602,27 +9075,27 @@ Show instance.")
 (define-public ghc-primitive
   (package
     (name "ghc-primitive")
-    (version "0.7.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "primitive" version))
-       (sha256
-        (base32
-         "1facmq2wxhn5mbgd209zz5swyaw1q970fv3hd84klaxrhabqaxwi"))))
+    (version "0.7.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "primitive" version))
+              (sha256
+               (base32
+                "1p01fmw8yi578rvwicrlpbfkbfsv7fbnzb88a7vggrhygykgs31w"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "primitive")))
-    (arguments `(#:tests? #f)) ; TODO: Loops.
-;    (native-inputs
-;     `(("ghc-base-orphans" ,ghc-base-orphans)
-;       ("ghc-quickcheck-classes-base" ,ghc-quickcheck-classes-base)
-;       ("ghc-quickcheck" ,ghc-quickcheck)
-;       ("ghc-tasty" ,ghc-tasty)
-;       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
-;       ("ghc-tagged" ,ghc-tagged)
-;       ("ghc-transformers-compat" ,ghc-transformers-compat)))
-    (home-page
-     "https://github.com/haskell/primitive")
+;    (native-inputs (list ghc-base-orphans
+;                         ghc-quickcheck-classes-base
+;                         ghc-quickcheck
+;                         ghc-tasty
+;                         ghc-tasty-quickcheck
+;                         ghc-tagged
+;                         ghc-transformers-compat))
+    (arguments
+     `(#:tests? #f ; Cannot resolve package cycle.
+       #:cabal-revision ("2"
+                         "0xh1m8nybz760c71gm1w9fga25y2rys1211q77v6wagdsas634yf")))
+    (home-page "https://github.com/haskell/primitive")
     (synopsis "Primitive memory-related operations")
     (description
      "This package provides various primitive memory-related operations.")
@@ -9735,20 +9208,18 @@ the ideal templating system.")
 (define-public ghc-protolude
   (package
     (name "ghc-protolude")
-    (version "0.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "protolude" version))
-       (sha256
-        (base32
-         "1b6wprbwfdjyvds2bm6na0fbqgzdkj5ikkk33whbkyh3krd3i0s0"))))
+    (version "0.3.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "protolude" version))
+              (sha256
+               (base32
+                "0i53yxg44nrz0czwr8cqhw1fdapz9db8kfnqz9a3lmj5skrikh3y"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "protolude")))
-    (inputs
-     (list ghc-async ghc-hashable ghc-mtl-compat ghc-paths
-           ghc-transformers-compat))
-    (home-page "https://github.com/protolude/protolude")
+    (inputs (list ghc-async ghc-hashable ghc-mtl-compat
+                  ghc-transformers-compat))
+    (home-page "https://github.com/sdiehl/protolude")
     (synopsis "Sensible set of defaults for writing custom Preludes")
     (description
      "Protolude gives you sensible defaults for writing custom Preludes to
@@ -9758,18 +9229,19 @@ replace the standard one provided by GHC.")
 (define-public ghc-psqueue
   (package
     (name "ghc-psqueue")
-    (version "1.1.0.1")
+    (version "1.1.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "PSQueue" version))
               (sha256
                (base32
-                "1cik7sw10sacsijmfhghzy54gm1qcyxw14shlp86lx8z89kcnkza"))))
+                "02pgqzwxndi8cwa5fw668gfsh7z3lzbygkgcsf56bwrxwqjyz4bi"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "PSQueue")))
+    (native-inputs (list ghc-quickcheck))
     (arguments
      '(#:cabal-revision
-       ("2" "0n1yrv1x1dxbjn9hjr8lk4k5in9c75ixzldlmszayi26bvax7329")))
+       ("1" "02a5g59sc9jh3v4pibhjpijv8lsbiydznrpqyin7qhwsyc0p813a")))
     (home-page "https://hackage.haskell.org/package/PSQueue")
     (synopsis "Priority search queue")
     (description
@@ -9784,32 +9256,26 @@ keys, in linear time.")
 (define-public ghc-psqueues
   (package
     (name "ghc-psqueues")
-    (version "0.2.7.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "psqueues" version))
-       (sha256
-        (base32
-         "1yckx2csqswghiy9nfj03cybmza8104nmnpbpcc9ngwlbmakn9i6"))))
+    (version "0.2.7.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "psqueues" version))
+              (sha256
+               (base32
+                "1cmz7spfzx7niglmsphnndh0m4b8njkn0fhb9nshbnbq6nx515yh"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "psqueues")))
-    (arguments
-     '(#:tests? #f ; TODO: Needs quickcheck<2.14
-       #:cabal-revision
-       ("1" "0d0mm3c8x31dasfzp1884r2irkm3c9irvvbahjzfr1bzzxfb7vyv")))
-    (inputs
-     (list ghc-hashable))
-    (native-inputs
-     (list ghc-hunit
-           ghc-quickcheck
-           ghc-tagged
-           ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck))
-    (home-page "https://github.com/jaspervdj/psqueues")
+    (inputs (list ghc-hashable))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-tagged))
+    (home-page "http://hackage.haskell.org/package/psqueues")
     (synopsis "Pure priority search queues")
-    (description "The psqueues package provides
+    (description
+     "The psqueues package provides
 @uref{https://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in
 three different flavors:
 
@@ -9878,36 +9344,33 @@ usable.")
 (define-public ghc-random
   (package
     (name "ghc-random")
-    (version "1.2.0")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "random" version))
-       (sha256
-        (base32 "1pmr7zbbqg58kihhhwj8figf5jdchhi7ik2apsyxbgsqq3vrqlg4"))))
+    (version "1.2.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "random" version))
+              (sha256
+               (base32
+                "0xlv1k4sj87akwvj54kq4nrfkzi6qcz1941bf78pnkbaxpvp44iy"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "random")))
-    (arguments
-     `(#:tests? #f
-       #:cabal-revision
-       ("6" "1hzfz9b1cxrsya8i53yx145iypaakfsfjix7l8girhx7vbz0cm8r")))
-    (inputs `(("ghc-splitmix" ,ghc-splitmix-bootstrap)))
-   ;; ghc-random is widely used and causes quite a few loops.
-;    (native-inputs
-;     `(("ghc-doctest" ,ghc-doctest)
-;       ("ghc-mwc-random" ,ghc-mwc-random)
-;       ("ghc-primitive" ,ghc-primitive)
-;       ("ghc-unliftio" ,ghc-unliftio)
-;       ("ghc-vector" ,ghc-vector)
-;       ("ghc-smallcheck" ,ghc-smallcheck)
-;       ("ghc-tasty" ,ghc-tasty)
-;       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
-;       ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
-;       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
-    (home-page "https://hackage.haskell.org/package/random")
+    ;; ghc-random is widely used and causes quite a few loops, so disable tests.
+    (arguments (list #:tests? #f))
+    (inputs (list ghc-splitmix-bootstrap))
+;    (native-inputs (list ghc-doctest
+;                         ghc-mwc-random
+;                         ghc-primitive
+;                         ghc-unliftio-bootstrap
+;                         ghc-vector
+;                         ghc-smallcheck
+;                         ghc-tasty
+;                         ghc-tasty-smallcheck
+;                         ghc-tasty-hunit
+;                         ghc-tasty
+;                         ghc-tasty-inspection-testing))
+    (home-page "http://hackage.haskell.org/package/random")
     (synopsis "Random number library")
-    (description "This package provides a basic random number generation
+    (description
+     "This package provides a basic random number generation
 library, including the ability to split random number generators.")
     (license license:bsd-3)))
 
@@ -9958,6 +9421,9 @@ DOS/Windows paths and markup languages (such as XML).")
          "1ja39cg26wy2fs00gi12x7iq5k8i366pbqi3p916skfa5jnkfc3h"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "readable")))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0dywlvxjszqa1dj5r1cva0viv2l1hm8mw75zddnf96pfpd00fmga")))
     (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
@@ -9968,38 +9434,41 @@ includes efficient implementations for common data types.")
 (define-public ghc-rebase
   (package
     (name "ghc-rebase")
-    (version "1.13.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "rebase" version))
-       (sha256
-        (base32
-         "0sh1vha10n28c4jb97p99xglghqph8ppydqzbnb2h25a34057927"))))
+    (version "1.16.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "rebase" version))
+              (sha256
+               (base32
+                "0mb1x5p3lvfhxsrnmkhsv6f4rd1cxp6m3qg6kyz30svrbwxsvvkz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "rebase")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-bifunctors
-           ghc-comonad
-           ghc-contravariant
-           ghc-dlist
-           ghc-either
-           ghc-hashable
-           ghc-hashable-time
-           ghc-profunctors
-           ghc-scientific
-           ghc-selective
-           ghc-semigroupoids
-           ghc-unordered-containers
-           ghc-uuid-types
-           ghc-vector
-           ghc-vector-instances
-           ghc-void))
+    (inputs (list ghc-bifunctors
+                  ghc-contravariant
+                  ghc-comonad
+                  ghc-dlist
+                  ghc-either
+                  ghc-groups
+                  ghc-hashable
+                  ghc-invariant
+                  ghc-profunctors
+                  ghc-scientific
+                  ghc-selective
+                  ghc-semigroupoids
+                  ghc-time-compat
+                  ghc-unordered-containers
+                  ghc-uuid-types
+                  ghc-vector
+                  ghc-vector-instances
+                  ghc-void))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1igpk9gz54jfvf5m69xcp7hl567c4lkbmwhzylcbx0i1n0pd7i2n")))
     (home-page "https://github.com/nikita-volkov/rebase")
     (synopsis "Progressive alternative to the base package
 for Haskell")
-    (description "This Haskell package is intended for those who are
+    (description
+     "This Haskell package is intended for those who are
 tired of keeping long lists of dependencies to the same essential libraries
 in each package as well as the endless imports of the same APIs all over again.
 
@@ -10025,24 +9494,23 @@ the community, with the missing features being added with pull-requests.")
 (define-public ghc-reducers
   (package
     (name "ghc-reducers")
-    (version "3.12.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "reducers" version))
-       (sha256
-        (base32
-         "09wf8pl9ycglcv6qj5ba26gkg2s5iy81hsx9xp0q8na0cwvp71ki"))))
+    (version "3.12.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "reducers" version))
+              (sha256
+               (base32
+                "0hsycdir52jdijnnvc77jj971fjrrc722v952wr62ivrvx2zarn0"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "reducers")))
+    (inputs (list ghc-fingertree ghc-hashable ghc-unordered-containers
+                  ghc-semigroupoids ghc-semigroups))
     (arguments
-     '(#:cabal-revision
-       ("2" "1kd38n9h2hxl09khvkvkhnflgm6rbky1zkw3iazlpb8xk9zkk39s")))
-    (inputs
-     (list ghc-fingertree ghc-hashable ghc-unordered-containers
-           ghc-semigroupoids ghc-semigroups))
-    (home-page "https://github.com/ekmett/reducers/")
-    (synopsis "Semigroups, specialized containers and a general map/reduce framework")
+     `(#:cabal-revision ("2"
+                         "1ji6rp0f857d0vp2kjqcck7avrjgqvqjgwnhdcxs3zbjkwpqyhfb")))
+    (home-page "http://github.com/ekmett/reducers/")
+    (synopsis
+     "Semigroups, specialized containers and a general map/reduce framework")
     (description "This library provides various semigroups, specialized
 containers and a general map/reduce framework for Haskell.")
     (license license:bsd-3)))
@@ -10096,36 +9564,23 @@ configurations to coexist without resorting to mutable global variables or
 (define-public ghc-regex
   (package
     (name "ghc-regex")
-    (version "1.1.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "regex" version))
-       (sha256
-        (base32
-         "02hxgy5ck3h5pwd5gzs4565qbql8457cjdbbc2yrk236qzc1qa8x"))))
+    (version "1.1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "regex" version))
+              (sha256
+               (base32
+                "1nzyfkqmclmawmphvksvm9l64awqgnypic4xplc2s9sjcj4h814a"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "regex")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'relax-dependencies
-           (lambda _
-             (substitute* "regex.cabal"
-               (("base-compat.*>=.*0.6.*")
-                "base-compat >= 0.6\n")
-               (("template-haskell.*>=.*2.7.*")
-                "template-haskell >= 2.7\n"))
-             #t)))))
-    (inputs
-     (list ghc-base-compat
-           ghc-hashable
-           ghc-regex-base
-           ghc-regex-pcre-builtin
-           ghc-regex-tdfa
-           ghc-time-locale-compat
-           ghc-unordered-containers
-           ghc-utf8-string))
+    (inputs (list ghc-base-compat
+                  ghc-hashable
+                  ghc-regex-base
+                  ghc-regex-pcre-builtin
+                  ghc-regex-tdfa
+                  ghc-time-locale-compat
+                  ghc-unordered-containers
+                  ghc-utf8-string))
     (home-page "https://regex.uk")
     (synopsis "Toolkit for regex-base")
     (description
@@ -10163,20 +9618,22 @@ regular expressions.  Parsers can be built using Applicative interface.")
 (define-public ghc-regex-base
   (package
     (name "ghc-regex-base")
-    (version "0.94.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "regex-base" version))
-       (sha256
-        (base32
-         "1ngdmmrxs1rhvib052c6shfa40yad82jylylikz327r0zxpxkcbi"))))
+    (version "0.94.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "regex-base" version))
+              (sha256
+               (base32
+                "1w9fxad1dwi040r3db9i2cjhhrl86p3hngj13ixbcnqgb27l16bv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "regex-base")))
-    (home-page
-     "https://sourceforge.net/projects/lazy-regex")
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1k2gzjm7xz69f7zr08wh2wzb5dhb659cvimsvx0g9p8cf5f45x2g")))
+    (home-page "https://wiki.haskell.org/Regular_expressions")
     (synopsis "Replaces/Enhances Text.Regex")
-    (description "@code{Text.Regex.Base} provides the interface API for
+    (description
+     "@code{Text.Regex.Base} provides the interface API for
 regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
     (license license:bsd-3)))
 
@@ -10195,36 +9652,15 @@ regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
     (properties '((upstream-name . "regex-compat")))
     (inputs
      (list ghc-regex-base ghc-regex-posix))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "0ldqpdxikm17ydrkfmichflkdqdrkspv4r0qy3zbdgqf5033pj4n")))
     (home-page "https://sourceforge.net/projects/lazy-regex")
     (synopsis "Replaces/Enhances Text.Regex")
     (description "This library provides one module layer over
 @code{regex-posix} to replace @code{Text.Regex}.")
     (license license:bsd-3)))
 
-(define-public ghc-regex-compat-tdfa
-  (package
-    (name "ghc-regex-compat-tdfa")
-    (version "0.95.1.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "regex-compat-tdfa" version))
-       (sha256
-        (base32
-         "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "regex-compat-tdfa")))
-    (inputs
-     (list ghc-regex-base ghc-regex-tdfa))
-    (home-page "https://hub.darcs.net/shelarcy/regex-compat-tdfa")
-    (synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
-    (description
-     "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
-@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
-This is not good for Unicode users.  This modified regex-compat uses regex-tdfa to solve
-this problem.")
-    (license license:bsd-3)))
-
 (define-public ghc-regex-pcre
   (package
     (name "ghc-regex-pcre")
@@ -10298,23 +9734,18 @@ Haskell library @code{regex-base}.")
 (define-public ghc-regex-tdfa
   (package
     (name "ghc-regex-tdfa")
-    (version "1.3.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "regex-tdfa" version))
-       (sha256
-        (base32
-         "1msrq31k4jmn2lmrdzn87jqarqhw265ca69rfg5jpa5adrzm3gmi"))))
+    (version "1.3.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "regex-tdfa" version))
+              (sha256
+               (base32
+                "1lfzhir5zbgga44zhr4qvc2xc9pa9lslv12c8lwqqw80bzfdfq16"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "regex-tdfa")))
-    (arguments
-     '(#:cabal-revision
-       ("1" "02gwf740vs0jy3l6dgw72r8c04yggshia6w16n140ncpsici8c4r")))
-    (inputs
-     (list ghc-regex-base))
-    (native-inputs (list ghc-utf8-string))
-    (home-page "https://github.com/haskell-hvr/regex-tdfa")
+    (inputs (list ghc-regex-base))
+    (native-inputs (list ghc-utf8-string ghc-doctest-parallel))
+    (home-page "https://wiki.haskell.org/Regular_expressions")
     (synopsis "POSIX extended regular expressions in Haskell")
     (description
      "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
@@ -10325,18 +9756,15 @@ inspired by libtre.")
 (define-public ghc-repline
   (package
     (name "ghc-repline")
-    (version "0.4.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "repline" version))
-       (sha256
-        (base32
-         "1dspwi28krinkxdd7waq4y6plz0dfmzz72885p9pcqp1r14qrhj3"))))
+    (version "0.4.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "repline" version))
+              (sha256
+               (base32
+                "0nldn02yqqmrxkzwzrx3v6hkb4y2hch48jkcr2qrw1dl0vqv70b1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "repline")))
-    (inputs
-     (list ghc-exceptions ghc-haskeline))
     (home-page "https://github.com/sdiehl/repline")
     (synopsis "Haskeline wrapper for GHCi-like REPL interfaces")
     (description
@@ -10347,22 +9775,20 @@ normal mtl transformers.")
 (define-public ghc-rerebase
   (package
     (name "ghc-rerebase")
-    (version "1.13.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "rerebase" version))
-       (sha256
-        (base32
-         "0j50l96whwi65ir35nfhn24h6103zy1ilfjsqiax63ajzw169fkv"))))
+    (version "1.16.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "rerebase" version))
+              (sha256
+               (base32
+                "04pw2j4nh8x53axmfzp9d2plmiwxpxddgwcji0a8j24lkdyv8k32"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "rerebase")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-rebase))
+    (inputs (list ghc-rebase))
     (home-page "https://github.com/nikita-volkov/rerebase")
     (synopsis "Reexports from ``base'' with many other standard libraries")
-    (description "A rich drop-in replacement for @code{base}.  For details and
+    (description
+     "A rich drop-in replacement for @code{base}.  For details and
 documentation please visit @uref{https://github.com/nikita-volkov/rerebase,
 the project's home page}.")
     (license license:expat)))
@@ -10381,9 +9807,16 @@ the project's home page}.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "resolv")))
     (arguments
-     `(#:tests? #f ; TODO: tasty >=1.2.3 && <1.3 || >=1.3.1 && <1.4
-       #:cabal-revision
-       ("3" "0af5dsdyn04i76d012xhhfkkml10bqzl6q2yivkhf8rlvh1fiii5")))
+     `(;#:tests? #f ; tasty >=1.2.3 && <1.3 || >=1.3.1 && <1.4
+       #:cabal-revision ("5"
+                         "0df5y8bj9bxjmqnkvpwxvb17k70g1i174xs6vfrv9f1lys7xkqk1")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "resolv.cabal"
+               (("\\b(tasty)\\s+[^,]+" all dep)
+                dep)))))))
     (inputs
      (list ghc-base16-bytestring))
     (native-inputs
@@ -10422,26 +9855,18 @@ connections.")
 (define-public ghc-resourcet
   (package
     (name "ghc-resourcet")
-    (version "1.2.4.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "resourcet" version))
-       (sha256
-        (base32
-         "0zrvnikw1a0r2j59k12fxikyrg0ki5a7xhqhjgfl9h6dqpz54h85"))))
+    (version "1.2.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "resourcet" version))
+              (sha256
+               (base32
+                "0d7xnpysrick56gxzkkj0mpblywbxaaldhziyl77am3822r3afzq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "resourcet")))
-    (inputs
-     (list ghc-transformers-base
-           ghc-monad-control
-           ghc-transformers-compat
-           ghc-mmorph
-           ghc-exceptions
-           ghc-unliftio-core))
-    (native-inputs
-     (list ghc-lifted-base ghc-hspec))
-    (home-page "https://github.com/snoyberg/conduit")
+    (inputs (list ghc-unliftio-core ghc-primitive))
+    (native-inputs (list ghc-hspec))
+    (home-page "http://github.com/snoyberg/conduit")
     (synopsis "Deterministic allocation and freeing of scarce resources")
     (description "ResourceT is a monad transformer which creates a region of
 code where you can safely allocate resources.")
@@ -10450,24 +9875,22 @@ code where you can safely allocate resources.")
 (define-public ghc-retry
   (package
     (name "ghc-retry")
-    (version "0.8.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "retry" version))
-       (sha256
-        (base32
-         "0nwyis42xpmxfw8nz8qn59r3v7q0dkfzkzkhllgn30cdjbbmwhf5"))))
+    (version "0.9.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "retry" version))
+              (sha256
+               (base32
+                "1kafm17xk6hylr0lwa98wxjcx7z3rgnqi4fzxcks7dy9dz5ms7n1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "retry")))
-    (inputs
-     (list ghc-exceptions ghc-random))
-    (native-inputs
-     (list ghc-hunit ghc-tasty ghc-tasty-hunit ghc-tasty-hedgehog
-           ghc-hedgehog))
-    (home-page "https://github.com/Soostone/retry")
+    (inputs (list ghc-random ghc-mtl-compat ghc-unliftio-core))
+    (native-inputs (list ghc-hunit ghc-tasty ghc-tasty-hunit
+                         ghc-tasty-hedgehog ghc-hedgehog))
+    (home-page "http://github.com/Soostone/retry")
     (synopsis "Retry combinators for monadic actions that may fail")
-    (description "This package exposes combinators that can wrap
+    (description
+     "This package exposes combinators that can wrap
 arbitrary monadic actions.  They run the action and potentially retry
 running it with some configurable delay for a configurable number of
 times.  The purpose is to make it easier to work with IO and especially
@@ -10503,31 +9926,29 @@ better for some purposes.")
 (define-public ghc-rio
   (package
     (name "ghc-rio")
-    (version "0.1.21.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "rio" version))
-       (sha256
-        (base32
-         "013m4xgsmg8h1rba9krxppz49lc5wz26gksms5zibsjj0w59m58h"))))
+    (version "0.1.22.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "rio" version))
+              (sha256
+               (base32
+                "0rpc4f2yvw0y6mqz9ykm3778j6srya7ssww691kpf9nb8vddgjb6"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "rio")))
-    (inputs
-     (list ghc-hashable
-           ghc-microlens
-           ghc-microlens-mtl
-           ghc-primitive
-           ghc-typed-process
-           ghc-unliftio-core
-           ghc-unliftio
-           ghc-unordered-containers
-           ghc-vector))
-    (native-inputs
-     (list ghc-hspec ghc-quickcheck hspec-discover))
+    (inputs (list ghc-hashable
+                  ghc-microlens
+                  ghc-microlens-mtl
+                  ghc-primitive
+                  ghc-typed-process
+                  ghc-unliftio
+                  ghc-unliftio-core
+                  ghc-unordered-containers
+                  ghc-vector))
+    (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover))
     (home-page "https://github.com/commercialhaskell/rio#readme")
     (synopsis "Standard library for Haskell")
-    (description "This package works as a prelude replacement for Haskell,
+    (description
+     "This package works as a prelude replacement for Haskell,
 providing more functionality and types out of the box than the standard
 prelude (such as common data types like @code{ByteString} and
 @code{Text}), as well as removing common ``gotchas'', like partial
@@ -10553,6 +9974,14 @@ expose it from another module in the hierarchy.
     (build-system haskell-build-system)
     (properties '((upstream-name . "roman-numerals")))
     (inputs (list ghc-base-unicode-symbols))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "roman-numerals.cabal"
+               (("\\b(bytestring)\\s+[^,]+" all dep)
+                dep)))))))
     (home-page "https://github.com/roelvandijk/roman-numerals")
     (synopsis "Parsing and pretty printing of Roman numerals")
     (description
@@ -10587,21 +10016,20 @@ exceptions.")
 (define-public ghc-safe-exceptions
   (package
     (name "ghc-safe-exceptions")
-    (version "0.1.7.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "safe-exceptions" version))
-       (sha256
-        (base32
-         "15a80s87f603w8l7fnaba2cyqx62042vvcidpjzyga2685wpyqv9"))))
+    (version "0.1.7.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "safe-exceptions" version))
+              (sha256
+               (base32
+                "1gxm61mccivrdz2qcfh5sim596nbrpapx0nli0bx7vx6z3c2ikli"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "safe-exceptions")))
-    (native-inputs
-     (list ghc-hspec ghc-void hspec-discover))
-    (home-page "https://github.com/fpco/safe-exceptions")
+    (native-inputs (list ghc-hspec ghc-void hspec-discover))
+    (home-page "https://github.com/fpco/safe-exceptions#readme")
     (synopsis "Safe, consistent, and easy exception handling")
-    (description "Runtime exceptions - as exposed in @code{base} by the
+    (description
+     "Runtime exceptions - as exposed in @code{base} by the
 @code{Control.Exception} module - have long been an intimidating part of the
 Haskell ecosystem.  This package is intended to overcome this.  It provides a
 safe and simple API on top of the existing exception handling machinery.  The
@@ -10629,6 +10057,7 @@ handling wrong.")
     (native-inputs
      (list ghc-hunit ghc-test-framework ghc-test-framework-hunit
            ghc-test-framework-th))
+    (arguments (list #:tests? #f)) ; Fail to build: Module ‘Data.ByteString’ does not export ‘hPutStrLn’.
     (home-page "https://github.com/luispedro/safeio")
     (synopsis "Write output to disk atomically")
     (description
@@ -10738,6 +10167,9 @@ as sending some messages to the terminal - that has the following properties:
            ghc-tasty-quickcheck
            ghc-smallcheck
            ghc-quickcheck))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "1n67w1b64q59nn4845z3kr8rm0x0p7bi3cyp6n1dpnfs8k4l8x2i")))
     (home-page "https://github.com/basvandijk/scientific")
     (synopsis "Numbers represented using scientific notation")
     (description "This package provides @code{Data.Scientific}, which provides
@@ -10786,22 +10218,22 @@ award winning Linux port of \"Civilization: Call To Power.\"")
 (define-public ghc-sdl2
   (package
     (name "ghc-sdl2")
-    (version "2.5.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "sdl2" version))
-       (sha256
-        (base32
-         "08l24cb92spnx3bn26bj0z2cszpsawhaa9vvhblvsr3d6z76065q"))))
+    (version "2.5.4.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "sdl2" version))
+              (sha256
+               (base32
+                "1g35phifz49kxk48s8jmgglxhxl79cbzc1cg2qlgk0vdpxpin8ym"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "sdl2")))
-    (arguments '(#:tests? #f)) ; tests require graphical environment
-    (inputs
-     (list ghc-exceptions ghc-linear ghc-statevar ghc-vector sdl2))
-    (native-inputs
-     (list ghc-weigh pkg-config))
-    (home-page "https://hackage.haskell.org/package/sdl2")
+    (inputs (list ghc-statevar ghc-vector ghc-linear sdl2))
+    (native-inputs (list ghc-weigh pkg-config))
+    (arguments
+     `(#:tests? #f ; Needs a graphics card.
+       #:cabal-revision ("2"
+                         "1yxzq4gb6ig3d94lc76i5d50fa0j1fxr1wdlmgwhkvlfd4xnh6sg")))
+    (home-page "http://hackage.haskell.org/package/sdl2")
     (synopsis "High- and low-level bindings to the SDL library")
     (description
      "This package contains bindings to the SDL 2 library, in both high- and
@@ -10817,21 +10249,18 @@ programming.")
 (define-public ghc-sdl2-image
   (package
     (name "ghc-sdl2-image")
-    (version "2.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "sdl2-image" version))
-       (sha256
-        (base32
-         "1pr6dkg73cy9z0w54lrkj9c5bhxj56nl92lxikjy8kz6nyr455rr"))))
+    (version "2.1.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "sdl2-image" version))
+              (sha256
+               (base32
+                "03cjlmj844gmfxqn9mp8333hpsg227kaipgs6g68xwg0cvch696j"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "sdl2-image")))
-    (inputs
-     (list ghc-sdl2 sdl2-image))
-    (native-inputs
-     (list pkg-config))
-    (home-page "https://hackage.haskell.org/package/sdl2-image")
+    (inputs (list ghc-sdl2 sdl2-image))
+    (native-inputs (list pkg-config))
+    (home-page "http://hackage.haskell.org/package/sdl2-image")
     (synopsis "Bindings to SDL2_image")
     (description "This package provides Haskell bindings to
 @code{SDL2_image}.")
@@ -10840,26 +10269,19 @@ programming.")
 (define-public ghc-sdl2-mixer
   (package
     (name "ghc-sdl2-mixer")
-    (version "1.1.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "sdl2-mixer" version))
-       (sha256
-        (base32
-         "1k8avyccq5l9z7bwxigim312yaancxl1sr3q6a96bcm7pnhiak0g"))))
+    (version "1.2.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "sdl2-mixer" version))
+              (sha256
+               (base32
+                "16fgnxq2nmifbz3lrr7dn1qj57l5f2kzv124lya1fjaxmwk1h52q"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "sdl2-mixer")))
-    (inputs
-     (list ghc-data-default-class
-           ghc-lifted-base
-           ghc-monad-control
-           ghc-sdl2
-           ghc-vector
-           sdl2-mixer))
-    (native-inputs
-     (list pkg-config))
-    (home-page "https://hackage.haskell.org/package/sdl2-mixer")
+    (inputs (list ghc-data-default-class ghc-lifted-base ghc-monad-control
+                  ghc-sdl2 ghc-vector sdl2-mixer))
+    (native-inputs (list pkg-config))
+    (home-page "http://hackage.haskell.org/package/sdl2-mixer")
     (synopsis "Bindings to SDL2 mixer")
     (description "This package provides Haskell bindings to
 @code{SDL2_mixer}.")
@@ -10944,28 +10366,28 @@ a memory chunk that will be auto-scrubbed after it run out of scope.")
 (define-public ghc-semialign
   (package
     (name "ghc-semialign")
-    (version "1.1.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "semialign" version))
-       (sha256
-        (base32
-         "11qs4imy3cq4cx9mm6g30r6qk3rngqrmz7lkl5379gs1yvgvs44q"))))
+    (version "1.2.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "semialign" version))
+              (sha256
+               (base32
+                "0ci1jpp37p1lzyjxc1bljd6zgg407qmkl9s36b50qjxf85q6j06r"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "semialign")))
-    (inputs
-     (list ghc-these
-           ghc-base-compat
-           ghc-hashable
-           ghc-tagged
-           ghc-unordered-containers
-           ghc-vector
-           ghc-semigroupoids))
-    (home-page
-     "https://github.com/isomorphism/these")
-    (synopsis
-     "Align and Zip type-classes from the common Semialign ancestor")
+    (inputs (list ghc-these
+                  ghc-hashable
+                  ghc-indexed-traversable
+                  ghc-indexed-traversable-instances
+                  ghc-tagged
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-semigroupoids))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0dbcdnksik508i12arh3s6bis6779lx5f1df0jkc0bp797inhd7f")))
+    (home-page "https://github.com/haskellari/these")
+    (synopsis "Align and Zip type-classes from the common Semialign ancestor")
     (description
      "The major use of @code{These} of this is provided by the
 @code{align} member of @code{Semialign} class, representing a
@@ -10978,31 +10400,29 @@ class, forming lattice-like structure.")
 (define-public ghc-semigroupoids
   (package
     (name "ghc-semigroupoids")
-    (version "5.3.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "semigroupoids" version))
-       (sha256
-        (base32
-         "0glhqc9x8i5z3bdg23xvl2lfns95msid3h3x0jksna7i6c8j869n"))))
+    (version "5.3.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "semigroupoids" version))
+              (sha256
+               (base32
+                "169pjrm7lxjxrqj5q1iyl288bx5nj8n0pf2ri1cclxccqnvcsibd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "semigroupoids")))
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-base-orphans
-           ghc-transformers-compat
-           ghc-bifunctors
-           ghc-comonad
-           ghc-contravariant
-           ghc-distributive
-           ghc-generic-deriving
-           ghc-hashable
-           ghc-tagged
-           ghc-unordered-containers))
-    (home-page "https://github.com/ekmett/semigroupoids")
+    (inputs (list ghc-base-orphans
+                  ghc-bifunctors
+                  ghc-transformers-compat
+                  ghc-generic-deriving
+                  ghc-contravariant
+                  ghc-distributive
+                  ghc-comonad
+                  ghc-tagged
+                  ghc-hashable
+                  ghc-unordered-containers))
+    (home-page "http://github.com/ekmett/semigroupoids")
     (synopsis "Semigroupoids operations for Haskell")
-    (description "This library provides a wide array of (semi)groupoids and
+    (description
+     "This library provides a wide array of (semi)groupoids and
 operations for working with them.  A @code{Semigroupoid} is a @code{Category}
 without the requirement of identity arrows for every object in the category.
 A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
@@ -11010,26 +10430,26 @@ Finally, to work with these weaker structures it is beneficial to have
 containers that can provide stronger guarantees about their contents, so
 versions of @code{Traversable} and @code{Foldable} that can be folded with
 just a @code{Semigroup} are added.")
-    (license license:bsd-3)))
+    (license license:bsd-2)))
 
 (define-public ghc-semigroups
   (package
     (name "ghc-semigroups")
-    (version "0.19.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "semigroups" version))
-       (sha256
-        (base32
-         "0h1sl3i6k8csy5zkkpy65rxzds9wg577z83aaakybr3n1gcv4855"))))
+    (version "0.20")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "semigroups" version))
+              (sha256
+               (base32
+                "1qbk6scp1rzb69dy8mz26p6az5vi16g2lzwmwnfshh3br4rjwbch"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "semigroups")))
-    (inputs
-     (list ghc-nats ghc-tagged ghc-unordered-containers ghc-hashable))
-    (home-page "https://github.com/ekmett/semigroups/")
+    (inputs (list ghc-nats ghc-tagged ghc-hashable ghc-unordered-containers
+                  ghc-transformers-compat))
+    (home-page "http://github.com/ekmett/semigroups/")
     (synopsis "Semigroup operations for Haskell")
-    (description "This package provides semigroups for Haskell.  In
+    (description
+     "This package provides semigroups for Haskell.  In
 mathematics, a semigroup is an algebraic structure consisting of a set
 together with an associative binary operation.  A semigroup generalizes a
 monoid in that there might not exist an identity element.  It
@@ -11082,29 +10502,28 @@ by @code{0} annihilates R.")
 (define-public ghc-serialise
   (package
     (name "ghc-serialise")
-    (version "0.2.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "serialise" version))
-       (sha256
-        (base32
-         "0vp4wyxpximpx10pssfgdsir1pc23zb62fg3kj3iblpzqfrryy69"))))
+    (version "0.2.6.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "serialise" version))
+              (sha256
+               (base32
+                "05m5h5vfjp4wvh6y7j2f3d4c3l6gxww2n1v38vqrjacpw641izwk"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "serialise")))
-    (inputs
-     (list ghc-cborg
-           ghc-half
-           ghc-hashable
-           ghc-primitive
-           ghc-unordered-containers
-           ghc-vector))
-    (native-inputs
-     (list ghc-quickcheck ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck
-           ghc-quickcheck-instances))
+    (inputs (list ghc-cborg
+                  ghc-half
+                  ghc-hashable
+                  ghc-primitive
+                  ghc-strict
+                  ghc-these
+                  ghc-unordered-containers
+                  ghc-vector))
+    (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-hunit
+                         ghc-tasty-quickcheck ghc-quickcheck-instances))
     (arguments
-     `(#:cabal-revision
-       ("2" "1qcsp15v0swxy2qlvc40fil09zq32y3wl00y3passc2a4b4yhmr4")))
+     `(#:cabal-revision ("1"
+                         "0rlsi4jq2d1dak2fps5flcn27lywjlhvsi0x2k2lvnjqawnfb3f9")))
     (home-page "https://github.com/well-typed/cborg")
     (synopsis "Binary serialisation library for Haskell values")
     (description
@@ -11155,6 +10574,9 @@ environment variables.")
                 "19rv89jkhq5ic7j5rzpygnmsbzim2mn8ip0m292za613q88gywir"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "setlocale")))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1k4idj2xl9dg5nfz128xazrrydz9mgm3bbjrc0cyby8n3c0ij9x1")))
     (home-page "https://hackage.haskell.org/package/setlocale")
     (synopsis "Haskell bindings to setlocale")
     (description "This package provides Haskell bindings to the
@@ -11164,27 +10586,28 @@ environment variables.")
 (define-public ghc-shakespeare
   (package
     (name "ghc-shakespeare")
-    (version "2.0.25")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "shakespeare" version))
-       (sha256
-        (base32
-         "1fjv3yg425d87d3dih0l3ff95g5a5yp9w85m58sjara6xqivj9s4"))))
+    (version "2.0.30")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "shakespeare" version))
+              (sha256
+               (base32
+                "038yprj9yig2xbjs2pqsjzs4pl9ir2frdz9wn2pklc4kvdazx3aw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "shakespeare")))
     (inputs (list ghc-aeson
                   ghc-blaze-markup
                   ghc-blaze-html
+                  ghc-file-embed
                   ghc-vector
-                  ghc-th-lift
                   ghc-unordered-containers
-                  ghc-scientific))
+                  ghc-scientific
+                  ghc-th-lift))
     (native-inputs (list ghc-hspec ghc-hunit hspec-discover))
-    (home-page "https://www.yesodweb.com/book/shakespearean-templates")
+    (home-page "http://www.yesodweb.com/book/shakespearean-templates")
     (synopsis "Family of type-safe template languages for Haskell")
-    (description "This Haskell package provides a family of type-safe
+    (description
+     "This Haskell package provides a family of type-safe
 templates with simple variable interpolation.  Shakespeare templates can
 be used inline with a quasi-quoter or in an external file and it
 interpolates variables according to the type being inserted.")
@@ -11193,30 +10616,26 @@ interpolates variables according to the type being inserted.")
 (define-public ghc-shelly
   (package
     (name "ghc-shelly")
-    (version "1.9.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "shelly" version))
-       (sha256
-        (base32
-         "1kma77gixhyciimh19p64h1ndbcrs9qhk8fgyv71iqh5q57zvday"))))
+    (version "1.10.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "shelly" version))
+              (sha256
+               (base32
+                "0hgzh0rrhipir8378civ5mwvkvcsd063jm2pyx8dqngdynph0h65"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "shelly")))
-    (inputs
-     (list ghc-unix-compat
-           ghc-system-filepath-bootstrap
-           ghc-system-fileio-bootstrap
-           ghc-monad-control
-           ghc-lifted-base
-           ghc-lifted-async
-           ghc-exceptions
-           ghc-enclosed-exceptions
-           ghc-async
-           ghc-transformers-base
-           ghc-hunit
-           ghc-hspec
-           ghc-hspec-contrib))
+    (inputs (list ghc-async
+                  ghc-enclosed-exceptions
+                  ghc-lifted-async
+                  ghc-lifted-base
+                  ghc-monad-control
+                  ghc-transformers-base
+                  ghc-unix-compat))
+    (native-inputs (list ghc-hspec ghc-hspec-contrib ghc-hunit))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "07c1rjwvg2ldam6yaksvrr9f703b7d1rcw0482ns5yi2f7y1kczp")))
     (home-page "https://github.com/yesodweb/Shelly.hs")
     (synopsis "Shell-like (systems) programming in Haskell")
     (description
@@ -11227,23 +10646,30 @@ spirit to POSIX shells.  Shelly is originally forked  from the Shellish package.
 (define-public ghc-silently
   (package
     (name "ghc-silently")
-    (version "1.2.5.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "silently" version))
-       (sha256
-        (base32
-         "1lgs1gsr5dp0x21diqn4l03fxgai2kgdmj85gqp0iz3zykvbmjbz"))))
+    (version "1.2.5.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "silently" version))
+              (sha256
+               (base32
+                "0wk3yci4r9v0vwyzylj3k07damz17jwc6n6imwqahf4lsapsz7ds"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "silently")))
-    (arguments `(#:tests? #f)) ;; circular dependency with nanospec
+    (native-inputs (list ghc-nanospec ghc-temporary))
     (home-page "https://github.com/hspec/silently")
     (synopsis "Prevent writing to stdout")
     (description "This package provides functions to prevent or capture
 writing to stdout and other handles.")
     (license license:bsd-3)))
 
+(define-public ghc-silently-bootstrap
+  (package
+    (inherit ghc-silently)
+    (name "ghc-silently-bootstrap")
+    (arguments `(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
 (define-public ghc-simple-reflect
   (package
     (name "ghc-simple-reflect")
@@ -11295,30 +10721,17 @@ are the bottleneck of web servers.")
 (define-public ghc-size-based
   (package
     (name "ghc-size-based")
-    (version "0.1.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "size-based" version))
-       (sha256
-        (base32
-         "06hmlic0n73ncwlkpx49xlv09bzsrr27ncnp5byhzlknak2gd7vp"))))
+    (version "0.1.3.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "size-based" version))
+              (sha256
+               (base32
+                "1x2z8iw4jgcp6xirclifjhh3rvyjy5xgqrd6lcv4gifj859sfjd2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "size-based")))
-    (inputs
-     (list ghc-dictionary-sharing ghc-testing-type-modifiers
-           ghc-template-haskell))
-    (arguments
-     `(#:cabal-revision
-       ("1" "0kax1ypjyglkn6iff1x4yz12y7f2n249m95xvdhrc63hsa4xlcqv")
-       #:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "size-based.cabal"
-               (("(template-haskell)\\s+.+$" all dep)
-                (string-append dep "\n"))))))))
-    (home-page "https://hackage.haskell.org/package/size-based")
+    (inputs (list ghc-dictionary-sharing ghc-testing-type-modifiers))
+    (home-page "http://hackage.haskell.org/package/size-based")
     (synopsis "Sized functors for size-based enumerations")
     (description "This library provides a framework for size-based
 enumerations.")
@@ -11327,13 +10740,13 @@ enumerations.")
 (define-public ghc-skylighting-core
   (package
     (name "ghc-skylighting-core")
-    (version "0.10.5.2")
+    (version "0.13.2")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "skylighting-core" version))
               (sha256
                (base32
-                "0bskci0gng6nf324wna9ss4xbr1mwjkgk3mlfkr96r1m3wza5g3d"))))
+                "0iwzfgynj3l8rnvvrl4kg0i1n31rz15da8cf1943gw1vcfh6w585"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "skylighting-core")))
     (inputs
@@ -11364,20 +10777,115 @@ supported by that framework can be added.  An optional command-line program is
 provided.  Skylighting is intended to be the successor to highlighting-kate.")
     (license license:gpl2)))
 
+(define-public ghc-skylighting-format-blaze-html
+  (package
+    (name "ghc-skylighting-format-blaze-html")
+    (version "0.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "skylighting-format-blaze-html" version))
+              (sha256
+               (base32
+                "04zg92x1jnzv6hac6wdgksgma7gi5g82x2kdxk8r7pk9yd6rn4xi"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "skylighting-format-blaze-html")))
+    (inputs (list ghc-skylighting-core ghc-blaze-html))
+    (home-page "https://github.com/jgm/skylighting")
+    (synopsis "HTML formatter for skylighting syntax highlighting library")
+    (description
+     "This module allows tokens produced by skylighting-core to be rendered as HTML.")
+    (license license:bsd-3)))
+
+(define-public ghc-skylighting-format-latex
+  (package
+    (name "ghc-skylighting-format-latex")
+    (version "0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "skylighting-format-latex" version))
+              (sha256
+               (base32
+                "0y7v5aifwar24i976pw32scfdywjwy2ad05ajhdf8l84nsd6rdlp"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "skylighting-format-latex")))
+    (inputs (list ghc-skylighting-core))
+    (home-page "https://github.com/jgm/skylighting")
+    (synopsis "LaTeX formatter for skylighting syntax highlighting library")
+    (description
+     "This module allows tokens produced by skylighting-core to be rendered as LaTeX
+macros.")
+    (license license:bsd-3)))
+
+(define-public ghc-skylighting-format-context
+  (package
+    (name "ghc-skylighting-format-context")
+    (version "0.1.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "skylighting-format-context" version))
+              (sha256
+               (base32
+                "1d4nf16wl2l4r627qnph09x21xwcq03r7bznqm08d4di1z241xv0"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "skylighting-format-context")))
+    (inputs (list ghc-skylighting-core))
+    (home-page "https://github.com/jgm/skylighting")
+    (synopsis "ConTeXt formatter for skylighting syntax highlighting library")
+    (description
+     "This module allows tokens produced by skylighting-core to be rendered as ConTeXt
+commands.")
+    (license license:bsd-3)))
+
+(define-public ghc-skylighting-format-ansi
+  (package
+    (name "ghc-skylighting-format-ansi")
+    (version "0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "skylighting-format-ansi" version))
+              (sha256
+               (base32
+                "16qavv10g5yqwi60axj7q595ll605vmnfjgdxyi029nd5rnaipr3"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "skylighting-format-ansi")))
+    (inputs (list ghc-skylighting-core ghc-ansi-terminal ghc-colour))
+    (home-page "https://github.com/jgm/skylighting")
+    (synopsis "ANSI formatter for skylighting syntax highlighting library")
+    (description
+     "This module allows tokens produced by skylighting-core to be rendered as ANSI
+colored text.")
+    (license license:bsd-3)))
+
 (define-public ghc-skylighting
   (package
-    (inherit ghc-skylighting-core)
     (name "ghc-skylighting")
-    (version "0.10.5.2")
+    (version "0.13.2")
     (source (origin
               (method url-fetch)
-              (uri (hackage-uri "skylighting-core" version))
+              (uri (hackage-uri "skylighting" version))
               (sha256
                (base32
-                "152ywiy7h04xjy0fdl571jwahl6c9350isqbm4p0na4cjd9cczzh"))))
-    (inputs
-     (modify-inputs (package-inputs ghc-skylighting-core)
-       (prepend ghc-skylighting-core)))))
+                "0dh4k39ddqca5px2d06ni8n9x3mifvkwd5i16077l472dwjcs879"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "skylighting")))
+    (inputs (list ghc-skylighting-core
+                  ghc-skylighting-format-ansi
+                  ghc-skylighting-format-context
+                  ghc-skylighting-format-latex
+                  ghc-skylighting-format-blaze-html
+                  ghc-pretty-show
+                  ghc-blaze-html))
+    (home-page "https://github.com/jgm/skylighting")
+    (synopsis "syntax highlighting library")
+    (description
+     "Skylighting is a syntax highlighting library with support for over one hundred
+languages.  It derives its tokenizers from XML syntax definitions used by KDE's
+KSyntaxHighlighting framework, so any syntax supported by that framework can be
+added.  An optional command-line program is provided.  Skylighting is intended
+to be the successor to highlighting-kate.  This package provides generated
+syntax modules based on the KDE XML definitions provided by the
+@code{skylighting-core} package.")
+    (license license:gpl2)))
 
 (define-public ghc-smallcheck
   (package
@@ -11425,19 +10933,22 @@ automatically by SmallCheck.")
 (define-public ghc-sop-core
   (package
     (name "ghc-sop-core")
-    (version "0.5.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "sop-core" version))
-       (sha256
-        (base32
-         "1c4xk4bw1ij4gpgy35iv08bhcxhv1siy55qnvp2xd6wcc3qnghys"))))
+    (version "0.5.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "sop-core" version))
+              (sha256
+               (base32
+                "0rbj56icbaqlcxx5xwvbx4n4vmyv6cfcv7s45n1fv3drahigvgw7"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "sop-core")))
-    (home-page "https://hackage.haskell.org/package/sop-core")
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1p6zyqja021gyndskn1qnj29glqr0hldyhxplnpxz06hz4xqwngz")))
+    (home-page "http://hackage.haskell.org/package/sop-core")
     (synopsis "True Sums of Products")
-    (description "This package provides an implementation of
+    (description
+     "This package provides an implementation of
 @math{n}-ary sums and @math{n}-ary products.  The module @code{Data.SOP}
 is the main module of this library and contains more detailed
 documentation.  The main use case of this package is to serve as the
@@ -11460,6 +10971,9 @@ generics-sop}.")
     (properties '((upstream-name . "special-values")))
     (inputs
      (list ghc-scientific ghc-ieee754 ghc-nats))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1vv5gydjd65jniifl3mnch8bzvpvdahi913gsa3kv5zijwhad699")))
     (home-page
      "https://github.com/minad/special-values#readme")
     (synopsis "Typeclass providing special values")
@@ -11471,24 +10985,20 @@ used for example by QuickCheck, see quickcheck-special."  )
 (define-public ghc-split
   (package
     (name "ghc-split")
-    (version "0.2.3.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "split" version))
-       (sha256
-        (base32
-         "0ahzdjcxw5wywr3w4msspia99k6fkckddam1m5506h4z9h8fa7r7"))))
+    (version "0.2.3.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "split" version))
+              (sha256
+               (base32
+                "0n9ip49laq5jwqw0c43lhf69ii8y4lwci9j6d5bjnjim23bai2mz"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "split")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "06pmlvyrz4rr7rsrghpyrdypprphm9522rvnz4l3i8333n4pb304")))
-    (native-inputs
-     (list ghc-quickcheck))
-    (home-page "https://hackage.haskell.org/package/split")
+    (native-inputs (list ghc-quickcheck))
+    (home-page "http://hackage.haskell.org/package/split")
     (synopsis "Combinator library for splitting lists")
-    (description "This package provides a collection of Haskell functions for
+    (description
+     "This package provides a collection of Haskell functions for
 splitting lists into parts, akin to the @code{split} function found in several
 mainstream languages.")
     (license license:bsd-3)))
@@ -11496,30 +11006,36 @@ mainstream languages.")
 (define-public ghc-splitmix
   (package
     (name "ghc-splitmix")
-    (version "0.1.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "splitmix" version))
-       (sha256
-        (base32
-         "0das5n44dhlcv5i233iakx37d17kidqvhrvp6w9nd7hc015ry026"))))
+    (version "0.1.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "splitmix" version))
+              (sha256
+               (base32
+                "1apck3nzzl58r0b9al7cwaqwjhhkl8q4bfrx14br2yjf741581kd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "splitmix")))
-    (native-inputs
-     (list ghc-async
-           ghc-base-compat-batteries
-           ghc-base-compat
-           ghc-hunit
-           ghc-math-functions
-           ghc-random-bootstrap
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-tf-random
-           ghc-vector))
-    (home-page "https://hackage.haskell.org/package/splitmix")
+    (native-inputs (list ghc-hunit
+                         ghc-base-compat
+                         ghc-hunit
+                         ghc-math-functions
+                         ghc-test-framework
+                         ghc-test-framework-hunit
+                         ghc-async
+                         ghc-base-compat-batteries
+                         ghc-random
+                         ghc-tf-random
+                         ghc-vector
+                         ghc-base-compat-batteries
+                         ghc-hunit))
+    (arguments
+     `(#:tests? #f ; Missing library testu01.
+       #:cabal-revision ("1"
+                         "1iqlg2d4mybqwzwp67c5a1yxzd47cbp4f7mrpa6d0ckypis2akl0")))
+    (home-page "http://hackage.haskell.org/package/splitmix")
     (synopsis "Fast and splittable pseudorandom number generator")
-    (description "This package provides a Pure Haskell implementation of the
+    (description
+     "This package provides a Pure Haskell implementation of the
 SplitMix pseudorandom number generator.  SplitMix is a \"splittable\"
 pseudorandom number generator that is quite fast: 9 64-bit
 arithmetic/logical operations per 64 bits generated.  SplitMix is tested
@@ -11592,41 +11108,39 @@ in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
 (define-public ghc-statistics
   (package
     (name "ghc-statistics")
-    (version "0.15.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "statistics" version))
-       (sha256
-        (base32
-         "0j9awbg47fzb58k5z2wgkp6a0042j7hqrl1g6lyflrbsfswdp5n4"))))
+    (version "0.16.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "statistics" version))
+              (sha256
+               (base32
+                "15yr0w25dqaqz16635qxkxvr6nj6mkjj9pl7wzw5yr3pn84xjryq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "statistics")))
-    (inputs
-     (list ghc-aeson
-           ghc-async
-           ghc-base-orphans
-           ghc-data-default-class
-           ghc-dense-linear-algebra
-           ghc-math-functions
-           ghc-monad-par
-           ghc-mwc-random
-           ghc-primitive
-           ghc-vector
-           ghc-vector-algorithms
-           ghc-vector-th-unbox
-           ghc-vector-binary-instances))
-    (native-inputs
-     (list ghc-erf
-           ghc-ieee754
-           ghc-quickcheck
-           ghc-tasty-expected-failure
-           ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck))
-    (home-page "https://github.com/bos/mwc-random")
+    (inputs (list ghc-math-functions
+                  ghc-mwc-random
+                  ghc-random
+                  ghc-aeson
+                  ghc-async
+                  ghc-primitive
+                  ghc-dense-linear-algebra
+                  ghc-parallel
+                  ghc-vector
+                  ghc-vector-algorithms
+                  ghc-vector-th-unbox
+                  ghc-vector-binary-instances
+                  ghc-data-default-class))
+    (native-inputs (list ghc-quickcheck
+                         ghc-erf
+                         ghc-ieee754
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-tasty-expected-failure))
+    (home-page "https://github.com/haskell/statistics")
     (synopsis "Haskell library of statistical types, data, and functions")
-    (description "This library provides a number of common functions
+    (description
+     "This library provides a number of common functions
 and types useful in statistics.  We focus on high performance, numerical
 robustness, and use of good algorithms.  Where possible, we provide references
 to the statistical literature.
@@ -11756,22 +11270,21 @@ and Fortran complex data types.")
 (define-public ghc-storable-record
   (package
     (name "ghc-storable-record")
-    (version "0.0.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri
-        (hackage-uri "storable-record" version))
-       (sha256
-        (base32
-         "17nf0bx3g169cpslf8prr5h5lvxl389m23rbsyb3kdai45fibpwf"))))
+    (version "0.0.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "storable-record" version))
+              (sha256
+               (base32
+                "1d4c1ccbrpq8rnacsjib9nmxhgxk9yb1zxx1nvfavhqhv8nwq2fd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "storable-record")))
-    (inputs
-     (list ghc-semigroups ghc-utility-ht ghc-storablevector ghc-timeit))
-    (home-page "https://hackage.haskell.org/package/storable-record")
+    (inputs (list ghc-quickcheck ghc-semigroups ghc-utility-ht
+                  ghc-storablevector ghc-timeit))
+    (home-page "http://code.haskell.org/~thielema/storable-record/")
     (synopsis "Elegant definition of Storable instances for records")
-    (description "With this package you can build a Storable instance of
+    (description
+     "With this package you can build a Storable instance of
 a record type from Storable instances of its elements in an elegant way.
 It does not do any magic, just a bit arithmetic to compute the right
 offsets, that would be otherwise done manually or by a preprocessor like
@@ -11827,6 +11340,13 @@ together.")
            ghc-unsafe
            ghc-quickcheck
            ghc-syb))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "storablevector.cabal"
+               (("bytestring >=0\\.9 && <0\\.11") "bytestring")))))))
     (home-page "https://wiki.haskell.org/Storable_Vector")
     (synopsis "Fast, packed, strict storable arrays with a list interface")
     (description "This library provides fast, packed, strict storable
@@ -11846,14 +11366,14 @@ a library that provides fusion with lazy lists.")
 (define-public ghc-streaming-commons
   (package
     (name "ghc-streaming-commons")
-    (version "0.2.1.1")
+    (version "0.2.2.5")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "streaming-commons" version))
        (sha256
         (base32
-         "1lmyx3wkjsayhy5yilzvy0kf8qwmycwlk26r1d8f3cxbfhkr7s52"))))
+         "0157xjz8nhr65y9rm7rdf3pnjlrsgaqam7qfg7nqq91bvfdq2l6a"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "streaming-commons")))
     (inputs
@@ -11881,6 +11401,9 @@ needed by various Haskell streaming data libraries, such as @code{conduit} and
     (properties '((upstream-name . "strict")))
     (inputs
      (list ghc-hashable ghc-these ghc-assoc))
+    (arguments
+     `(#:cabal-revision ("4"
+                         "0pdzqhy7z70m8gxcr54jf04qhncl1jbvwybigb8lrnxqirs5l86n")))
     (home-page "https://hackage.haskell.org/package/strict")
     (synopsis "Strict data types and String IO")
     (description
@@ -11973,8 +11496,8 @@ occurrences of a substring (the first in case of overlaps) with another.")
     (inputs
      (list ghc-blaze-builder ghc-hashable ghc-unordered-containers))
     (arguments
-     `(#:cabal-revision
-       ("3" "1zc7shja5i63rn7kd9mnq2m052qhp7nh44qy8qp93dm64v9m9pi2")))
+     `(#:cabal-revision ("6"
+                         "1cprm8ya1rdid4pz1dk6692mv0kqkaxrsqaxg83bca5z4dkgqi2z")))
     (home-page "https://github.com/diagrams/svg-builder.git")
     (synopsis "Domain-specific language for building Scalable Vector Graphics")
     (description "Easy-to-write domain-specific language (DSL) for
@@ -11984,23 +11507,20 @@ building Scalable Vector Graphics (SVG).")
 (define-public ghc-syb
   (package
     (name "ghc-syb")
-    (version "0.7.2.1")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "syb" version))
-       (sha256
-        (base32
-         "15ld5929n3lzfb5sy9nnm77x2l6i2sgsxw47jdrqcrz6fxpwc1qq"))))
+    (version "0.7.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "syb" version))
+              (sha256
+               (base32
+                "1qxjjndfwz2vvpz9707banmcn6jl2v6w6zp401zxaj327fccchw1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "syb")))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit))
-    (home-page
-     "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
     (synopsis "Scrap Your Boilerplate")
-    (description "This package contains the generics system described in the
+    (description
+     "This package contains the generics system described in the
 /Scrap Your Boilerplate/ papers (see
 @uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}).  It
 defines the @code{Data} class of types permitting folding and unfolding of
@@ -12208,9 +11728,10 @@ having to unsafely pass dummy arguments.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "tar")))
     (arguments
-     `(#:cabal-revision
-       ("4" "03a33nj9k62f318qgmp5pgk7i99c8cyqy5f7m7p0bwc5ni39ysfq")))
-    (inputs
+     `(#:tests? #f ; Failed! Exception: 'TruncatedArchive' (after 4 tests):
+       #:cabal-revision ("5"
+                         "15dqywn1lsyqb0nq1amj70mh1i079b7xwr02wbpcdzmdljg9c55w")))
+    (native-inputs
      (list ghc-bytestring-handle ghc-quickcheck ghc-tasty
            ghc-tasty-quickcheck))
     (home-page "https://hackage.haskell.org/package/tar")
@@ -12305,16 +11826,16 @@ This is a better maintained fork of the \"temporary\" package.")
 (define-public ghc-terminal-size
   (package
     (name "ghc-terminal-size")
-    (version "0.3.2.1")
+    (version "0.3.3")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "terminal-size" version))
               (sha256
                (base32
-                "0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm"))))
+                "1hv0r8gr1ms258rrz602gd5kziykkxw5zlnnzz5f42r0ly7lq5wc"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "terminal-size")))
-    (home-page "https://hackage.haskell.org/package/terminal-size")
+    (home-page "http://hackage.haskell.org/package/terminal-size")
     (synopsis "Get terminal window height and width")
     (description "Get terminal window height and width without ncurses
 dependency.")
@@ -12323,20 +11844,18 @@ dependency.")
 (define-public ghc-texmath
   (package
     (name "ghc-texmath")
-    (version "0.12.3.2")
+    (version "0.12.5.4")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "texmath" version))
               (sha256
                (base32
-                "1d9r3na7hmkgr0j63fs50ssll506l1wyqhw0dpap7jk0rdz8pv6n"))))
+                "1dn88s352y641c1vlj5j5mqwhnz6r1algkd7mx83y3fr0wp3nhlq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "texmath")))
-    (inputs
-     (list ghc-syb ghc-network-uri ghc-split ghc-xml ghc-pandoc-types))
-    (native-inputs
-     (list ghc-temporary ghc-utf8-string))
-    (home-page "https://github.com/jgm/texmath")
+    (inputs (list ghc-syb ghc-xml ghc-pandoc-types ghc-split))
+    (native-inputs (list ghc-pretty-show ghc-tasty ghc-tasty-golden ghc-tagged))
+    (home-page "http://github.com/jgm/texmath")
     (synopsis "Conversion between formats used to represent mathematics")
     (description
      "The texmath library provides functions to read and write TeX math,
@@ -12345,7 +11864,7 @@ Office).  Support is also included for converting math formats to pandoc's
 native format (allowing conversion, via pandoc, to a variety of different
 markup formats).  The TeX reader supports basic LaTeX and AMS extensions, and
 it can parse and apply LaTeX macros.")
-    (license license:gpl2+)))
+    (license license:gpl2)))
 
 (define-public ghc-text-binary
   (package
@@ -12371,20 +11890,17 @@ text package.")
 (define-public ghc-text-manipulate
   (package
     (name "ghc-text-manipulate")
-    (version "0.3.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "text-manipulate" version))
-       (sha256
-        (base32
-         "0pmzp38m3r0k6ps97b1wqplxlgvvlaid09x53jl3gxng0fwq910a"))))
+    (version "0.3.1.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "text-manipulate" version))
+              (sha256
+               (base32
+                "1g06ldl6cdnyr31xlks5qm1sj44ccrdvq4bf8dk032mzfkpyyrws"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "text-manipulate")))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit))
-    (home-page
-     "https://github.com/brendanhay/text-manipulate")
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "https://github.com/brendanhay/text-manipulate")
     (synopsis
      "Case conversion, word boundary manipulation, and textual subjugation")
     (description
@@ -12455,14 +11971,13 @@ Hashing\" by Claessen, Pałka for details and the rationale of the design.")
 (define-public ghc-th-abstraction
   (package
     (name "ghc-th-abstraction")
-    (version "0.4.3.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "th-abstraction" version))
-       (sha256
-        (base32
-         "01nyscmjriga4fh4362b4zjad48hdv33asjkd28sj8hx3pii7fy8"))))
+    (version "0.4.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "th-abstraction" version))
+              (sha256
+               (base32
+                "09hm0famyqsq09lal2ylnhsb31hybj8zanldi7cqncky4i7y5m80"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "th-abstraction")))
     (home-page "https://github.com/glguy/th-abstraction")
@@ -12477,21 +11992,17 @@ Template Haskell.")
 (define-public ghc-th-expand-syns
   (package
     (name "ghc-th-expand-syns")
-    (version "0.4.8.0")
+    (version "0.4.10.0")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "th-expand-syns" version))
               (sha256
                (base32
-                "1mw0yxfbmicv0irfrcz4s6pn39za7yjd7zz09ialwym1b46624si"))))
+                "044h1hv4b0ihpwr9wndj55fa843cbzqp1difgj9wyy3mw925higm"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "th-expand-syns")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "0l30cmwm20lgjpvr3a5yxj6429s1hqahjsij8z2ap88754phd41l")))
-    (inputs
-     (list ghc-syb ghc-th-abstraction))
-    (home-page "https://hackage.haskell.org/package/th-expand-syns")
+    (inputs (list ghc-syb ghc-th-abstraction))
+    (home-page "https://github.com/DanielSchuessler/th-expand-syns")
     (synopsis "Expands type synonyms in Template Haskell ASTs")
     (description
      "This package enables users to expand type synonyms in Template Haskell
@@ -12512,6 +12023,9 @@ Template Haskell.")
     (properties '((upstream-name . "th-lift")))
     (inputs
      (list ghc-th-abstraction))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1s95i774zy3q8yzk18ygdzhzky6wfcr7g55hd2g8h8lc05xzcdgi")))
     (home-page "https://github.com/mboes/th-lift")
     (synopsis "Derive Template Haskell's Lift class for datatypes")
     (description
@@ -12522,21 +12036,21 @@ datatypes.")
 (define-public ghc-th-lift-instances
   (package
     (name "ghc-th-lift-instances")
-    (version "0.1.18")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "th-lift-instances" version))
-       (sha256
-        (base32
-         "09nv1zsffvv6zfz1fjzcqrla3lc350qr4i4xf7wgvzp049sprrdy"))))
+    (version "0.1.20")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "th-lift-instances" version))
+              (sha256
+               (base32
+                "0w6qc7xzyjymhh8hv72rlszh3n2xyzzamlfcl1hs9k6xbbww6czm"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "th-lift-instances")))
-    (inputs
-     (list ghc-th-lift ghc-vector ghc-quickcheck))
-    (home-page "https://github.com/bennofs/th-lift-instances/")
+    (inputs (list ghc-vector ghc-th-lift))
+    (native-inputs (list ghc-quickcheck))
+    (home-page "http://github.com/bennofs/th-lift-instances/")
     (synopsis "Lift instances for template-haskell for common data types")
-    (description "Most data types in the Haskell platform do not have Lift
+    (description
+     "Most data types in the Haskell platform do not have Lift
 instances.  This package provides orphan instances for @code{containers},
 @code{text}, @code{bytestring} and @code{vector}.")
     (license license:bsd-3)))
@@ -12544,28 +12058,19 @@ instances.  This package provides orphan instances for @code{containers},
 (define-public ghc-th-orphans
   (package
     (name "ghc-th-orphans")
-    (version "0.13.12")
+    (version "0.13.14")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "th-orphans" version))
               (sha256
                (base32
-                "03n6qxnpxhbzyzbyrjq77d1y62dwgx39mmxfwmnc04l8pawgrxxz"))))
+                "0z07qcbbsj2b3j9p1qr4jvlpa7qgjfjvymkjd6vbizka1wd2mnwx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "th-orphans")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "0vfz9dl5g9xwp2zmwqc5gngyvjaqj3i0s97vbcslafcqhdqw3qaj")))
-    (inputs
-     (list ghc-th-lift
-           ghc-th-lift-instances
-           ghc-th-reify-many
-           ghc-th-compat
-           ghc-th-expand-syns
-           ghc-generic-deriving))
-    (native-inputs
-     (list ghc-hspec))
-    (home-page "https://hackage.haskell.org/package/th-orphans")
+    (inputs (list ghc-th-compat ghc-th-lift ghc-th-reify-many
+                  ghc-generic-deriving ghc-th-lift-instances))
+    (native-inputs (list ghc-hspec))
+    (home-page "http://hackage.haskell.org/package/th-orphans")
     (synopsis "Orphan instances for TH datatypes")
     (description
      "This package provides orphan instances for Template Haskell datatypes.  In particular,
@@ -12590,8 +12095,8 @@ package, and that's where the version number started.")
     (inputs
      (list ghc-hashable ghc-assoc))
     (arguments
-     `(#:cabal-revision
-       ("2" "16x3am622jn97j1d9879x7j5zbjn33bkfaa0dq0xyp1fbc0s7h5x")))
+     `(#:cabal-revision ("6"
+                         "12ll5l8m482qkb8zn79vx51bqlwc89fgixf8jv33a32b4qzc3499")))
     (home-page
      "https://github.com/isomorphism/these")
     (synopsis "Either-or-both data type")
@@ -12625,22 +12130,21 @@ variant of @code{These}.
 (define-public ghc-threads
   (package
     (name "ghc-threads")
-    (version "0.5.1.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "threads" version))
-       (sha256
-        (base32
-         "0bjnjhnq3km6xqk0fn1fgyz5xdw4h6lylbwwbcmkkfzwcz0c76hk"))))
+    (version "0.5.1.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "threads" version))
+              (sha256
+               (base32
+                "1l226792dqlp772aaxqr3qzz8yq72702g708k16gi8lrkfhgxxp0"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "threads")))
-    (native-inputs
-     (list ghc-concurrent-extra ghc-hunit ghc-test-framework
-           ghc-test-framework-hunit))
+    (native-inputs (list ghc-concurrent-extra ghc-hunit ghc-test-framework
+                         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
+    (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
@@ -12683,30 +12187,27 @@ function which generates instances.")
 (define-public ghc-time-compat
   (package
     (name "ghc-time-compat")
-    (version "1.9.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "time-compat" version))
-       (sha256
-        (base32
-         "19p3056i6kh8lgcdsnwsh8pj80xyi23kmw9n7hmdacczs5kv49ii"))))
+    (version "1.9.6.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "time-compat" version))
+              (sha256
+               (base32
+                "103b3vpn277kkccv6jv54b2wpi5c00mpb01ndl9w4y4nxc0bn1xd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "time-compat")))
-    (inputs
-     (list ghc-base-orphans))
-    (native-inputs
-     (list ghc-hunit
-           ghc-base-compat
-           ghc-quickcheck
-           ghc-tagged
-           ghc-tasty
-           ghc-tasty-hunit
-           ghc-tasty-quickcheck))
+    (inputs (list ghc-base-orphans ghc-hashable))
+    (native-inputs (list ghc-hunit
+                         ghc-base-compat
+                         ghc-quickcheck
+                         ghc-tagged
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
     (arguments
-     `(#:cabal-revision
-       ("1" "1f6r8cyfgzpfg9nrsqbf99pi44fyds9wcmgwxb4s0zmlb5dbv1m5")))
-    (home-page "https://github.com/phadej/time-compat")
+     `(#:cabal-revision ("4"
+                         "1n39yfk21xz8y1xvkh01651yysk2zp5qac22l5pq2hi7scczmxaw")))
+    (home-page "https://github.com/haskellari/time-compat")
     (synopsis "Compatibility package for time")
     (description "This package tries to compat as many @code{time}
 features as possible.")
@@ -12775,52 +12276,50 @@ used CPU time of monadic computation with an IO base.")
 
 (define-public ghc-timezone-series
   (package
-   (name "ghc-timezone-series")
-   (version "0.1.9")
-   (source
-    (origin
-     (method url-fetch)
-     (uri
-      (hackage-uri "timezone-series" version))
-     (sha256
-      (base32
-       "1blwgnyzqn917rgqkl4dncv9whv3xmk0lav040qq0214vksmvlz5"))))
-   (build-system haskell-build-system)
-   (properties '((upstream-name . "timezone-series")))
-   (home-page "https://archives.haskell.org/projects.haskell.org/time-ng/")
-   (synopsis "Enhanced timezone handling for Time")
-   (description
-    "This package endows @code{Data.Time}, from the time package, with several
+    (name "ghc-timezone-series")
+    (version "0.1.13")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "timezone-series" version))
+              (sha256
+               (base32
+                "18n6w7jxwlysq5mvb1sp1z57nyrsgn2ans642fy5rhmpwcavgvr8"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "timezone-series")))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1ak05p8z1q2nispv1xw32j7lhfmf3sfj2ibjrxpm347s37fmxnwc")))
+    (home-page "http://projects.haskell.org/time-ng/")
+    (synopsis "Enhanced timezone handling for Time")
+    (description
+     "This package endows @code{Data.Time}, from the time package, with several
 data types and functions for enhanced processing of timezones.  For one way to
 create timezone series, see the ghc-timezone-olson package.")
-   (license license:bsd-3)))
+    (license license:bsd-3)))
 
 (define-public ghc-timezone-olson
   (package
-   (name "ghc-timezone-olson")
-   (version "0.2.0")
-   (source
-    (origin
-     (method url-fetch)
-     (uri
-      (hackage-uri "timezone-olson" version))
-     (sha256
-      (base32
-       "0b9vh27b9nz803yhd93d5z63bs370lvn4vkdajxaak9clxlw6mwg"))))
-   (build-system haskell-build-system)
-   (properties '((upstream-name . "timezone-olson")))
-   (inputs
-    (list ghc-timezone-series ghc-extensible-exceptions))
-   (home-page "https://archives.haskell.org/projects.haskell.org/time-ng/")
-   (synopsis "Parser and renderer for binary Olson timezone files")
-   (description
-    "A parser and renderer for binary Olson timezone files whose format
+    (name "ghc-timezone-olson")
+    (version "0.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "timezone-olson" version))
+              (sha256
+               (base32
+                "10f5843sza2ikj2sg9fjhf5dhnhcidad86cdjmrj1y6zclkiqmdc"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "timezone-olson")))
+    (inputs (list ghc-timezone-series ghc-extensible-exceptions))
+    (home-page "http://projects.haskell.org/time-ng/")
+    (synopsis "Parser and renderer for binary Olson timezone files")
+    (description
+     "A parser and renderer for binary Olson timezone files whose format
 is specified by the tzfile(5) man page on Unix-like systems.  For more
 information about this format, see
 @url{http://www.iana.org/time-zones/repository/tz-link.html}.  Functions
 are provided for converting the parsed data into @code{TimeZoneSeries}
 objects from the timezone-series package.")
-   (license license:bsd-3)))
+    (license license:bsd-3)))
 
 (define-public ghc-tldr
   (package
@@ -12938,19 +12437,20 @@ compatibility to run on old versions of the platform.")
 (define-public ghc-transformers-compat
   (package
     (name "ghc-transformers-compat")
-    (version "0.6.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "transformers-compat" version))
-       (sha256
-        (base32
-         "1yd936az31g9995frc84g05rrb5b7w59ajssc5183lp6wm8h4bky"))))
+    (version "0.7.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "transformers-compat" version))
+              (sha256
+               (base32
+                "0slxrkxi8xa1bmi9saq9x8bz52clrf2slf877m3ckjzkr4276b5n"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "transformers-compat")))
-    (home-page "https://github.com/ekmett/transformers-compat/")
+    (inputs (list ghc-generic-deriving))
+    (home-page "http://github.com/ekmett/transformers-compat/")
     (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
-    (description "This package includes backported versions of types that were
+    (description
+     "This package includes backported versions of types that were
 added to transformers in transformers 0.3 and 0.4 for users who need strict
 transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
 but also need those types.")
@@ -12959,42 +12459,38 @@ but also need those types.")
 (define-public ghc-tree-diff
   (package
     (name "ghc-tree-diff")
-    (version "0.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "tree-diff" version))
-       (sha256
-        (base32
-         "0bybi4qp7nj9117yza5qqgw2f7s6rk3i7q642jqd7sdn3bx5cnap"))))
+    (version "0.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tree-diff" version))
+              (sha256
+               (base32
+                "0g3lsp067dq1ydvj2im4nlfxa65g9zjmjjkv91dhjhnrklir10q0"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "tree-diff")))
-    (arguments
-     `(#:cabal-revision
-       ("1" "0brlnq5ddmambidll1dn4jnjac2i44a9hd5hwp2p0rbh1s8jfyhm")))
-    (inputs
-     (list ghc-aeson
-           ghc-ansi-terminal
-           ghc-ansi-wl-pprint
-           ghc-base-compat
-           ghc-bytestring-builder
-           ghc-hashable
-           ghc-parsers
-           ghc-primitive
-           ghc-quickcheck
-           ghc-scientific
-           ghc-semialign
-           ghc-strict
-           ghc-tagged
-           ghc-these
-           ghc-unordered-containers
-           ghc-uuid-types
-           ghc-vector))
-    (native-inputs
-     (list ghc-trifecta ghc-tasty ghc-tasty-golden ghc-tasty-quickcheck))
+    (inputs (list ghc-aeson
+                  ghc-ansi-terminal
+                  ghc-ansi-wl-pprint
+                  ghc-base-compat
+                  ghc-bytestring-builder
+                  ghc-hashable
+                  ghc-parsers
+                  ghc-primitive
+                  ghc-quickcheck
+                  ghc-scientific
+                  ghc-semialign
+                  ghc-strict
+                  ghc-tagged
+                  ghc-these
+                  ghc-unordered-containers
+                  ghc-uuid-types
+                  ghc-vector))
+    (native-inputs (list ghc-tasty ghc-tasty-golden ghc-tasty-quickcheck
+                         ghc-trifecta))
     (home-page "https://github.com/phadej/tree-diff")
     (synopsis "Compute difference between (expression) trees")
-    (description "This Haskell library provides a function for computing
+    (description
+     "This Haskell library provides a function for computing
 the difference between (expression) trees.  It also provides a way to
 compute the difference between arbitrary abstract datatypes (ADTs) using
 @code{Generics}-derivable helpers.")
@@ -13003,36 +12499,37 @@ compute the difference between arbitrary abstract datatypes (ADTs) using
 (define-public ghc-trifecta
   (package
     (name "ghc-trifecta")
-    (version "2.1.1")
+    (version "2.1.2")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "trifecta" version))
               (sha256
                (base32
-                "1lhzi0xxvilvgjy3yf3f85wfmrks562hhsnl0kg1xwji36rgwp6y"))))
+                "1akx8m6mgskwsbhsf90cxlqjq23jk4pwaxagvm923dpncwrlwfla"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "trifecta")))
-    (inputs
-     (list ghc-ansi-terminal
-           ghc-blaze-builder
-           ghc-blaze-html
-           ghc-blaze-markup
-           ghc-charset
-           ghc-comonad
-           ghc-fingertree
-           ghc-hashable
-           ghc-indexed-traversable
-           ghc-lens
-           ghc-parsers
-           ghc-prettyprinter-ansi-terminal
-           ghc-prettyprinter
-           ghc-profunctors
-           ghc-reducers
-           ghc-unordered-containers
-           ghc-utf8-string))
-    (native-inputs
-     (list ghc-quickcheck))
-    (home-page "https://github.com/ekmett/trifecta/")
+    (inputs (list ghc-ansi-terminal
+                  ghc-blaze-builder
+                  ghc-blaze-html
+                  ghc-blaze-markup
+                  ghc-charset
+                  ghc-comonad
+                  ghc-fingertree
+                  ghc-hashable
+                  ghc-indexed-traversable
+                  ghc-lens
+                  ghc-parsers
+                  ghc-prettyprinter
+                  ghc-prettyprinter-ansi-terminal
+                  ghc-profunctors
+                  ghc-reducers
+                  ghc-unordered-containers
+                  ghc-utf8-string))
+    (native-inputs (list ghc-quickcheck))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0a7cfbd04w3zbm234mmpib9mxar46ra5xvb62gcnbmixr7b343j9")))
+    (home-page "http://github.com/ekmett/trifecta/")
     (synopsis "Parser combinator library with convenient diagnostics")
     (description "Trifecta is a modern parser combinator library for Haskell,
 with slicing and Clang-style colored diagnostics.")
@@ -13062,34 +12559,29 @@ statically known size.")
 (define-public ghc-turtle
   (package
     (name "ghc-turtle")
-    (version "1.5.22")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "turtle" version))
-       (sha256
-        (base32
-         "14lf43b5rxci6p9sy1gkb715m4b1s4rl65swn2qpdqv3h2yvpi4s"))))
+    (version "1.5.25")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "turtle" version))
+              (sha256
+               (base32
+                "1hh2rbwk3m4iklk67f1l1a8shsng9qzs9132j6lpag7cgqkrmqdk"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "turtle")))
-    (inputs
-     (list ghc-ansi-wl-pprint
-           ghc-async
-           ghc-clock
-           ghc-exceptions
-           ghc-foldl
-           ghc-hostname
-           ghc-managed
-           ghc-semigroups
-           ghc-system-filepath
-           ghc-system-fileio
-           ghc-streaming-commons
-           ghc-temporary
-           ghc-optparse-applicative
-           ghc-optional-args
-           ghc-unix-compat))
-    (native-inputs
-     (list ghc-doctest ghc-fail))
+    (inputs (list ghc-ansi-wl-pprint
+                  ghc-async
+                  ghc-clock
+                  ghc-foldl
+                  ghc-hostname
+                  ghc-managed
+                  ghc-system-filepath
+                  ghc-system-fileio
+                  ghc-streaming-commons
+                  ghc-temporary
+                  ghc-optparse-applicative
+                  ghc-optional-args
+                  ghc-unix-compat))
+    (native-inputs (list ghc-doctest))
     (home-page
      "https://hackage.haskell.org/package/turtle")
     (synopsis "Shell programming, Haskell-style")
@@ -13119,21 +12611,24 @@ similar functionality.")
 (define-public ghc-typed-process
   (package
     (name "ghc-typed-process")
-    (version "0.2.6.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "typed-process" version))
-       (sha256
-        (base32
-         "071mw4yv4xr5n82si33qbcqcxvcr7h56zlyd8gmsfrsdnacbq47k"))))
+    (version "0.2.10.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "typed-process" version))
+              (sha256
+               (base32
+                "17h9jl7gi26v3cxb4jdcksbp755sqqp8w7303q8x8r36rmf8fdp4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "typed-process")))
-    (inputs
-     (list ghc-async ghc-unliftio-core))
-    (native-inputs
-     (list ghc-base64-bytestring ghc-hspec hspec-discover ghc-temporary))
-    (home-page "https://haskell-lang.org/library/typed-process")
+    (inputs (list ghc-async ghc-unliftio-core))
+    (native-inputs (list ghc-base64-bytestring
+                         ghc-hspec
+                         ghc-temporary
+                         ghc-base64-bytestring
+                         ghc-hspec
+                         ghc-temporary
+                         hspec-discover))
+    (home-page "https://github.com/fpco/typed-process")
     (synopsis "Run external processes with strong typing of streams")
     (description
      "This library provides the ability to launch and interact with external
@@ -13164,21 +12659,18 @@ function.")
 (define-public ghc-unagi-chan
   (package
     (name "ghc-unagi-chan")
-    (version "0.4.1.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unagi-chan" version))
-       (sha256
-        (base32
-         "15fnk9x4fd2ryp31fjfrwm8k61m3a0qyb95m4065zc0yi0jyacp2"))))
+    (version "0.4.1.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unagi-chan" version))
+              (sha256
+               (base32
+                "1d98a6s7rydjlf2p3jv6j7wglq8ahf8kgcibji5fiy6y0ymz9mnr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unagi-chan")))
-    (inputs
-     (list ghc-atomic-primops ghc-primitive))
-    (arguments
-     `(#:tests? #f)) ; TODO: Fail.
-    (home-page "https://hackage.haskell.org/package/unagi-chan")
+    (inputs (list ghc-atomic-primops ghc-primitive))
+    (arguments (list #:tests? #f)) ; counter is atomic... test: Counter broken: expecting 10000000 got 9999996
+    (home-page "http://hackage.haskell.org/package/unagi-chan")
     (synopsis "Fast concurrent queues with a Chan-like API, and more")
     (description
      "This library provides implementations of concurrent FIFO queues (for
@@ -13228,24 +12720,49 @@ unbounded @code{Integer} type.")
 handled safely, this is what you're left with.")
     (license license:isc)))
 
+(define-public ghc-unicode-data
+  (package
+    (name "ghc-unicode-data")
+    (version "0.4.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unicode-data" version))
+              (sha256
+               (base32
+                "1030n3h11hk1rbq0fdbpry3aclz6yz8bki2abjvbwh0rh2kdx99p"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "unicode-data")))
+    (native-inputs (list ghc-hspec))
+    (home-page "http://github.com/composewell/unicode-data")
+    (synopsis "Access Unicode Character Database (UCD)")
+    (description
+     "This package provides Haskell APIs to efficiently access the
+<https://www.unicode.org/ucd/ Unicode character database> (UCD).  Performance is
+the primary goal in the design of this package.  The Haskell data structures
+are generated programmatically from the UCD files.")
+    (license license:asl2.0)))
+
 (define-public ghc-unicode-transforms
   (package
     (name "ghc-unicode-transforms")
-    (version "0.3.7.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unicode-transforms" version))
-       (sha256
-        (base32
-         "1010sahi4mjzqmxqlj3w73rlymbl2370x5vizjqbx7mb86kxzx4f"))))
+    (version "0.4.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unicode-transforms" version))
+              (sha256
+               (base32
+                "1z29jvli2rqkynfxni1gibl81458j7h8lrb8fg6lpnj8svhy2y1j"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unicode-transforms")))
-    (native-inputs
-     (list ghc-quickcheck ghc-getopt-generics ghc-split ghc-hspec))
-    (home-page "https://github.com/composewell/unicode-transforms")
+    (inputs (list ghc-unicode-data))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck ghc-hspec ghc-split))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1imm3svpz2shilj2kmmmcyy5yd4c1mpmz5v1gvjrr98hrab2i9x7")))
+    (home-page "http://github.com/composewell/unicode-transforms")
     (synopsis "Unicode normalization")
-    (description "This library provides tools for fast Unicode 12.1.0
+    (description
+     "This library provides tools for fast Unicode 12.1.0
 normalization in Haskell (normalization forms C, KC, D, and KD).")
     (license license:bsd-3)))
 
@@ -13298,18 +12815,19 @@ work, but is substantially simpler and faster.")
 (define-public ghc-unix-compat
   (package
     (name "ghc-unix-compat")
-    (version "0.5.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unix-compat" version))
-       (sha256
-        (base32
-         "1j75i3dj489rz60ij3nfza774mb7mw33amhdkm10dd0dxabvb4q8"))))
+    (version "0.5.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unix-compat" version))
+              (sha256
+               (base32
+                "1cd4lh2c16h7y5hzrcn5l9vir8aq2wcizwksppnagklsdsfmf942"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unix-compat")))
-    (home-page
-     "https://github.com/jystic/unix-compat")
+    (arguments
+     `(#:cabal-revision ("2"
+                         "0mik6xb1jdmb2jlxlmzf0517mxfj0c1j2i4r6h5212m4q6znqqcm")))
+    (home-page "http://github.com/jacobstanley/unix-compat")
     (synopsis "Portable POSIX-compatibility layer")
     (description
      "This package provides portable implementations of parts of the unix
@@ -13320,22 +12838,19 @@ isn't available, portable implementations are used.")
 (define-public ghc-unix-time
   (package
     (name "ghc-unix-time")
-    (version "0.4.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unix-time" version))
-       (sha256
-        (base32
-         "02fyh298lm8jsg52i3z0ikazwz477ljqjmhnqr2d88grmn5ky8qr"))))
+    (version "0.4.8")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unix-time" version))
+              (sha256
+               (base32
+                "0hz8mi08kg84hiqnch5ycscgqmjyn1mnl5ih1bsrclyb3fhvdppy"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unix-time")))
-    (arguments
-     `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found".  This
-                     ; is weird, that should be provided by GHC 7.10.2.
-    (inputs
-     (list ghc-old-time ghc-old-locale))
-    (home-page "https://hackage.haskell.org/package/unix-time")
+    (inputs (list ghc-old-time))
+    (native-inputs (list ghc-doctest ghc-old-locale ghc-quickcheck ghc-hspec
+                         hspec-discover))
+    (home-page "http://hackage.haskell.org/package/unix-time")
     (synopsis "Unix time parser/formatter and utilities")
     (description "This library provides fast parsing and formatting utilities
 for Unix time in Haskell.")
@@ -13344,25 +12859,22 @@ for Unix time in Haskell.")
 (define-public ghc-unliftio
   (package
     (name "ghc-unliftio")
-    (version "0.2.20")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unliftio" version))
-       (sha256
-        (base32
-         "0mbm57h7r16qd7kpglbm50qrnfjmazd70avbrl647n4jwhlrp7my"))))
+    (version "0.2.23.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unliftio" version))
+              (sha256
+               (base32
+                "1zg4ddi4z85550abw9ijycbbjg8ddig7r0vcma8ik03dxzga71id"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unliftio")))
-    (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH
-    (outputs '("out" "static" "doc"))
-    (inputs
-     (list ghc-async ghc-unliftio-core))
-    (native-inputs (list ghc-hspec))
-    (home-page "https://github.com/fpco/unliftio")
+    (inputs (list ghc-async ghc-safe-exceptions ghc-unliftio-core ghc-nats))
+    (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover))
+    (home-page "https://github.com/fpco/unliftio/tree/master/unliftio#readme")
     (synopsis "Provides MonadUnliftIO typecplass for unlifting monads to
 IO")
-    (description "This Haskell package provides the core @code{MonadUnliftIO}
+    (description
+     "This Haskell package provides the core @code{MonadUnliftIO}
 typeclass, a number of common instances, and a collection of common functions
 working with it.")
     (license license:expat)))
@@ -13394,29 +12906,30 @@ functions.")
 (define-public ghc-unordered-containers
   (package
     (name "ghc-unordered-containers")
-    (version "0.2.14.0")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unordered-containers" version))
-       (sha256
-        (base32
-         "0rw8kmg7xjlacmr1hcpin95abkd387awf154s9ran7zg9jllh3x1"))))
+    (version "0.2.19.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unordered-containers" version))
+              (sha256
+               (base32
+                "1li8s6qw8mgv6a7011y7hg0cn2nllv2g9sr9c1xb48nmw32vw9qv"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unordered-containers")))
-    (inputs
-     (list ghc-chasingbottoms
-           ghc-hunit
-           ghc-quickcheck
-           ghc-test-framework
-           ghc-test-framework-hunit
-           ghc-test-framework-quickcheck2
-           ghc-hashable))
+    (inputs (list ghc-hashable))
+    (native-inputs (list ghc-chasingbottoms
+                         ghc-hunit
+                         ghc-quickcheck
+                         ghc-random
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-nothunks-bootstrap))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0fcax3apnpxxy9maymclr6s2b4c28d3pkl3plbg0lv1mn0mh84fv")))
     (home-page
-     "https://github.com/tibbe/unordered-containers")
-    (synopsis
-     "Efficient hashing-based container types")
+     "https://github.com/haskell-unordered-containers/unordered-containers")
+    (synopsis "Efficient hashing-based container types")
     (description
      "Efficient hashing-based container types.  The containers have been
 optimized for performance critical use, both in terms of large data quantities
@@ -13430,6 +12943,7 @@ and high speed.")
     (arguments `(#:tests? #f))
     (inputs
      `(("ghc-hashable" ,ghc-hashable-bootstrap)))
+    (native-inputs '())
     (properties '((hidden? #t)))))
 
 (define-public ghc-unsafe
@@ -13489,16 +13003,17 @@ parser that uses ByteStrings for parsing and representing the URI data.")
 (define-public ghc-utf8-light
   (package
     (name "ghc-utf8-light")
-    (version "0.4.2")
+    (version "0.4.4.0")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "utf8-light" version))
        (sha256
         (base32
-         "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q"))))
+         "0415hapndlsnzvmm3bk2fl42h4vn1izky7jb3lbby3mzzzd8d1fx"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "utf8-light")))
+    (native-inputs (list ghc-hspec hspec-discover))
     (home-page
      "https://hackage.haskell.org/package/utf8-light")
     (synopsis "Lightweight unicode support for Haskell")
@@ -13590,10 +13105,13 @@ parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.")
          "1pd7xd6inkmmwjscf7pmiwqjks9y0gi1p8ahqbapvh34gadvhs5d"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "uuid-types")))
-    (arguments `(#:tests? #f)) ; TODO: Wrong byteorder version?
     (inputs (list ghc-hashable ghc-random))
-    (native-inputs (list ghc-byteorder ghc-quickcheck ghc-tasty
+    (native-inputs (list ghc-quickcheck ghc-tasty
                          ghc-tasty-hunit ghc-tasty-quickcheck))
+    (arguments
+     `(#:tests? #f ; Missing GHC internal library ghc-byteorder.
+       #:cabal-revision ("3"
+                         "10hpjshw6z8xnjpga47cazfdd4i27qvy4ash13lza2lmwf36k9ww")))
     (home-page "https://github.com/hvr/uuid")
     (synopsis "Haskell type definitions for UUIDs")
     (description "This Haskell library contains type definitions for
@@ -13605,24 +13123,28 @@ functions.")
 (define-public ghc-validation
   (package
     (name "ghc-validation")
-    (version "1.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "validation" version))
-       (sha256
-        (base32
-         "1dv7azpljdcf7irbnznnz31hq611bn1aj2m6ywghz3hgv835qqak"))))
+    (version "1.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "validation" version))
+              (sha256
+               (base32
+                "15hhz2kj6h9zv568bvq79ymck3s3b89fpkasdavbwvyhfyjm5k8x"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "validation")))
-    (inputs
-     (list ghc-semigroups ghc-semigroupoids ghc-assoc ghc-bifunctors
-           ghc-lens))
-    (native-inputs
-     (list ghc-hedgehog ghc-hunit))
+    (inputs (list ghc-assoc ghc-semigroups ghc-semigroupoids ghc-bifunctors
+                  ghc-lens))
+    (native-inputs (list ghc-hedgehog ghc-hunit))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "validation.cabal"
+               (("\\b(hedgehog|lens)\\s+[^,]+" all dep)
+                dep)))))))
     (home-page "https://github.com/qfpl/validation")
-    (synopsis
-     "Data-type like Either but with an accumulating Applicative")
+    (synopsis "Data-type like Either but with an accumulating Applicative")
     (description
      "A data-type like Either but with differing properties and type-class
 instances.
@@ -13644,19 +13166,17 @@ example of, \"An applicative functor that is not a monad.\"")
 (define-public ghc-validity
   (package
     (name "ghc-validity")
-    (version "0.11.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "validity" version))
-       (sha256
-        (base32
-         "086nj5ymp4mxxfw9qjgjhd4j3z7gl2y9d89p0b7bkap5ampgdw2x"))))
+    (version "0.12.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "validity" version))
+              (sha256
+               (base32
+                "1j9yswqas9dpb9mv132myfn1rky5vbh5gdvcxbb7p93k5c2y4g0w"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "validity")))
     (native-inputs (list ghc-hspec hspec-discover))
-    (home-page
-     "https://github.com/NorfairKing/validity")
+    (home-page "https://github.com/NorfairKing/validity#readme")
     (synopsis "Validity typeclass")
     (description
      "Values of custom types usually have invariants imposed upon them.  This
@@ -13679,6 +13199,9 @@ explicit by providing a function to check whether the invariants hold.")
     (properties '((upstream-name . "vault")))
     (inputs
      (list ghc-unordered-containers ghc-hashable ghc-semigroups))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1bjwv3nv8jfhrdxa5kn3gvgxmyalpq7592bvyl7bpvcc7bbkfkf3")))
     (home-page
      "https://github.com/HeinrichApfelmus/vault")
     (synopsis "Persistent store for arbitrary values")
@@ -13761,6 +13284,9 @@ optimisation framework.")
      (list ghc-vector))
     (native-inputs
      (list ghc-tasty ghc-tasty-quickcheck))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0av0k2gn90mf5ai74575bd368x73ljnr7xlkwsqmrs6zdzkw0i83")))
     (home-page "https://github.com/bos/vector-binary-instances")
     (synopsis "Instances of Data.Binary and Data.Serialize for vector")
     (description "This library provides instances of @code{Binary} for the
@@ -13773,27 +13299,27 @@ boxed and storable vectors.")
 (define-public ghc-vector-builder
   (package
     (name "ghc-vector-builder")
-    (version "0.3.8.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "vector-builder" version))
-       (sha256
-        (base32
-         "1g1zxp6xcwcq3372a5qqs44cl09a48p21m1jsys5bsampprlmcgs"))))
+    (version "0.3.8.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "vector-builder" version))
+              (sha256
+               (base32
+                "0gc2n5j1ca07hd50shy7l5xybs1y720zrarzs5dj74dsdcpvmjxw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "vector-builder")))
-    (inputs (list ghc-vector ghc-semigroups ghc-base-prelude))
+    (inputs (list ghc-vector))
     (native-inputs (list ghc-attoparsec
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-rerebase
                          ghc-tasty
                          ghc-tasty-hunit
-                         ghc-tasty-quickcheck
-                         ghc-hunit
-                         ghc-quickcheck-instances
-                         ghc-rerebase))
+                         ghc-tasty-quickcheck))
     (home-page "https://github.com/nikita-volkov/vector-builder")
     (synopsis "Vector builder for Haskell")
-    (description "This Haskell package provides an API for constructing vectors.
+    (description
+     "This Haskell package provides an API for constructing vectors.
 It provides the composable @code{Builder} abstraction, which has instances of the
 @code{Monoid} and @code{Semigroup} classes.
 
@@ -13805,21 +13331,24 @@ vector.")
 (define-public ghc-vector-th-unbox
   (package
     (name "ghc-vector-th-unbox")
-    (version "0.2.1.9")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "vector-th-unbox" version))
-       (sha256
-        (base32
-         "0jbzm31d91kxn8m0h6iplj54h756q6f4zzdrnb2w7rzz5zskgqyl"))))
+    (version "0.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "vector-th-unbox" version))
+              (sha256
+               (base32
+                "0j81m09xxv24zziv0nanfppckzmas5184jr3npjhc9w49r3cm94a"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "vector-th-unbox")))
-    (inputs
-     (list ghc-vector ghc-data-default))
-    (home-page "https://github.com/liyang/vector-th-unbox")
+    (inputs (list ghc-vector))
+    (native-inputs (list ghc-data-default))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0ki133sixq8pkfys36nl25jzdvnw40qq2bnskdmk2zyjhckdjcna")))
+    (home-page "https://github.com/tsurucapital/vector-th-unbox")
     (synopsis "Deriver for Data.Vector.Unboxed using Template Haskell")
-    (description "This Haskell library provides a Template Haskell
+    (description
+     "This Haskell library provides a Template Haskell
 deriver for unboxed vectors, given a pair of coercion functions to
 and from some existing type with an Unbox instance.")
     (license license:bsd-3)))
@@ -13860,13 +13389,8 @@ given term should not exist.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "wave")))
     (arguments
-     '(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "wave.cabal"
-               (("temporary.* < 1\\.3")
-                "temporary >= 1.1 && < 1.4")))))))
+     `(#:cabal-revision ("1"
+                         "19rxhnqhhv1qs35y723c15c8nifj8pakcrd09jlvg5271zg4qb0b")))
     (inputs
      (list ghc-cereal ghc-data-default-class ghc-quickcheck ghc-temporary))
     (native-inputs
@@ -14019,40 +13543,34 @@ modernized interface.")
 (define-public ghc-wl-pprint-text
   (package
     (name "ghc-wl-pprint-text")
-    (version "1.2.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "wl-pprint-text" version))
-       (sha256
-        (base32
-         "030ckgzz14sv2c317g4j5g68hyq9xi40cmv0apwclw6sc6xgsvly"))))
+    (version "1.2.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "wl-pprint-text" version))
+              (sha256
+               (base32
+                "0axivwh7bxmljxpfnccs66knxzrqck07byxmp2j737xbb26pf5cj"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "wl-pprint-text")))
-    (inputs
-     (list ghc-base-compat))
-    (home-page "https://hackage.haskell.org/package/wl-pprint-text")
+    (inputs (list ghc-base-compat))
+    (home-page "http://hackage.haskell.org/package/wl-pprint-text")
     (synopsis "Wadler/Leijen Pretty Printer for Text values")
-    (description
-     "A clone of wl-pprint for use with the text library.")
+    (description "A clone of wl-pprint for use with the text library.")
     (license license:bsd-3)))
 
 (define-public ghc-word-wrap
   (package
     (name "ghc-word-wrap")
-    (version "0.4.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "word-wrap" version))
-       (sha256
-        (base32 "15rcqhg9vb7qisk9ryjnyhhfgigxksnkrczycaw2rin08wczjwpb"))))
+    (version "0.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "word-wrap" version))
+              (sha256
+               (base32
+                "0i57233g4p9p8c0jf9mp3pvknwgv1lsrxm4mxjay38rw0372jpzq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "word-wrap")))
     (native-inputs (list ghc-hspec))
-    (arguments
-     `(#:cabal-revision
-       ("1" "1k4w4g053vhmpp08542hrqaw81p3p35i567xgdarqmpghfrk68pp")))
     (home-page "https://github.com/jtdaugherty/word-wrap/")
     (synopsis "Haskell library for word-wrapping text")
     (description
@@ -14104,22 +13622,21 @@ word expansion like a posix-shell.")
 (define-public ghc-x11
   (package
     (name "ghc-x11")
-    (version "1.10.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "X11" version))
-       (sha256
-        (base32 "1ip207l97s8nw4daxp9s254agk8f0wibpf0prx0n695klqyn8bz1"))))
+    (version "1.10.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "X11" version))
+              (sha256
+               (base32
+                "0hnj2q310a6s0h479hq8jsmywymvxdjxg13zw46mmdndynwd2jnq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "X11")))
     (arguments
      `(#:extra-directories
        ("libx11" "libxrandr" "libxinerama" "libxscrnsaver")))
-    (inputs
-     (list libx11 libxrandr libxinerama libxscrnsaver
-           ghc-data-default-class))
-    (home-page "https://github.com/haskell-pkg-janitors/X11")
+    (inputs (list libx11 libxrandr libxinerama libxscrnsaver
+                  ghc-data-default-class))
+    (home-page "https://github.com/xmonad/X11")
     (synopsis "Bindings to the X11 graphics library")
     (description
      "This package provides Haskell bindings to the X11 graphics library.  The
@@ -14129,27 +13646,25 @@ bindings are a direct translation of the C bindings.")
 (define-public ghc-x11-xft
   (package
     (name "ghc-x11-xft")
-    (version "0.3.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "X11-xft" version))
-       (sha256
-        (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
-    (arguments
-     `(#:extra-directories ("libx11" "libxft" "xorgproto")))
-    (inputs
-     (list ghc-x11 ghc-utf8-string libx11 libxft xorgproto))
-    (native-inputs
-     (list pkg-config))
+    (version "0.3.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "X11-xft" version))
+              (sha256
+               (base32
+                "05m988r45jiqpxqsw3vafz158whlwfcl7v8z9nnqnqz9mggd4032"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "X11-xft")))
-    (home-page "https://hackage.haskell.org/package/X11-xft")
+    (arguments
+     `(#:extra-directories ("libx11" "libxft" "xorgproto")))
+    (inputs (list ghc-x11 ghc-utf8-string libx11 libxft xorgproto))
+    (native-inputs (list pkg-config))
+    (home-page "http://hackage.haskell.org/package/X11-xft")
     (synopsis "Bindings to Xft")
     (description
      "Bindings to the Xft, X Free Type interface library, and some Xrender
 parts.")
-    (license license:lgpl2.1)))
+    (license license:bsd-3)))
 
 (define-public ghc-xdg-basedir
   (package
@@ -14209,8 +13724,20 @@ parts.")
            ghc-data-default-class
            ghc-blaze-markup
            ghc-blaze-html))
-    (native-inputs
-     (list ghc-doctest ghc-hspec ghc-cabal-doctest ghc-hunit))
+    (native-inputs (list ghc-hspec ghc-hunit ghc-doctest hspec-discover))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "0m6sknp9xxz8a3dhvyfpyjvxp8ph511w19j4vj1qsd6hl2pazjy6")
+       #:tests? #f ; Depend on non-existent doctest API.
+       #:phases
+       (modify-phases %standard-phases
+         ;; Tries to use non-existent doctest API.
+         (add-after 'unpack 'disable-doctest
+           (lambda _
+             (with-output-to-file "Setup.hs"
+               (lambda _
+                 (display
+                  "import Distribution.Simple\nmain = defaultMain\n"))))))))
     (home-page "https://github.com/snoyberg/xml")
     (synopsis "Utilities for dealing with XML with the conduit package")
     (description
@@ -14240,56 +13767,56 @@ documents.")
 (define-public ghc-xml-hamlet
   (package
     (name "ghc-xml-hamlet")
-    (version "0.5.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "xml-hamlet" version))
-       (sha256
-        (base32 "0jrhcjy7ww59dafg857f2g2df1fw2jmbwcs1q379ph0pc5rxj3lj"))))
+    (version "0.5.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "xml-hamlet" version))
+              (sha256
+               (base32
+                "109fck1626d74s00ssjffg837584wf7dxpswkil37wqqfy94mw2z"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "xml-hamlet")))
-    (inputs
-     (list ghc-shakespeare ghc-xml-conduit))
-    (native-inputs
-     (list ghc-hspec ghc-hunit))
-    (home-page "https://www.yesodweb.com/")
+    (inputs (list ghc-shakespeare ghc-xml-conduit))
+    (native-inputs (list ghc-hspec ghc-hunit))
+    (home-page "http://www.yesodweb.com/")
     (synopsis "Hamlet-style quasiquoter for XML content")
-    (description "This package provides a type-safe tool for generating XML
+    (description
+     "This package provides a type-safe tool for generating XML
 code via quasi-quoting built on top of @code{ghc-shakespeare}.")
     (license license:bsd-3)))
 
 (define-public ghc-yaml
   (package
     (name "ghc-yaml")
-    (version "0.11.7.0")
+    (version "0.11.8.0")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "yaml" version))
               (sha256
                (base32
-                "0s08kw0hqxixxripwjmz7b4yh9130dws3jaj460x8ds8q4b6khbx"))))
+                "1s0arllihjjqp65jbc8c1w5106i2infppsirvbsifpmpkf14w6pn"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "yaml")))
-    (inputs
-     (list ghc-conduit
-           ghc-resourcet
-           ghc-aeson
-           ghc-unordered-containers
-           ghc-vector
-           ghc-attoparsec
-           ghc-scientific
-           ghc-libyaml
-           ghc-optparse-applicative))
-    (native-inputs
-     (list ghc-hspec
-           ghc-hunit
-           ghc-base-compat
-           hspec-discover
-           ghc-mockery
-           ghc-raw-strings-qq
-           ghc-temporary))
-    (home-page "https://github.com/snoyberg/yaml/")
+    (inputs (list ghc-aeson
+                  ghc-attoparsec
+                  ghc-conduit
+                  ghc-libyaml
+                  ghc-resourcet
+                  ghc-scientific
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-optparse-applicative))
+    (native-inputs (list ghc-hunit
+                         ghc-base-compat
+                         ghc-hspec
+                         ghc-mockery
+                         ghc-raw-strings-qq
+                         ghc-temporary
+                         hspec-discover))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1dix5jm3d380vjr9l6wqz54zk883kilk8rijlvjp6b13mjxwcj1l")))
+    (home-page "https://github.com/snoyberg/yaml#readme")
     (synopsis "Parsing and rendering YAML documents")
     (description
      "This package provides a library to parse and render YAML documents.")
@@ -14298,16 +13825,17 @@ code via quasi-quoting built on top of @code{ghc-shakespeare}.")
 (define-public ghc-zip-archive
   (package
     (name "ghc-zip-archive")
-    (version "0.4.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "zip-archive" version))
-       (sha256
-        (base32
-         "1cdix5mnxrbs7b2kivhdydhfzgxidd9dqlw71mdw5p21cabwkmf5"))))
+    (version "0.4.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "zip-archive" version))
+              (sha256
+               (base32
+                "02b76hm76gqallij70z77xz1y981ig4biklzm0wgxran8d06n0d4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "zip-archive")))
+    (inputs (list ghc-zlib ghc-digest))
+    (native-inputs (list ghc-hunit ghc-temporary which unzip))
     (arguments
      `(#:phases
        (modify-phases %standard-phases
@@ -14318,46 +13846,31 @@ code via quasi-quoting built on top of @code{ghc-shakespeare}.")
                    (path (getenv "PATH")))
                (setenv "PATH" (string-append unzip "/bin:" which "/bin:" path))
                #t))))))
-    (inputs
-     (list ghc-digest ghc-temporary ghc-zlib))
-    (native-inputs
-     (list ghc-hunit unzip which))
-    (home-page "https://hackage.haskell.org/package/zip-archive")
+    (home-page "http://github.com/jgm/zip-archive")
     (synopsis "Zip archive library for Haskell")
-    (description "The zip-archive library provides functions for creating,
+    (description
+     "The zip-archive library provides functions for creating,
 modifying, and extracting files from zip archives in Haskell.")
     (license license:bsd-3)))
 
 (define-public ghc-zlib
   (package
     (name "ghc-zlib")
-    (version "0.6.2.3")
-    (outputs '("out" "static" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "zlib" version))
-       (sha256
-        (base32
-         "125wbayk8ifp0gp8cb52afck2ziwvqfrjzbmwmy52g6bz7fnnzw0"))))
+    (version "0.6.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "zlib" version))
+              (sha256
+               (base32
+                "1nh4xsm3kgsg76jmkcphvy7hhslg9hx1s75mpsskhi2ksjd9ialy"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "zlib")))
     (arguments
-     `(#:extra-directories ("zlib")
-       #:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'strip-test-framework-constraints
-           (lambda _
-             (substitute* "zlib.cabal"
-               (("tasty            >= 0\\.8 && < 0\\.12") "tasty")
-               (("tasty-hunit      >= 0\\.8 && < 0\\.10") "tasty-hunit")
-               (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+     `(#:extra-directories ("zlib")))
     (inputs (list zlib))
-    (native-inputs
-     (list ghc-quickcheck ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck))
-    (home-page "https://hackage.haskell.org/package/zlib")
-    (synopsis
-     "Compression and decompression in the gzip and zlib formats")
+    (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-quickcheck))
+    (home-page "http://hackage.haskell.org/package/zlib")
+    (synopsis "Compression and decompression in the gzip and zlib formats")
     (description
      "This package provides a pure interface for compressing and decompressing
 streams of data represented as lazy @code{ByteString}s.  It uses the zlib C
@@ -14420,20 +13933,20 @@ compression ratios.")
 (define-public ghc-indexed-traversable
   (package
     (name "ghc-indexed-traversable")
-    (version "0.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "indexed-traversable" version))
-       (sha256
-        (base32 "0fc18vdm1894yjbjkj9wjm27bf37ac3gvkzak677mgiw2pinmhvs"))))
+    (version "0.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "indexed-traversable" version))
+              (sha256
+               (base32
+                "13b91rkhs6wcshaz3dwx6x3xjpw5z5bm2riwp78zxccqf7p5hs2i"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "indexed-traversable")))
     (inputs (list ghc-generic-deriving))
     (arguments
-     `(#:cabal-revision
-       ("1" "0krvp9v5dh4w2076kar48cpkk62ndqp769v2ai3b38rsa5bj6q74")))
-    (home-page "https://hackage.haskell.org/package/indexed-traversable")
+     `(#:cabal-revision ("2"
+                         "0l2k9jrmixkkf7qzzq0bqgvk6axaqi9sxxkpb4dgj8frmc4bg8aj")))
+    (home-page "http://hackage.haskell.org/package/indexed-traversable")
     (synopsis "Indexed Functor, Foldable, and Traversable typeclasses")
     (description
      "This Haskell package provides three useful generalizations:
@@ -14471,8 +13984,8 @@ associated @code{TypeFamilies} instead of @code{FunctionalDependencies}.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "type-equality")))
     (arguments
-     `(#:cabal-revision
-       ("2" "1a3irpv5kyg3rywhmcp5fwg5irrdbdr0hrlw7asdk113nakrba7j")))
+     `(#:cabal-revision ("4"
+                         "0sajw67mmk5syhbrwx4bz82j5cjhm04n4kjl0pp3dnphxg1m5nbw")))
     (home-page "https://github.com/hesselink/type-equality")
     (synopsis "@code{Data.Type.Equality} compatibility package")
     (description
@@ -14491,18 +14004,16 @@ for compilers with @code{PolyKinds}.")
 (define-public ghc-selective
   (package
     (name "ghc-selective")
-    (version "0.4.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "selective" version))
-       (sha256
-        (base32 "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l"))))
+    (version "0.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "selective" version))
+              (sha256
+               (base32
+                "18wd5wn8xaw0ilx34j292l06cqn6r2rri1wvxng8ygd8141sizdh"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "selective")))
-    (native-inputs
-     (list ghc-quickcheck ghc-tasty ghc-tasty-expected-failure
-           ghc-tasty-quickcheck))
+    (native-inputs (list ghc-quickcheck))
     (home-page "https://github.com/snowleopard/selective")
     (synopsis "Selective applicative functors")
     (description
@@ -14534,6 +14045,9 @@ on selective functors} for more details.")
            ghc-tagged
            ghc-transformers-compat
            ghc-unordered-containers))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "1sb7ii9mhx77rhviqbmdc5r6wlimkmadxi1pyk7k3imdqcdzgjlp")))
     (home-page "http://github.com/ekmett/keys/")
     (synopsis "Keyed functors and containers")
     (description
@@ -14546,26 +14060,25 @@ dependencies.")
 (define-public ghc-pointed
   (package
     (name "ghc-pointed")
-    (version "5.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "pointed" version))
-       (sha256
-        (base32 "07p92y62dibys3xa59rvx52xyyr39nghl73z7hzwnksa3ry3vfmq"))))
+    (version "5.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "pointed" version))
+              (sha256
+               (base32
+                "1mv06x2hscs220w4acm5jwg96vi4faky6ir9hnljfry3n2r2xix3"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "pointed")))
-    (inputs
-     (list ghc-data-default-class
-           ghc-comonad
-           ghc-kan-extensions
-           ghc-semigroupoids
-           ghc-semigroups
-           ghc-tagged
-           ghc-transformers-compat
-           ghc-hashable
-           ghc-unordered-containers))
-    (home-page "https://github.com/ekmett/pointed/")
+    (inputs (list ghc-data-default-class
+                  ghc-comonad
+                  ghc-kan-extensions
+                  ghc-semigroupoids
+                  ghc-semigroups
+                  ghc-tagged
+                  ghc-transformers-compat
+                  ghc-hashable
+                  ghc-unordered-containers))
+    (home-page "http://github.com/ekmett/pointed/")
     (synopsis "Pointed and copointed data types")
     (description
      "This Haskell library provides pointed and copointed data types.")
@@ -14601,17 +14114,16 @@ the @code{ghc-vector} package.")
 (define-public ghc-th-compat
   (package
     (name "ghc-th-compat")
-    (version "0.1.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "th-compat" version))
-       (sha256
-        (base32 "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b"))))
+    (version "0.1.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "th-compat" version))
+              (sha256
+               (base32
+                "1f5ssi24mnhmmi91dl5ddg2jwci6akwlznqggf56nyxl9b0pmyfq"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "th-compat")))
-    (native-inputs
-     (list ghc-base-compat ghc-hspec hspec-discover))
+    (native-inputs (list ghc-base-compat ghc-hspec hspec-discover))
     (home-page "https://github.com/haskell-compat/th-compat")
     (synopsis
      "Backward- and forward-compatible @code{Quote} and @code{Code} types")
@@ -14626,19 +14138,18 @@ range of @code{template-haskell} versions.  On recent versions of
 (define-public ghc-filepattern
   (package
     (name "ghc-filepattern")
-    (version "0.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "filepattern" version))
-       (sha256
-        (base32 "0nznzji5haxl4ninm2a79dqf4c7fj6pc3z9gdc6wbf5h1pp14afr"))))
+    (version "0.1.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "filepattern" version))
+              (sha256
+               (base32
+                "0dlnwnwhsfdkwm69z66wj5d2x9n3la55glq4fsn5rxm2kr1msi6c"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "filepattern")))
-    (inputs
-     (list ghc-extra ghc-semigroups))
+    (inputs (list ghc-extra))
     (native-inputs (list ghc-quickcheck))
-    (home-page "https://github.com/ndmitchell/filepattern")
+    (home-page "https://github.com/ndmitchell/filepattern#readme")
     (synopsis "File path glob-like matching")
     (description
      "This package provides Haskell library for matching files using patterns
@@ -14667,19 +14178,18 @@ traverals using patterns.
 (define-public ghc-lib-parser-ex
   (package
     (name "ghc-lib-parser-ex")
-    (version "8.10.0.23")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ghc-lib-parser-ex" version))
-       (sha256
-        (base32 "0r5sl7hhn0cxp0b1dskx1lshplc0yka7hcvs2nh10nrj07fjd3vj"))))
+    (version "9.2.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ghc-lib-parser-ex" version))
+              (sha256
+               (base32
+                "138wkpy7qpdkp07028flab3lwq4b3mns0qcrkfrhclixlz8pi74v"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "ghc-lib-parser-ex")))
     (inputs (list ghc-uniplate))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit ghc-extra))
-    (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex")
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-extra))
+    (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme")
     (synopsis "Algorithms on GHC parse trees")
     (description
      "The @code{ghc-lib-parser-ex} package contains GHC API parse tree utilities.")
@@ -14688,16 +14198,16 @@ traverals using patterns.
 (define-public ghc-lift-type
   (package
     (name "ghc-lift-type")
-    (version "0.1.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "lift-type" version))
-       (sha256
-        (base32 "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf"))))
+    (version "0.1.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lift-type" version))
+              (sha256
+               (base32
+                "039psym2ghkydk4qyycs3cxndrf85ab5hwzrqv0ajxcilqr11n0h"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "lift-type")))
-    (home-page "https://github.com/parsonsmatt/lift-type")
+    (home-page "https://github.com/parsonsmatt/lift-type#readme")
     (synopsis
      "Lift a type from a Typeable constraint to a Template Haskell type")
     (description
@@ -14709,19 +14219,18 @@ it.")
 (define-public ghc-unicode-collation
   (package
     (name "ghc-unicode-collation")
-    (version "0.1.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "unicode-collation" version))
-       (sha256
-        (base32 "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi"))))
+    (version "0.1.3.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "unicode-collation" version))
+              (sha256
+               (base32
+                "0imcdsk0qqwj31zwgpick4s2nbxlyxwa64lq6r212jd0y0hrrvvl"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "unicode-collation")))
     (inputs (list ghc-th-lift-instances))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
-           ghc-unicode-transforms ghc-doctest))
+    (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
+                         ghc-unicode-transforms ghc-doctest))
     (home-page "https://github.com/jgm/unicode-collation")
     (synopsis "Haskell implementation of the Unicode Collation Algorithm")
     (description
@@ -14735,32 +14244,31 @@ provided.")
 (define-public ghc-citeproc
   (package
     (name "ghc-citeproc")
-    (version "0.4.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "citeproc" version))
-       (sha256
-        (base32 "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv"))))
+    (version "0.8.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "citeproc" version))
+              (sha256
+               (base32
+                "1rja6vdggmh7d40gsg2xfs9md6m1zbfddpsd27a15qyqb3530jzw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "citeproc")))
-    (inputs
-     (list ghc-safe
-           ghc-case-insensitive
-           ghc-vector
-           ghc-scientific
-           ghc-uniplate
-           ghc-xml-conduit
-           ghc-attoparsec
-           ghc-data-default
-           ghc-aeson
-           ghc-file-embed
-           ghc-pandoc-types
-           ghc-unicode-collation
-           ghc-base-compat
-           ghc-aeson-pretty))
+    (inputs (list ghc-safe
+                  ghc-case-insensitive
+                  ghc-vector
+                  ghc-scientific
+                  ghc-uniplate
+                  ghc-xml-conduit
+                  ghc-attoparsec
+                  ghc-data-default
+                  ghc-aeson
+                  ghc-file-embed
+                  ghc-pandoc-types
+                  ghc-unicode-collation
+                  ghc-base-compat
+                  ghc-aeson-pretty))
     (native-inputs (list ghc-timeit ghc-diff))
-    (home-page "https://hackage.haskell.org/package/citeproc")
+    (home-page "http://hackage.haskell.org/package/citeproc")
     (synopsis "Generate citations and bibliography from CSL styles")
     (description
      "@code{ghc-citeproc} parses @acronym{Citation Style Language, CSL} style files
@@ -14771,18 +14279,17 @@ entries.  For more information about CSL, see @uref{https://citationstyles.org/}
 (define-public ghc-commonmark
   (package
     (name "ghc-commonmark")
-    (version "0.2.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "commonmark" version))
-       (sha256
-        (base32 "105szy7l4ji255fwv0kbfcy3i3a3a4197zgj6s9jb12kwbn6n0c7"))))
+    (version "0.2.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "commonmark" version))
+              (sha256
+               (base32
+                "0kmjc9xgzy33kxz842mw5rdywip3lmk7v3ambrs87nakawgl42xp"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "commonmark")))
-    (inputs (list ghc-unicode-transforms))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
+    (inputs (list ghc-unicode-transforms ghc-unicode-data))
+    (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
     (home-page "https://github.com/jgm/commonmark-hs")
     (synopsis "Pure Haskell Commonmark parser")
     (description
@@ -14805,19 +14312,17 @@ varies linearly with input length.")
 (define-public ghc-commonmark-extensions
   (package
     (name "ghc-commonmark-extensions")
-    (version "0.2.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "commonmark-extensions" version))
-       (sha256
-        (base32 "0jm6w84p2a2gyaljvnlvjjwrwnir1lss3ps53d0bd8mkvhixxrqr"))))
+    (version "0.2.3.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "commonmark-extensions" version))
+              (sha256
+               (base32
+                "009yrsb2xxna73q6nnijfx5ngffaz369mildvqvn91qbrkrzq7pl"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "commonmark-extensions")))
-    (inputs
-     (list ghc-network-uri ghc-commonmark ghc-emojis))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit))
+    (inputs (list ghc-network-uri ghc-commonmark ghc-emojis))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
     (home-page "https://github.com/jgm/commonmark-hs")
     (synopsis "Extensions for @code{ghc-commonmark}")
     (description
@@ -14829,17 +14334,16 @@ footnotes, math, and more.")
 (define-public ghc-commonmark-pandoc
   (package
     (name "ghc-commonmark-pandoc")
-    (version "0.2.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "commonmark-pandoc" version))
-       (sha256
-        (base32 "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp"))))
+    (version "0.2.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "commonmark-pandoc" version))
+              (sha256
+               (base32
+                "1dpi8zvjshab96w56qfqcys9h09f46lld8sc9q4xzb0y1p6lwmap"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "commonmark-pandoc")))
-    (inputs
-     (list ghc-commonmark ghc-commonmark-extensions ghc-pandoc-types))
+    (inputs (list ghc-commonmark ghc-commonmark-extensions ghc-pandoc-types))
     (home-page "https://github.com/jgm/commonmark-hs")
     (synopsis "Bridge between Commonmark and Pandoc AST")
     (description
@@ -14850,19 +14354,18 @@ Pandoc types.")
 (define-public ghc-hslua-module-path
   (package
     (name "ghc-hslua-module-path")
-    (version "0.1.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "hslua-module-path" version))
-       (sha256
-        (base32 "1zxfljcn74rky26ijqmba6grpj0h9plgr47wxdaf7gcz1y8dhn68"))))
+    (version "1.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-module-path" version))
+              (sha256
+               (base32
+                "1sy2k4mb263kg85vkf39ja84xz5kvm6z61xn62jy1swhrvvd96sr"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "hslua-module-path")))
-    (inputs (list ghc-hslua))
-    (native-inputs
-     (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua))
-    (home-page "https://github.com/hslua/hslua-module-path")
+    (inputs (list ghc-hslua-core ghc-hslua-marshalling ghc-hslua-packaging))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua))
+    (home-page "https://hslua.org/")
     (synopsis "Lua module to work with file paths")
     (description
      "This Haskell library provides a Lua module to work with file paths in a
@@ -14872,16 +14375,22 @@ platform independent way.")
 (define-public ghc-template-haskell
   (package
     (name "ghc-template-haskell")
-    (version "2.16.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "template-haskell" version))
-       (sha256
-        (base32 "1nk1cv35szp80qkhbyh5gn6vn194zzl0wz186qrqdrdx3a9r9w4g"))))
+    (version "2.18.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "template-haskell" version))
+              (sha256
+               (base32
+                "0mcb7psdkyx9ddwkny0ymvadrsy2dnj82d6jdm23c63zv99z3g1r"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "template-haskell")))
-    (inputs (list ghc-boot-th))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "template-haskell.cabal"
+               (("ghc-boot-th == 9.2.1") "ghc-boot-th")))))))
     (home-page "https://hackage.haskell.org/package/template-haskell")
     (synopsis "Support library for Template Haskell")
     (description
@@ -14894,74 +14403,50 @@ information.")
 (define-public ghc-genvalidity-hspec
   (package
     (name "ghc-genvalidity-hspec")
-    (version "0.7.0.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "genvalidity-hspec" version))
-       (sha256
-        (base32 "0aajx07n2rznyqxb0c4pn9j2cvkzw5brz9ki4grhhigbcri3jzmv"))))
+    (version "1.0.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "genvalidity-hspec" version))
+              (sha256
+               (base32
+                "00sv0mzlvny5ch7c9fnd19szqd0pjrkvi080x1i62qa5fdzs5yc4"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "genvalidity-hspec")))
-    (inputs
-     (list ghc-quickcheck
-           ghc-genvalidity
-           ghc-genvalidity-property
-           ghc-hspec
-           hspec-discover
-           ghc-hspec-core
-           ghc-validity))
-    (home-page "https://github.com/NorfairKing/validity")
+    (inputs (list ghc-quickcheck
+                  ghc-genvalidity
+                  ghc-genvalidity-property
+                  ghc-hspec
+                  ghc-hspec-core
+                  ghc-validity))
+    (native-inputs (list hspec-discover))
+    (home-page "https://github.com/NorfairKing/validity#readme")
     (synopsis "Standard spec's for @code{GenValidity} instances")
     (description
      "This haskell library provides validity and validity-based testing for
 @code{ghc-hspec}.")
     (license license:expat)))
 
-(define-public ghc-boot-th
-  (package
-    (name "ghc-boot-th")
-    (version "8.10.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "ghc-boot-th" version))
-       (sha256
-        (base32 "0vhhmsd32p7zn9vhpv4d0k0b55n2dyhzy42xblndrma617kz8gli"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "ghc-boot-th")))
-    (home-page "https://hackage.haskell.org/package/ghc-boot-th")
-    (synopsis
-     "Shared functionality between GHC and Template Haskell")
-    (description
-     "This library contains various bits shared between GHC and Template
-Haskell.  This package exists to ensure that @code{template-haskell} has a
-minimal set of transitive dependencies, since it is intended to be depended
-upon by user code.")
-    (license license:bsd-3)))
-
 (define-public ghc-binary-orphans
   (package
     (name "ghc-binary-orphans")
-    (version "1.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "binary-orphans" version))
-       (sha256
-        (base32 "0gbmn5rpvyxhw5bxjmxwld6918lslv03b2f6hshssaw1il5x86j3"))))
+    (version "1.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "binary-orphans" version))
+              (sha256
+               (base32
+                "0b302hhjaybwbnpzrd8qmdp24g2xj2svib34zfxqqxg67j159rg2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "binary-orphans")))
-    (native-inputs
-     (list ghc-quickcheck ghc-quickcheck-instances ghc-tagged ghc-tasty
-           ghc-tasty-quickcheck))
-    (arguments
-     `(#:cabal-revision
-       ("5" "1h2d37szfrcwn9rphnijn4q9l947b0wwqjs1aqmm62xkhbad7jf6")))
+    (native-inputs (list ghc-onetuple
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-tagged
+                         ghc-tasty
+                         ghc-tasty-quickcheck))
     (home-page "https://hackage.haskell.org/package/binary-orphans")
     (synopsis "Compatibility package for binary")
-    (description
-     "This package provides instances defined in later versions of
+    (description "This package provides instances defined in later versions of
 @code{ghc-binary} package.")
     (license license:bsd-3)))
 
@@ -14991,18 +14476,18 @@ of Netlink families.")
 (define-public ghc-doctest-driver-gen
   (package
     (name "ghc-doctest-driver-gen")
-    (version "0.3.0.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "doctest-driver-gen" version))
-       (sha256
-        (base32 "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a"))))
+    (version "0.3.0.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "doctest-driver-gen" version))
+              (sha256
+               (base32
+                "0a4jdg4mzhdgfal7jp60yrlv63iv7d8f7nxc9aqvrl93mairny8l"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "doctest-driver-gen")))
-    (arguments `(#:tests? #f)) ; TODO: Fail to open shared library.
     (native-inputs (list ghc-doctest))
-    (home-page "https://github.com/Hexirp/doctest-driver-gen")
+    (arguments (list #:tests? #f)) ;; XXX: doctest-driver-gen: error while loading shared libraries: libHSdoctest-driver-gen-0.3.0.6-3WJHXaMfGwJFKjjgcmC868-ghc9.2.5.so: cannot open shared object file: No such file or directory
+    (home-page "https://github.com/Hexirp/doctest-driver-gen#readme")
     (synopsis "Generate driver file for Doctest's Cabal integration")
     (description
      "@code{ghc-doctest-driver-gen} is a Doctest's driver file generator.  It
@@ -15012,17 +14497,19 @@ lets you automatically generate driver file for Doctest's Cabal integration.")
 (define-public ghc-template-haskell-compat-v0208
   (package
     (name "ghc-template-haskell-compat-v0208")
-    (version "0.1.6")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "template-haskell-compat-v0208" version))
-       (sha256
-        (base32 "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8"))))
+    (version "0.1.9.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "template-haskell-compat-v0208" version))
+              (sha256
+               (base32
+                "1z87rla4vcbghdrvjkay59b686f0by02102vwrcayn4vbwzn4am1"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "template-haskell-compat-v0208")))
-    (home-page "https://github.com/nikita-volkov/template-haskell-compat-v0208")
-    (synopsis "Backwards compatibility layer for Template Haskell newer than 2.8")
+    (home-page
+     "https://github.com/nikita-volkov/template-haskell-compat-v0208")
+    (synopsis
+     "Backwards compatibility layer for Template Haskell newer than 2.8")
     (description
      "This package provides a backwards compatibility layer for Template
 Haskell newer than 2.8.")
@@ -15084,28 +14571,26 @@ Haskell datatypes in text form using the @code{ghc-blaze-builder} library.")
 (define-public ghc-mysql-simple
   (package
     (name "ghc-mysql-simple")
-    (version "0.4.7")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "mysql-simple" version))
-       (sha256
-        (base32 "1mhmszpq64h8kxr20iaj1laq46wr2gaqc8xxq1k821i7jfxfld6j"))))
+    (version "0.4.9")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "mysql-simple" version))
+              (sha256
+               (base32
+                "0hwv1hlr65m5l2zrrj5zmvrjz9y2814jy05l17l5jb4j4j5xw3z2"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "mysql-simple")))
-    (arguments `(#:tests? #f)) ; TODO: Fails to connect to server.
-    (inputs
-     (list ghc-attoparsec
-           ghc-base16-bytestring
-           ghc-blaze-builder
-           ghc-mysql
-           ghc-pcre-light
-           ghc-old-locale
-           ghc-blaze-textual
-           ghc-vector
-           openssl
-           zlib))
+    (inputs (list ghc-attoparsec
+                  ghc-base16-bytestring
+                  ghc-blaze-builder
+                  ghc-mysql
+                  ghc-pcre-light
+                  ghc-old-locale
+                  ghc-vector
+                  openssl
+                  zlib))
     (native-inputs (list ghc-hspec))
+    (arguments (list #:tests? #f)) ; Fail to build.
     (home-page "https://github.com/paul-rouse/mysql-simple")
     (synopsis "Mid-level MySQL client library")
     (description
@@ -15116,27 +14601,25 @@ Haskell datatypes in text form using the @code{ghc-blaze-builder} library.")
 (define-public ghc-persistent-qq
   (package
     (name "ghc-persistent-qq")
-    (version "2.12.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "persistent-qq" version))
-       (sha256
-        (base32 "1dvniapxjaw2vmdqd5cplwxdxiy2l6z6gns8gp3ci3rn3xp0pf6p"))))
+    (version "2.12.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "persistent-qq" version))
+              (sha256
+               (base32
+                "0pzlhwl4h9q358zc6d0m5zv0ii2yhf2lzw0a3v2spfc1ch4a014a"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "persistent-qq")))
-    (inputs
-     (list ghc-haskell-src-meta ghc-persistent))
-    (native-inputs
-     (list ghc-hunit
-           ghc-aeson
-           ghc-fast-logger
-           ghc-hspec
-           ghc-monad-logger
-           ghc-persistent-sqlite
-           ghc-resourcet
-           ghc-unliftio))
-    (home-page "https://github.com/yesodweb/persistent")
+    (inputs (list ghc-haskell-src-meta ghc-persistent))
+    (native-inputs (list ghc-hunit
+                         ghc-aeson
+                         ghc-fast-logger
+                         ghc-hspec
+                         ghc-monad-logger
+                         ghc-persistent-sqlite
+                         ghc-resourcet
+                         ghc-unliftio))
+    (home-page "https://github.com/yesodweb/persistent#readme")
     (synopsis "Quasi-quoter for raw SQL for @code{ghc-persistent}")
     (description
      "This package provides a quasi-quoter for raw @acronym{SQL, Structured Query
@@ -15146,39 +14629,36 @@ Language} for @code{ghc-persistent}.")
 (define-public ghc-persistent-mysql
   (package
     (name "ghc-persistent-mysql")
-    (version "2.13.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "persistent-mysql" version))
-       (sha256
-        (base32 "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732"))))
+    (version "2.13.1.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "persistent-mysql" version))
+              (sha256
+               (base32
+                "0fm6agqwawwraw6l6kxm8lq40pm5pnjg093f574a7sdf648q21yc"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "persistent-mysql")))
-    (arguments `(#:tests? #f)) ; TODO: Fails to import MaybeFieldDefsTest.
-    (inputs
-     (list ghc-persistent
-           ghc-aeson
-           ghc-blaze-builder
-           ghc-conduit
-           ghc-monad-logger
-           ghc-mysql
-           ghc-mysql-simple
-           ghc-resourcet
-           ghc-resource-pool
-           ghc-unliftio-core
-           openssl
-           zlib))
-    (native-inputs
-     (list ghc-fast-logger
-           ghc-hspec
-           ghc-http-api-data
-           ghc-hunit
-           ghc-path-pieces
-           ghc-persistent-qq
-           ghc-persistent-test
-           ghc-quickcheck
-           ghc-quickcheck-instances))
+    (inputs (list ghc-persistent
+                  ghc-aeson
+                  ghc-blaze-builder
+                  ghc-conduit
+                  ghc-monad-logger
+                  ghc-mysql
+                  ghc-mysql-simple
+                  ghc-resourcet
+                  ghc-resource-pool
+                  ghc-unliftio-core
+                  openssl))
+    (native-inputs (list ghc-fast-logger
+                         ghc-hspec
+                         ghc-http-api-data
+                         ghc-hunit
+                         ghc-path-pieces
+                         ghc-persistent-qq
+                         ghc-persistent-test
+                         ghc-quickcheck
+                         ghc-quickcheck-instances))
+    (arguments (list #:tests? #f)) ; Fails to connect to server.
     (home-page "http://www.yesodweb.com/book/persistent")
     (synopsis
      "Backend for the @code{ghc-persistent} library using MySQL database server")
@@ -15246,8 +14726,8 @@ string types into values of other string types.")
     (build-system haskell-build-system)
     (properties '((upstream-name . "postgresql-libpq")))
     (arguments
-     `(#:cabal-revision
-       ("1" "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2")))
+     `(#:cabal-revision ("3"
+                         "02cj493a2qxl5hddiq0579079s398hdqqy164pig6d61nl7q66cs")))
     (inputs (list postgresql))
     (home-page "https://github.com/haskellari/postgresql-libpq")
     (synopsis "Low-level bindings to @code{libpq}")
@@ -15293,8 +14773,8 @@ server and to receive the results of these queries.")
            ghc-tasty-golden
            ghc-tasty-hunit))
     (arguments
-     `(#:cabal-revision
-       ("2" "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv")))
+     `(#:cabal-revision ("8"
+                         "1qavb3qs1g307pc19k9y3yvqp0c1srwsplijvayn9ldp0bxdy6q8")))
     (home-page "https://hackage.haskell.org/package/postgresql-simple")
     (synopsis "Mid-Level PostgreSQL client library")
     (description
@@ -15305,44 +14785,43 @@ server and to receive the results of these queries.")
 (define-public ghc-persistent-postgresql
   (package
     (name "ghc-persistent-postgresql")
-    (version "2.13.2.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "persistent-postgresql" version))
-       (sha256
-        (base32 "07pnr8m0nk43jaz6l293lzx4ivyqgnw94fjypazzm008b4irh7ir"))))
+    (version "2.13.5.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "persistent-postgresql" version))
+              (sha256
+               (base32
+                "1q9hy49nfrb3azgz5rjz235d7scy27l5axkih7crskaa04hf4k8d"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "persistent-postgresql")))
-    (arguments `(#:tests? #f)) ; TODO: Cannot import MaybeFieldDefsTest.
-    (inputs
-     (list ghc-persistent
-           ghc-aeson
-           ghc-attoparsec
-           ghc-blaze-builder
-           ghc-conduit
-           ghc-monad-logger
-           ghc-postgresql-simple
-           ghc-postgresql-libpq
-           ghc-resourcet
-           ghc-resource-pool
-           ghc-string-conversions
-           ghc-unliftio-core
-           ghc-unliftio))
-    (native-inputs
-     (list ghc-persistent-qq
-           ghc-persistent-test
-           ghc-fast-logger
-           ghc-hunit
-           ghc-hspec
-           ghc-hspec-expectations
-           ghc-hspec-expectations-lifted
-           ghc-quickcheck
-           ghc-quickcheck-instances
-           ghc-path-pieces
-           ghc-http-api-data
-           ghc-unordered-containers
-           ghc-vector))
+    (inputs (list ghc-persistent
+                  ghc-aeson
+                  ghc-attoparsec
+                  ghc-blaze-builder
+                  ghc-conduit
+                  ghc-monad-logger
+                  ghc-postgresql-simple
+                  ghc-postgresql-libpq
+                  ghc-resourcet
+                  ghc-resource-pool
+                  ghc-string-conversions
+                  ghc-unliftio-core
+                  ghc-vault
+                  ghc-unliftio))
+    (native-inputs (list ghc-persistent-qq
+                         ghc-persistent-test
+                         ghc-fast-logger
+                         ghc-hunit
+                         ghc-hspec
+                         ghc-hspec-expectations
+                         ghc-hspec-expectations-lifted
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-path-pieces
+                         ghc-http-api-data
+                         ghc-unordered-containers
+                         ghc-vector))
+    (arguments (list #:tests? #f)) ; Fails to connect to server.
     (home-page "http://www.yesodweb.com/book/persistent")
     (synopsis "Backend for the @code{ghc-persistent library} using Postgresql")
     (description
@@ -15393,22 +14872,21 @@ using the @code{ghc-postgresql-simple} package.")
 (define-public ghc-hsyaml-aeson
   (package
     (name "ghc-hsyaml-aeson")
-    (version "0.2.0.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "HsYAML-aeson" version))
-       (sha256
-        (base32 "12sxww260pc0bbpiyirm7911haxhljdi2f08a9ddpbgw8d5n7ffg"))))
+    (version "0.2.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "HsYAML-aeson" version))
+              (sha256
+               (base32
+                "139hqd07hkr8ykvrgmcshh9f3vp9dnrj6ks5nl8hgrpi990jsy5r"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "HsYAML-aeson")))
-    (inputs
-     (list ghc-hsyaml ghc-aeson ghc-scientific ghc-unordered-containers
-           ghc-vector))
+    (inputs (list ghc-hsyaml ghc-aeson ghc-scientific ghc-unordered-containers
+                  ghc-vector))
     (arguments
-     `(#:cabal-revision
-       ("3" "0vhdndyj5f07vvvnssn5ybdja5wmaydq0n2lfpihvdg4dkhczrx2")))
-    (home-page "https://hackage.haskell.org/package/HsYAML-aeson")
+     `(#:cabal-revision ("5"
+                         "06v8vkn58d67yx4v59rhvxpc0sjrpi6k8krvjrvbyl0fn0v0jd14")))
+    (home-page "http://hackage.haskell.org/package/HsYAML-aeson")
     (synopsis "JSON to YAML adapter")
     (description
      "The @uref{https://yaml.org/spec/1.2/spec.html, YAML 1.2} format provides
@@ -15443,8 +14921,8 @@ data into native Haskell data types.")
            ghc-tasty-hunit
            ghc-temporary))
     (arguments
-     `(#:cabal-revision
-       ("1" "0mmq1q82mrbayiij0p8wdnkf0j8drmq1iibg8kn4cak3nrn9pd1d")))
+     `(#:cabal-revision ("3"
+                         "1a6spmbiv3ias40sjrnsxfgr1d5mwg039a2q7113zb7i9n6c1m7g")))
     (home-page "https://hackage.haskell.org/package/lukko")
     (synopsis "File locking")
     (description
@@ -15465,15 +14943,16 @@ locking.
 (define-public ghc-dec
   (package
     (name "ghc-dec")
-    (version "0.0.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "dec" version))
-       (sha256
-        (base32 "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc"))))
+    (version "0.0.5")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "dec" version))
+              (sha256
+               (base32
+                "126z70ij9hhy8pajw0d5fl0hrppy5sh22j8nkx46i0g6qz3l7071"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "dec")))
+    (inputs (list ghc-boring))
     (home-page "https://github.com/phadej/vec")
     (synopsis "Decidable propositions")
     (description
@@ -15539,23 +15018,1260 @@ pages.")
 (define-public ghc-singleton-bool
   (package
     (name "ghc-singleton-bool")
-    (version "0.1.5")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "singleton-bool" version))
-       (sha256
-        (base32 "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0"))))
+    (version "0.1.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "singleton-bool" version))
+              (sha256
+               (base32
+                "1pc34dbzx5g3vw5w03zifvqva3whyvxzfy3yh78qkpd05f0g98sw"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "singleton-bool")))
-    (inputs (list ghc-dec))
+    (inputs (list ghc-boring ghc-dec ghc-some))
     (arguments
-     `(#:cabal-revision
-       ("3" "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x")))
-    (home-page "https://github.com/phadej/singleton-bool")
+     `(#:cabal-revision ("2"
+                         "1l4nx664awgwzk3ih5idsgnj220jqdr1c55241xjv7fz7lwyhh5r")))
+    (home-page "https://github.com/phadej/singleton-bool#readme")
     (synopsis "Type-level booleans")
+    (description "This package provides Type-level booleans.")
+    (license license:bsd-3)))
+
+(define-public ghc-breakpoint
+  (package
+    (name "ghc-breakpoint")
+    (version "0.1.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "breakpoint" version))
+              (sha256
+               (base32
+                "1hk9mjijxvqjzcfqllzi53rmxiyggbxash05jbb742wrq832h2xw"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "breakpoint")))
+    (inputs (list ghc-pretty-simple ghc-ansi-terminal))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "http://hackage.haskell.org/package/breakpoint")
+    (synopsis "Set breakpoints using a GHC plugin")
+    (description
+     "This package provides a plugin that allows you to set breakpoints for debugging
+purposes.  See the
+[README](https://github.com/aaronallen8455/breakpoint#breakpoint) for details.")
+    (license license:expat)))
+
+(define-public ghc-githash
+  (package
+    (name "ghc-githash")
+    (version "0.1.6.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "githash" version))
+              (sha256
+               (base32
+                "06zg1rif1rcxni1vacmr2bh1nbm6i62rjbikfr4xsyzq1sv7kfpw"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "githash")))
+    (inputs (list ghc-th-compat git))
+    (native-inputs (list ghc-hspec ghc-temporary ghc-unliftio hspec-discover))
+    (arguments
+     (list
+      #:phases
+      #~(modify-phases %standard-phases
+         (add-after 'unpack 'patch-git-path
+           (lambda _
+             (substitute* "src/GitHash.hs"
+               (("\"git\"") (string-append "\"" #$git "/bin/git\""))))))))
+    (home-page "https://github.com/snoyberg/githash#readme")
+    (synopsis "Compile git revision info into Haskell projects")
+    (description "Please see the README and documentation at
+<https://www.stackage.org/package/githash>")
+    (license license:bsd-3)))
+
+(define-public ghc-nothunks
+  (package
+    (name "ghc-nothunks")
+    (version "0.1.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "nothunks" version))
+              (sha256
+               (base32
+                "0lqfhnyxhmhajvsgmz5h428pb5zrdy9zvbc5inzhd83cv31yk4f1"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "nothunks")))
+    (inputs (list ghc-vector))
+    ;(native-inputs (list ghc-hedgehog ghc-random ghc-tasty ghc-tasty-hedgehog))
+    (arguments (list #:tests? #f)) ; Fail to compile.
+    (home-page "http://hackage.haskell.org/package/nothunks")
+    (synopsis "Examine values for unexpected thunks")
+    (description
+     "Long lived application data typically should not contain any thunks.  This
+library can be used to examine values for unexpected thunks, which can then be
+used in assertions.  This can be invaluable in avoiding memory leaks, or
+tracking down existing ones.")
+    (license license:expat)))
+
+(define-public ghc-nothunks-bootstrap
+  (package
+    (inherit ghc-nothunks)
+    (name "ghc-nothunks-bootstrap")
+    (arguments `(#:tests? #f))
+    (native-inputs '())
+    (properties '((hidden? #t)))))
+
+(define-public ghc-barbies
+  (package
+    (name "ghc-barbies")
+    (version "2.0.4.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "barbies" version))
+              (sha256
+               (base32
+                "0v8bckxi58fkqgf1i1xd3100wp792pzd319xlfvmmw8z0ii1g872"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "barbies")))
+    (inputs (list ghc-distributive))
+    (native-inputs (list ghc-quickcheck
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck
+                         ghc-quickcheck
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (home-page "https://github.com/jcpetruzza/barbies#readme")
+    (synopsis "Classes for working with types that can change clothes.")
     (description
-     "This package provides Type-level booleans.")
+     "Types that are parametric on a functor are like Barbies that have an outfit for
+each role.  This package provides the basic abstractions to work with them
+comfortably.")
+    (license license:bsd-3)))
+
+(define-public ghc-onetuple
+  (package
+    (name "ghc-onetuple")
+    (version "0.3.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "OneTuple" version))
+              (sha256
+               (base32
+                "1vry21z449ph9k61l5zm7mfmdwkwszxqdlawlhvwrd1gsn13d1cq"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "OneTuple")))
+    (native-inputs (list ghc-hashable))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0g4siv8s6dlrdsivap2qy6ig08y5bjbs93jk192zmgkp8iscncpw")))
+    (home-page "http://hackage.haskell.org/package/OneTuple")
+    (synopsis "Singleton Tuple")
+    (description
+     "This package is a compatibility package for a singleton data type . > data Solo
+a = Solo a .  Note: it's not a @@newtype@@ . @@Solo@@ is available in
+@@base-4.16@@ (GHC-9.2).")
+    (license license:bsd-3)))
+
+(define-public ghc-indexed-traversable-instances
+  (package
+    (name "ghc-indexed-traversable-instances")
+    (version "0.1.1.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "indexed-traversable-instances" version))
+              (sha256
+               (base32
+                "1c60vhf47y8ln33scyvwiffg24dvhm4aavya624vbqjr7l3fapl9"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "indexed-traversable-instances")))
+    (inputs (list ghc-indexed-traversable ghc-onetuple ghc-tagged
+                  ghc-unordered-containers ghc-vector))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck-instances ghc-tasty
+                         ghc-tasty-quickcheck))
+    (home-page
+     "http://hackage.haskell.org/package/indexed-traversable-instances")
+    (synopsis
+     "More instances of FunctorWithIndex, FoldableWithIndex, TraversableWithIndex")
+    (description
+     "This package provides extra instances for type-classes in the
+[indexed-traversable](https://hackage.haskell.org/package/indexed-traversable)
+package. .  The intention is to keep this package minimal; it provides instances
+that formely existed in @@lens@@ or @@optics-extra@@.  We recommend putting
+other instances directly into their defining packages.  The
+@@indexed-traversable@@ package is light, having only GHC boot libraries as its
+dependencies.")
+    (license license:bsd-2)))
+
+(define-public ghc-witherable
+  (package
+    (name "ghc-witherable")
+    (version "0.4.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "witherable" version))
+              (sha256
+               (base32
+                "0121ic4xkv3k568j23zp22a5lrv0k11h94fq7cbijd18fjr2n3br"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "witherable")))
+    (inputs (list ghc-base-orphans
+                  ghc-hashable
+                  ghc-unordered-containers
+                  ghc-vector
+                  ghc-indexed-traversable
+                  ghc-indexed-traversable-instances))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck-instances ghc-tasty
+                         ghc-tasty-quickcheck))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "1f2bvl41by904lnr0dk6qgasqwadq2w48l7fj51bp2h8bqbkdjyc")))
+    (home-page "https://github.com/fumieval/witherable")
+    (synopsis "filterable traversable")
+    (description
+     "This package provides a stronger variant of `traverse` which can remove elements
+and generalised mapMaybe, catMaybes, filter")
+    (license license:bsd-3)))
+
+(define-public ghc-hspec-discover
+  (package
+    (name "ghc-hspec-discover")
+    (version "2.9.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec-discover" version))
+              (sha256
+               (base32
+                "0536kdxjw6p8b6gcwvmr22jbmb6cgzbddi0fkd01b2m847z37sb5"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hspec-discover")))
+    (native-inputs (list ghc-quickcheck ghc-hspec-meta ghc-mockery))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Automatically discover and run Hspec tests")
+    (description "Automatically discover and run Hspec tests .
+<http://hspec.github.io/hspec-discover.html>")
+    (license license:expat)))
+
+(define-public ghc-doctest-parallel
+  (package
+    (name "ghc-doctest-parallel")
+    (version "0.2.6")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "doctest-parallel" version))
+              (sha256
+               (base32
+                "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "doctest-parallel")))
+    (inputs (list ghc-glob
+                  ghc-base-compat
+                  ghc-code-page
+                  ghc-extra
+                  ghc-paths
+                  ghc-random
+                  ghc-syb
+                  ghc-unordered-containers))
+    (native-inputs (list ghc-hunit
+                         ghc-quickcheck
+                         ghc-hspec
+                         ghc-hspec-core
+                         ghc-hspec-discover
+                         ghc-mockery
+                         ghc-setenv
+                         ghc-silently
+                         ghc-stringbuilder))
+    (arguments
+     `(#:haddock? #f)) ; Setup.lhs: internal error when calculating transitive package dependencies.
+    (home-page "https://github.com/martijnbastiaan/doctest-parallel#readme")
+    (synopsis "Test interactive Haskell examples")
+    (description
+     "The doctest program checks examples in source code comments.  It is modeled
+after doctest for Python (<https://docs.python.org/3/library/doctest.html>). .
+Documentation is at
+<https://github.com/martijnbastiaan/doctest-parallel#readme>.")
+    (license license:expat)))
+
+(define-public ghc-pcg-random
+  (package
+    (name "ghc-pcg-random")
+    (version "0.1.3.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "pcg-random" version))
+              (sha256
+               (base32
+                "1l6jq5nvmg1ygk7i7g50s47p6qkh74p9avl1wbcxdl5m85lc5j76"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "pcg-random")))
+    (inputs (list ghc-primitive ghc-random ghc-entropy))
+    (native-inputs (list ghc-doctest))
+    (arguments
+     `(#:tests? #f ; Could not find module ‘Build_doctests’
+       #:phases
+       (modify-phases %standard-phases
+         ;; Tries to use non-existent doctest API.
+         (add-after 'unpack 'disable-doctest
+           (lambda _
+             (with-output-to-file "Setup.hs"
+               (lambda _
+                 (display
+                  "import Distribution.Simple\nmain = defaultMain\n"))))))))
+    (home-page "http://github.com/cchalmers/pcg-random")
+    (synopsis "Haskell bindings to the PCG random number generator.")
+    (description
+     "PCG is a family of simple fast space-efficient statistically good algorithms for
+random number generation.  Unlike many general-purpose RNGs, they are also hard
+to predict. .  This library implements bindings to the standard C
+implementation.  This includes the standard, unique, fast and single variants in
+the pcg family.  There is a pure implementation that can be used as a generator
+with the random package as well as a faster primitive api that includes
+functions for generating common types. .  The generators in this module are
+suitable for use in parallel but make sure threads don't share the same
+generator or things will go horribly wrong.")
+    (license license:bsd-3)))
+
+(define-public ghc-random-bytestring
+  (package
+    (name "ghc-random-bytestring")
+    (version "0.1.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "random-bytestring" version))
+              (sha256
+               (base32
+                "0f4n41gqxxggadysvx3vg2iq89z7i7692ccrfmiajq73lbp6y34j"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "random-bytestring")))
+    (inputs (list ghc-mwc-random ghc-nats ghc-pcg-random))
+    (home-page "https://www.github.com/larskuhtz/random-bytestring")
+    (synopsis "Efficient generation of random bytestrings")
+    (description
+     "__This package is deprecated__.  Please, use genByteString from the [random
+package (version >=1.2)](https://hackage.haskell.org/package/random) instead. .
+Efficient generation of random bytestrings.  The implementation populates
+uninitialized memory with uniformily distributed random 64 bit words (and 8 bit
+words for remaining bytes at the end of the bytestring). .  Random words are
+generated using the PRNG from the
+[mwc-random](https://hackage.haskell.org/package/mwc-random) package or the
+[pcg-random](https://hackage.haskell.org/package/pcg-random) package.  It is
+also possible to use a custom PRNG by providing an instance for the RandomWords
+type class and using the function generate from the module
+\"Data.ByteString.Random.Internal\". .  The generated byte strings are suitable
+for statistical applications.  They are /not/ suitable for cryptographic
+applications. .
+![benchmarks](https://hackage.haskell.org/package/random-bytestring-0.1.3.2/src/benchmarks.png)
+. ![detailed
+benchmarks](https://hackage.haskell.org/package/random-bytestring-0.1.3.2/src/benchmarks-details.png)")
+    (license license:expat)))
+
+(define-public ghc-base64
+  (package
+    (name "ghc-base64")
+    (version "0.4.2.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "base64" version))
+              (sha256
+               (base32
+                "119mpqcv1rwkhwm69ga2b4f7hr825fa5wfm1w3i1szmhzh52s2k4"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "base64")))
+    (inputs (list ghc-text-short))
+    (native-inputs (list ghc-base64-bytestring
+                         ghc-quickcheck
+                         ghc-random-bytestring
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "0cz3zzz9k490w9nfn4hpgdw4zx4w70fwqrwsfx8svcwqssqibqw3")))
+    (home-page "https://github.com/emilypi/base64")
+    (synopsis "A modern RFC 4648-compliant Base64 library")
+    (description
+     "RFC 4648-compliant Base64 with an eye towards performance and modernity
+(additional support for RFC 7049 standards)")
+    (license license:bsd-3)))
+
+(define-public ghc-ordered-containers
+  (package
+    (name "ghc-ordered-containers")
+    (version "0.2.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "ordered-containers" version))
+              (sha256
+               (base32
+                "18w1dasny6xffbjlvmz9861l2xbkqlg2w5qxz9kw6frgfl2rg11n"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "ordered-containers")))
+    (home-page "http://hackage.haskell.org/package/ordered-containers")
+    (synopsis
+     "Set- and Map-like types that remember the order elements were inserted")
+    (description "")
+    (license license:bsd-3)))
+
+(define-public ghc-cabal-syntax
+  (package
+    (name "ghc-cabal-syntax")
+    (version "3.6.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "Cabal-syntax" version))
+              (sha256
+               (base32
+                "0lcj4g55sj5iv727g7k57pscgyj0fx3smwapm1gmd5qkc3yfa9fa"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "Cabal-syntax")))
+    (home-page "http://www.haskell.org/cabal/")
+    (synopsis "A library for working with .cabal files")
+    (description
+     "This library provides tools for reading and manipulating the .cabal file format.
+.  Version 3.6 (unlike the following versions) is a dummy package that prevents
+module name clases between Cabal and Cabal-syntax if used together with a Cabal
+flag as described below. .  In Cabal-3.7 this package was split off.  To avoid
+module name clashes, you can add this to your .cabal file: . > flag Cabal-syntax
+> description: Use the new Cabal-syntax package > default: False > manual: False
+> > library > -- ... > if flag(Cabal-syntax) > build-depends: Cabal-syntax >=
+3.7 > else > build-depends: Cabal < 3.7, Cabal-syntax < 3.7 .  This will default
+to the older build, but will allow consumers to opt-in to the newer libraries by
+requiring Cabal or Cabal-syntax >= 3.7")
+    (license license:bsd-3)))
+
+(define-public ghc-tasty-hslua
+  (package
+    (name "ghc-tasty-hslua")
+    (version "1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tasty-hslua" version))
+              (sha256
+               (base32
+                "0ibdxwaclghcgcyf9zx4b1dnp4b708ydwli4clmb0a0mp1lwdp98"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "tasty-hslua")))
+    (inputs (list ghc-hslua-core ghc-tasty ghc-tasty-hunit))
+    (home-page "https://hslua.org/")
+    (synopsis "Tasty helpers to test HsLua.")
+    (description
+     "Various tasty helpers and utilities to test HsLua oparations.  Built on top of
+tasty-hunit.")
+    (license license:expat)))
+
+(define-public ghc-hslua-marshalling
+  (package
+    (name "ghc-hslua-marshalling")
+    (version "2.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-marshalling" version))
+              (sha256
+               (base32
+                "1xmix1frfcyv4p51rnshrg02gba7di7nrrc6chsq71d3mbwhyask"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-marshalling")))
+    (inputs (list ghc-hslua-core))
+    (native-inputs (list ghc-lua-arbitrary
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-tasty-hslua
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (home-page "https://hslua.org/")
+    (synopsis "Marshalling of values between Haskell and Lua.")
+    (description
+     "This package provides functions to marshal values from Haskell to Lua, and /vice
+versa/. .  This package is part of HsLua, a Haskell framework built around the
+embeddable scripting language <https://lua.org Lua>.")
+    (license license:expat)))
+
+(define-public ghc-lua-arbitrary
+  (package
+    (name "ghc-lua-arbitrary")
+    (version "1.0.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lua-arbitrary" version))
+              (sha256
+               (base32
+                "01g2pkvy7yhcrk8p1d9xzmqv279ldgy9z5aa6xj5msbxrpxvbpma"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "lua-arbitrary")))
+    (inputs (list ghc-lua ghc-quickcheck))
+    (home-page "https://hslua.org/")
+    (synopsis "Arbitrary instances for Lua types.")
+    (description
+     "This package provides instances for QuickCheck's \\\"Arbitrary\\\" typeclass.")
+    (license license:expat)))
+
+(define-public ghc-lua
+  (package
+    (name "ghc-lua")
+    (version "2.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lua" version))
+              (sha256
+               (base32
+                "07wni3ji46ndqabwffgwzij2jk34dq2d66z15hcd6jg33sqnym45"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "lua")))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "https://hslua.org/")
+    (synopsis "Lua, an embeddable scripting language")
+    (description
+     "This package provides bindings and types to bridge Haskell and
+<https://www.lua.org/ Lua>. .  The full Lua interpreter version 5.4.4 is
+included.  Alternatively, a system-wide Lua installation can be linked instead.")
+    (license license:expat)))
+
+(define-public ghc-hslua-core
+  (package
+    (name "ghc-hslua-core")
+    (version "2.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-core" version))
+              (sha256
+               (base32
+                "0hy3a7rn940bcj0shxyk75dndwl23wwmmvbnwnay36py60hy3rbq"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-core")))
+    (inputs (list ghc-lua))
+    (native-inputs (list ghc-lua-arbitrary
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-tasty
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (home-page "https://hslua.org/")
+    (synopsis "Bindings to Lua, an embeddable scripting language")
+    (description
+     "Wrappers and helpers to bridge Haskell and <https://www.lua.org/ Lua>. .  It
+builds upon the /lua/ package, which allows to bundle a Lua interpreter with a
+Haskell program.")
+    (license license:expat)))
+
+(define-public ghc-hslua-aeson
+  (package
+    (name "ghc-hslua-aeson")
+    (version "2.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-aeson" version))
+              (sha256
+               (base32
+                "0igmkay5bf3wg1n6rqm20kjv1xq36x552lgdvr1vlpwikgsiq8mb"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-aeson")))
+    (inputs (list ghc-aeson
+                  ghc-hashable
+                  ghc-hslua-core
+                  ghc-hslua-marshalling
+                  ghc-scientific
+                  ghc-unordered-containers
+                  ghc-vector))
+    (native-inputs (list ghc-quickcheck ghc-quickcheck-instances ghc-tasty
+                         ghc-tasty-quickcheck))
+    (home-page "https://hslua.org/")
+    (synopsis "Allow aeson data types to be used with Lua.")
+    (description
+     "This package provides instances to push and receive any datatype encodable as
+JSON to and from the Lua stack.")
+    (license license:expat)))
+
+(define-public ghc-gridtables
+  (package
+    (name "ghc-gridtables")
+    (version "0.0.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "gridtables" version))
+              (sha256
+               (base32
+                "1akix9flnax6dx3s9c7yyzb19nw13y8rmh0kz7y3hpjlkaz659xy"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "gridtables")))
+    (inputs (list ghc-doclayout))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0m2651z81n8s6hb8id7y6k2kprsgwnj7pcd6p8lmdpkzzz3wwd0c")))
+    (home-page "https://github.com/tarleb/gridtables")
+    (synopsis "Parser for reStructuredText-style grid tables.")
+    (description
+     "This package provides a parser for plain-text representations of tables.  This
+package supports table headers, cells spanning multiple columns or rows, as well
+as a way to specfiy column alignments.")
+    (license license:expat)))
+
+(define-public ghc-lpeg
+  (package
+    (name "ghc-lpeg")
+    (version "1.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "lpeg" version))
+              (sha256
+               (base32
+                "19vvsvdw8l2zjwdcypnzw12vc9ycix92mkd6g3f6kx1i364z9hg1"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "lpeg")))
+    (inputs (list ghc-lua))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit))
+    (home-page "https://hslua.org/")
+    (synopsis "LPeg – Parsing Expression Grammars For Lua")
+    (description
+     "This package contains the C sources of LPeg, as well as some tiny Haskell helper
+to load the package. . <http://www.inf.puc-rio.br/~roberto/lpeg/>")
+    (license license:expat)))
+
+(define-public ghc-pandoc-lua-marshal
+  (package
+    (name "ghc-pandoc-lua-marshal")
+    (version "0.1.7")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "pandoc-lua-marshal" version))
+              (sha256
+               (base32
+                "0pn9b7f8dln049k76zb4znscl01qms751y1ln4j8irs50rc1b55j"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "pandoc-lua-marshal")))
+    (inputs (list ghc-lua ghc-hslua ghc-hslua-marshalling ghc-pandoc-types
+                  ghc-safe))
+    (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-hunit
+                         ghc-tasty-lua ghc-tasty-quickcheck))
+    (home-page "https://github.com/pandoc/pandoc-lua-marshal")
+    (synopsis "Use pandoc types in Lua")
+    (description
+     "This package provides functions to marshal and unmarshal pandoc document types
+to and from Lua. .  The values of most types are pushed to pandoc as \"userdata\"
+objects that wrap a stable pointer to the Haskell value; these objects come with
+methods to access and modify their properties. .  Sequences are pushed as normal
+Lua tables, but are augmented with convenience functions.")
+    (license license:expat)))
+
+(define-public ghc-should-not-typecheck
+  (package
+    (name "ghc-should-not-typecheck")
+    (version "2.1.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "should-not-typecheck" version))
+              (sha256
+               (base32
+                "14fmv0mv2v4fqzynamlrmdj6d1l65aw1srf1wv19nrq7rrqaqf7m"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "should-not-typecheck")))
+    (inputs (list ghc-hunit))
+    (native-inputs (list ghc-hspec ghc-hspec-expectations))
+    (home-page "http://github.com/CRogers/should-not-typecheck")
+    (synopsis
+     "A HUnit/hspec assertion library to verify that an expression does not typecheck")
+    (description
+     "For examples and an introduction to the library please take a look at the
+<https://github.com/CRogers/should-not-typecheck#should-not-typecheck- README>
+on github.")
+    (license license:bsd-3)))
+
+(define-public ghc-hspec-wai
+  (package
+    (name "ghc-hspec-wai")
+    (version "0.11.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec-wai" version))
+              (sha256
+               (base32
+                "03wiksic5y9a2g6a86nsxrnajdgdvpv17w02h5qla0zp9zs6pa1j"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hspec-wai")))
+    (inputs (list ghc-quickcheck
+                  ghc-base-compat
+                  ghc-case-insensitive
+                  ghc-hspec-core
+                  ghc-hspec-expectations
+                  ghc-http-types
+                  ghc-wai
+                  ghc-wai-extra))
+    (native-inputs (list ghc-hspec hspec-discover))
+    (home-page "https://github.com/hspec/hspec-wai#readme")
+    (synopsis "Experimental Hspec support for testing WAI applications")
+    (description "Experimental Hspec support for testing WAI applications")
+    (license license:expat)))
+
+(define-public ghc-http-media
+  (package
+    (name "ghc-http-media")
+    (version "0.8.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "http-media" version))
+              (sha256
+               (base32
+                "0lww5cxrc9jlvzsysjv99lca33i4rb7cll66p3c0rdpmvz8pk0ir"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "http-media")))
+    (inputs (list ghc-case-insensitive ghc-utf8-string))
+    (native-inputs (list ghc-quickcheck ghc-test-framework
+                         ghc-test-framework-quickcheck2))
+    (arguments
+     `(#:cabal-revision ("7"
+                         "1sm8bnrqvwkj7f60x4s8vfsj6lfi0knq38im35x88wk8s9whg6jd")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'update-constraints
+           (lambda _
+             (substitute* "http-media.cabal"
+               (("QuickCheck                 >= 2.8  && < 2.14") "QuickCheck")
+               (("base                       >= 4.7  && < 4.13") "base")))))))
+    (home-page "https://github.com/zmthy/http-media")
+    (synopsis "Processing HTTP Content-Type and Accept headers")
+    (description
+     "This library is intended to be a comprehensive solution to parsing and selecting
+quality-indexed values in HTTP headers.  It is capable of parsing both media
+types and language parameters from the Accept and Content header families, and
+can be extended to match against other accept headers as well.  Selecting the
+appropriate header value is achieved by comparing a list of server options
+against the quality-indexed values supplied by the client. .  In the following
+example, the Accept header is parsed and then matched against a list of server
+options to serve the appropriate media using mapAcceptMedia': . > getHeader >>=
+maybe send406Error sendResourceWith .  mapAcceptMedia > [ (\"text/html\", asHtml)
+> , (\"application/json\", asJson) > ] .  Similarly, the Content-Type header can
+be used to produce a parser for request bodies based on the given content type
+with mapContentMedia': . > getContentType >>= maybe send415Error
+readRequestBodyWith .  mapContentMedia > [ (\"application/json\", parseJson) > ,
+(\"text/plain\", parseText) > ] .  The API is agnostic to your choice of server.")
+    (license license:expat)))
+
+(define-public ghc-servant
+  (package
+    (name "ghc-servant")
+    (version "0.19.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "servant" version))
+              (sha256
+               (base32
+                "1gk6j39rcjpjacs351lknhrwj86yr4ifyp3qwlmiig27dxqlig3q"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "servant")))
+    (inputs (list ghc-constraints
+                  ghc-sop-core
+                  ghc-http-api-data
+                  ghc-singleton-bool
+                  ghc-base-compat
+                  ghc-aeson
+                  ghc-attoparsec
+                  ghc-bifunctors
+                  ghc-case-insensitive
+                  ghc-http-media
+                  ghc-http-types
+                  ghc-mmorph
+                  ghc-network-uri
+                  ghc-quickcheck
+                  ghc-string-conversions
+                  ghc-tagged
+                  ghc-vault))
+    (native-inputs (list ghc-hspec ghc-quickcheck-instances hspec-discover))
+    (home-page "http://docs.servant.dev/")
+    (synopsis "A family of combinators for defining webservices APIs")
+    (description
+     "This package provides a family of combinators for defining webservices APIs and
+serving them .  You can learn about the basics in the
+<http://docs.servant.dev/en/stable/tutorial/index.html tutorial>. .
+<https://github.com/haskell-servant/servant/blob/master/servant/CHANGELOG.md
+CHANGELOG>")
+    (license license:bsd-3)))
+
+(define-public ghc-servant-server
+  (package
+    (name "ghc-servant-server")
+    (version "0.19.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "servant-server" version))
+              (sha256
+               (base32
+                "1a7msh8p59v5mgsnj5li9s3jg0jwq2zjsznr0cg7g0fncn7r1axy"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "servant-server")))
+    (inputs (list ghc-constraints
+                  ghc-servant
+                  ghc-http-api-data
+                  ghc-base-compat
+                  ghc-base64-bytestring
+                  ghc-http-media
+                  ghc-http-types
+                  ghc-network-uri
+                  ghc-monad-control
+                  ghc-network
+                  ghc-sop-core
+                  ghc-string-conversions
+                  ghc-resourcet
+                  ghc-tagged
+                  ghc-transformers-base
+                  ghc-wai
+                  ghc-wai-app-static
+                  ghc-word8
+                  ghc-aeson
+                  ghc-warp))
+    (native-inputs (list ghc-safe
+                         ghc-transformers-compat
+                         ghc-hspec
+                         ghc-hspec-wai
+                         ghc-quickcheck
+                         ghc-should-not-typecheck
+                         ghc-temporary
+                         ghc-wai-extra
+                         hspec-discover))
+    (home-page "http://docs.servant.dev/")
+    (synopsis
+     "A family of combinators for defining webservices APIs and serving them")
+    (description
+     "This package provides a family of combinators for defining webservices APIs and
+serving them .  You can learn about the basics in the
+<http://docs.servant.dev/en/stable/tutorial/index.html tutorial>. .
+<https://github.com/haskell-servant/servant/blob/master/servant-server/example/greet.hs
+Here> is a runnable example, with comments, that defines a dummy API and
+implements a webserver that serves this API, using this package. .
+<https://github.com/haskell-servant/servant/blob/master/servant-server/CHANGELOG.md
+CHANGELOG>")
+    (license license:bsd-3)))
+
+(define-public ghc-boring
+  (package
+    (name "ghc-boring")
+    (version "0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "boring" version))
+              (sha256
+               (base32
+                "0d2cm9ra69cvaxs5x3lr2rfv7xx6xrbpb3dbcpyd8m77cqxm7b0b"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "boring")))
+    (inputs (list ghc-tagged))
+    (arguments
+     `(#:cabal-revision ("2"
+                         "04pn94i3mysi7px93k86sf29vw99sf38sl4n0gy2nma0iqsik828")))
+    (home-page "https://github.com/phadej/boring")
+    (synopsis "Boring and Absurd types")
+    (description
+     "* @@Boring@@ types are isomorphic to @@()@@. . * @@Absurd@@ types are isomorphic
+to @@Void@@. .  See [What does () mean in Haskell -answer by Conor
+McBride](https://stackoverflow.com/questions/33112439/what-does-mean-in-haskell/33115522#33115522)")
+    (license license:bsd-3)))
+
+(define-public ghc-some
+  (package
+    (name "ghc-some")
+    (version "1.0.4.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "some" version))
+              (sha256
+               (base32
+                "1qy840b2f58f0jxmw4q9sfgbx64kypzdlqnwc72md5wwv84b9b1d"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "some")))
+    (home-page "https://github.com/haskellari/some")
+    (synopsis "Existential type: Some")
+    (description
+     "This library defines an existential type Some'. . @@ data Some f where \\ Some ::
+f a -> Some f @@ .  in few variants, and utilities to work with it. .  If you
+are unsure which variant to use, use the one in \"Data.Some\" module.")
+    (license license:bsd-3)))
+
+(define-public ghc-hslua-classes
+  (package
+    (name "ghc-hslua-classes")
+    (version "2.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-classes" version))
+              (sha256
+               (base32
+                "1z7ym3whcq16k2cm9jf7sf0vwmp52iv1f0iicvv4jk6xks9d6ia1"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-classes")))
+    (inputs (list ghc-hslua-core ghc-hslua-marshalling))
+    (native-inputs (list ghc-lua-arbitrary
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-tasty
+                         ghc-tasty-hslua
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (home-page "https://hslua.org/")
+    (synopsis "Type classes for HsLua")
+    (description
+     "Type classes for convenient marshalling and calling of Lua functions.")
+    (license license:expat)))
+
+(define-public ghc-hslua-objectorientation
+  (package
+    (name "ghc-hslua-objectorientation")
+    (version "2.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-objectorientation" version))
+              (sha256
+               (base32
+                "13011yzz6lrgl2gasn9w5ggdqgrdz49hhqk1h259qd9gq29jnq3y"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-objectorientation")))
+    (inputs (list ghc-hslua-core ghc-hslua-marshalling))
+    (native-inputs (list ghc-lua-arbitrary
+                         ghc-quickcheck
+                         ghc-quickcheck-instances
+                         ghc-tasty
+                         ghc-tasty-hslua
+                         ghc-tasty-hunit
+                         ghc-tasty-quickcheck))
+    (home-page "https://hslua.org/")
+    (synopsis "Object orientation tools for HsLua")
+    (description
+     "Expose Haskell objects to Lua with an object oriented interface.")
+    (license license:expat)))
+
+(define-public ghc-hslua-packaging
+  (package
+    (name "ghc-hslua-packaging")
+    (version "2.2.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-packaging" version))
+              (sha256
+               (base32
+                "1yxfrsxmmsb96lyfihlk9ks53l2z2aln3whfqaha7grs3gx1yaib"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-packaging")))
+    (inputs (list ghc-hslua-core ghc-hslua-marshalling
+                  ghc-hslua-objectorientation))
+    (native-inputs (list ghc-tasty-hslua ghc-tasty ghc-tasty-hunit))
+    (home-page "https://hslua.org/")
+    (synopsis "Utilities to build Lua modules.")
+    (description
+     "Utilities to package up Haskell functions and values into a Lua module. .  This
+package is part of HsLua, a Haskell framework built around the embeddable
+scripting language <https://lua.org Lua>.")
+    (license license:expat)))
+
+(define-public ghc-hslua-module-version
+  (package
+    (name "ghc-hslua-module-version")
+    (version "1.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-module-version" version))
+              (sha256
+               (base32
+                "1v24lbbagvaz0hacq4525snp6smz8yc5ifrxg89z1y5bbn7v46f5"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-module-version")))
+    (inputs (list ghc-hslua-core ghc-hslua-marshalling ghc-hslua-packaging))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua))
+    (home-page "https://hslua.org/")
+    (synopsis "Lua module to work with version specifiers.")
+    (description "Wrapper for the Data.Version.Version Haskell type.")
+    (license license:expat)))
+
+(define-public ghc-recv
+  (package
+    (name "ghc-recv")
+    (version "0.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "recv" version))
+              (sha256
+               (base32
+                "1yz9b95m9yxcwbbwdvp288y47ycn4yq9g7ixlw0sf98h5rjp4s2w"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "recv")))
+    (inputs (list ghc-network))
+    (native-inputs (list ghc-hspec hspec-discover))
+    (home-page "http://github.com/yesodweb/wai")
+    (synopsis "Efficient netowrk recv")
+    (description "Network recv based on buffer pools")
+    (license license:bsd-3)))
+
+(define-public ghc-glib
+  (package
+    (name "ghc-glib")
+    (version "0.13.8.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "glib" version))
+              (sha256
+               (base32
+                "09qamkxkpx2paazbh8x225wvwgzgpp0g0a3s708n96q76b4bvd46"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "glib")))
+    (inputs (list ghc-utf8-string glib))
+    (native-inputs (list ghc-gtk2hs-buildtools pkg-config))
+    (home-page "https://github.com/gtk2hs/gtk2hs")
+    (synopsis "GLib bindings for for Gtk2Hs")
+    (description
+     "GLib is a collection of C data structures and utility functions for the GObject
+system, main loop implementation, for strings and common data structures dealing
+with Unicode.  This package only binds as much functionality as required to
+support the packages that wrap libraries that are themselves based on GLib.")
+    (license license:lgpl2.1)))
+
+(define-public ghc-pango
+  (package
+    (name "ghc-pango")
+    (version "0.13.8.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "pango" version))
+              (sha256
+               (base32
+                "1mndcb904vlkqpbmj5np9lxqw2qw3pzawvrgbsbxa9xjayh0ylw5"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "pango")))
+    (inputs (list ghc-glib ghc-cairo pango))
+    (native-inputs (list ghc-gtk2hs-buildtools pkg-config))
+    (home-page "https://hackage.haskell.org/package/pango")
+    (synopsis "Haskell bindings to the Pango text rendering engine")
+    (description
+     "This package provides a wrapper around the Pango C library that allows
+high-quality rendering of Unicode text.  It can be used either with Cairo to
+output text in PDF, PS or other documents or with Gtk+ to display text
+on-screen.")
+    (license license:lgpl2.1)))
+
+(define-public ghc-monoidal-containers
+  (package
+    (name "ghc-monoidal-containers")
+    (version "0.6.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "monoidal-containers" version))
+              (sha256
+               (base32
+                "0m41z50r3jvr8vvfry99kamb2h3knm0g7bqfwspchmhwsgqqczh4"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "monoidal-containers")))
+    (inputs (list ghc-aeson
+                  ghc-hashable
+                  ghc-lens
+                  ghc-newtype
+                  ghc-unordered-containers
+                  ghc-witherable
+                  ghc-semialign
+                  ghc-these))
+    (home-page "http://github.com/bgamari/monoidal-containers")
+    (synopsis "Containers with monoidal accumulation")
+    (description
+     "Containers with merging via monoidal accumulation.  The Monoid instances
+provided by the @code{containers} and @code{unordered-containers} packages merge
+structures in a left-biased manner instead of using the underlying monoidal
+structure of the value.  This package wraps the types provided by these
+packages, but provides @code{Monoid} instances implemented in terms of the value
+type's mappend'.")
+    (license license:bsd-3)))
+
+(define-public ghc-newtype
+  (package
+    (name "ghc-newtype")
+    (version "0.2.2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "newtype" version))
+              (sha256
+               (base32
+                "1b7bamnd0p8vmxvlg39g5d4a2av49kx10rdyz04ixa28pg8zy01s"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "newtype")))
+    (arguments
+     `(#:cabal-revision ("3"
+                         "0yll88ydchd2gqcvdk28fchf2vygpd42ky2bigg4ga08jan2nacx")))
+    (home-page "http://hackage.haskell.org/package/newtype")
+    (synopsis "Typeclass and set of functions for working with newtypes")
+    (description
+     "Per Conor McBride, the Newtype typeclass represents the packing and unpacking of
+a @code{newtype}, and allows you to operate under that @code{newtype} with functions
+such as ala'.")
+    (license license:bsd-3)))
+
+(define-public ghc-hspec-hedgehog
+  (package
+    (name "ghc-hspec-hedgehog")
+    (version "0.0.1.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hspec-hedgehog" version))
+              (sha256
+               (base32
+                "17gbr4ssnzjk7nvpsnh47av6vd9wz27ax92xvr4jwyw0z7h2wn13"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hspec-hedgehog")))
+    (inputs (list ghc-hspec
+                  ghc-hspec-core
+                  ghc-hedgehog
+                  ghc-hunit
+                  ghc-quickcheck
+                  ghc-splitmix))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "1qv2gap0775d2zg8wbd3kq4ypziz05qlz5jfisvl3jfd6jzcf2ad")))
+    (home-page "https://github.com/parsonsmatt/hspec-hedgehog#readme")
+    (synopsis "Integrate Hedgehog and Hspec")
+    (description "An integration library for hspec and hedgehog.")
+    (license license:bsd-3)))
+
+(define-public ghc-validation-selective
+  (package
+    (name "ghc-validation-selective")
+    (version "0.1.0.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "validation-selective" version))
+              (sha256
+               (base32
+                "1gsvcm8gjp8kdfprd1i4h9si8f2ym1gj3hqfwz7x1ylsa8qxwvq1"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "validation-selective")))
+    (inputs (list ghc-selective))
+    (native-inputs (list ghc-hedgehog ghc-hspec ghc-hspec-hedgehog ghc-doctest))
+    (home-page "https://github.com/kowainik/validation-selective")
+    (synopsis
+     "Data validation based on Applicative and Selective functors")
+    (description
+     "Lighweight pure data validation based on Applicative and Selective functors.")
+    (license license:mpl2.0)))
+
+(define-public ghc-tomland
+  (package
+    (name "ghc-tomland")
+    (version "1.3.3.2")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "tomland" version))
+              (sha256
+               (base32
+                "152jqjv6n7n2hdysn903wfhpwh6vp8wmjiymzasazprasdcxpywm"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "tomland")))
+    (inputs (list ghc-hashable ghc-megaparsec ghc-parser-combinators
+                  ghc-unordered-containers ghc-validation-selective))
+    (native-inputs (list ghc-hedgehog ghc-hspec ghc-hspec-hedgehog
+                         ghc-hspec-megaparsec))
+    (home-page "https://github.com/kowainik/tomland")
+    (synopsis "Bidirectional TOML serialization")
+    (description
+     "Implementation of bidirectional TOML serialization.")
+    (license license:mpl2.0)))
+
+(define-public ghc-hslua-module-doclayout
+  (package
+    (name "ghc-hslua-module-doclayout")
+    (version "1.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "hslua-module-doclayout" version))
+              (sha256
+               (base32
+                "14sqffgcrhhrv7k4j8b1l41mn5gqlp8yzggd727746kjl0n56hqq"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "hslua-module-doclayout")))
+    (inputs (list ghc-doclayout ghc-hslua))
+    (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua))
+    (home-page "https://github.com/hslua/hslua-module-doclayout")
+    (synopsis "Lua module wrapping Text.DocLayout")
+    (description "Lua module wrapping @code{Text.DocLayout}.")
+    (license license:expat)))
+
+(define-public ghc-random-shuffle
+  (package
+    (name "ghc-random-shuffle")
+    (version "0.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "random-shuffle" version))
+              (sha256
+               (base32
+                "0586bnlh0g2isc44jbjvafkcl4yw6lp1db8x6vr0pza0y08l8w2j"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "random-shuffle")))
+    (inputs (list ghc-random ghc-monadrandom))
+    (home-page "http://hackage.haskell.org/package/random-shuffle")
+    (synopsis "Random shuffle implementation")
+    (description
+     "Random shuffle implementation, on immutable lists.  Based on
+@url{http://okmij.org/ftp/Haskell/perfect-shuffle.txt, perfect shuffle
+implementation by Oleg Kiselyov}.")
+    (license license:bsd-3)))
+
+(define-public ghc-deriving-aeson
+  (package
+    (name "ghc-deriving-aeson")
+    (version "0.2.8")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "deriving-aeson" version))
+              (sha256
+               (base32
+                "0f59ar4cax7g0h6wrk8ckni7i4gw5wls5ybzbrji2a0qpd7q5lrd"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "deriving-aeson")))
+    (inputs (list ghc-aeson))
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0pwx7lmdhpipg9ksqkz6xpjzh1aw2hip8y3jsk20ndl4wdzvxak5")))
+    (home-page "http://hackage.haskell.org/package/deriving-aeson")
+    (synopsis "Type driven generic aeson instance customisation")
+    (description
+     "This package provides a newtype wrapper with FromJSON/ToJSON instances
+customisable via a phantom type parameter.  The instances can be rendered to the
+original type using DerivingVia.")
+    (license license:bsd-3)))
+
+(define-public ghc-leancheck
+  (package
+    (name "ghc-leancheck")
+    (version "0.9.12")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "leancheck" version))
+              (sha256
+               (base32
+                "15wpklkbr03dciai4mk8bm1yk9svxxmbsl22wsvwk3ns7aiamrkj"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "leancheck")))
+    (home-page "https://github.com/rudymatela/leancheck#readme")
+    (synopsis "Enumerative property-based testing")
+    (description
+     "LeanCheck is a simple enumerative property-based testing library.  Properties
+are defined as Haskell functions returning a boolean value which should be true
+for all possible choices of argument values.  LeanCheck applies enumerated
+argument values to these properties in search for a counterexample.  Properties
+can be viewed as parameterized unit tests.  LeanCheck works by producing tiers
+of test values: a possibly infinite list of finite sublists of
+same-and-increasingly-sized values.")
+    (license license:bsd-3)))
+
+(define-public ghc-test-framework-leancheck
+  (package
+    (name "ghc-test-framework-leancheck")
+    (version "0.0.4")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "test-framework-leancheck" version))
+              (sha256
+               (base32
+                "0aa21r999jj59plzkn1px02k3a87znwhagdjmdsik2xvy5wrzgzv"))))
+    (build-system haskell-build-system)
+    (properties '((upstream-name . "test-framework-leancheck")))
+    (inputs (list ghc-test-framework ghc-leancheck))
+    (home-page "https://github.com/rudymatela/test-framework-leancheck#readme")
+    (synopsis "LeanCheck support for test-framework")
+    (description
+     "LeanCheck support for @code{test-framework}.  This package can be used
+to incorporate LeanCheck tests into test-framework test suites.")
     (license license:bsd-3)))
 
 ;;;
@@ -15563,3 +16279,4 @@ pages.")
 ;;; of a merge conflict, place them above by existing packages with similar
 ;;; functionality or similar names.
 ;;;
+
diff --git a/gnu/packages/idris.scm b/gnu/packages/idris.scm
index 8f08ed3a3e..5e4979edc3 100644
--- a/gnu/packages/idris.scm
+++ b/gnu/packages/idris.scm
@@ -99,7 +99,7 @@
          (add-before 'configure 'update-constraints
            (lambda _
              (substitute* "idris.cabal"
-               (("(aeson|ansi-terminal|haskeline|megaparsec|optparse-applicative)\\s+[^,]+" all dep)
+               (("(aeson|ansi-terminal|bytestring|haskeline|libffi|megaparsec|network|optparse-applicative)\\s+[^,]+" all dep)
                 dep))))
          (add-before 'configure 'set-cc-command
            (lambda _
diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 22284de7a2..c802a401b9 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -1262,71 +1262,74 @@ assembler, PEG) is less than 1MB.")
     (license license:expat)))
 
 (define-public carp
-  (package
-    (name "carp")
-    (version "0.5.5")
-    (source (origin
-              (method git-fetch)
-              (uri (git-reference
-                    (url "https://github.com/carp-lang/Carp")
-                    (commit (string-append "v" version))))
-              (file-name (git-file-name name version))
-              (sha256
-               (base32
-                "14jdnv0ljqvpr9ych1plfw7hp5q57a8j1bv8h3v345x06z783d07"))))
-    (build-system haskell-build-system)
-    (arguments
-     (list #:phases
-           #~(modify-phases %standard-phases
-               ;; Carp looks inside the sources checkout to know where to
-               ;; find its core libraries and other files.
-               ;; Carp emits C code and tries to compile it with an external
-               ;; C compiler. On Linux it defaults to Clang.
-               (add-after 'install 'wrap-programs
-                 (lambda* (#:key inputs #:allow-other-keys)
-                   (define (wrap-carp-program program)
-                     (wrap-program (string-append
-                                    #$output "/bin/" program)
-                       `("CARP_DIR" prefix
-                         (#$(package-source this-package)))
-                       `("PATH" prefix
-                         ,(list (dirname
-                                 (search-input-file inputs "bin/clang"))
-                                (dirname
-                                 (search-input-file inputs "bin/ld"))))
-                       `("C_INCLUDE_PATH" prefix
-                         ,(list (dirname
-                                 (search-input-directory
-                                  inputs "include/linux"))
-                                (dirname
-                                 (search-input-file
-                                  inputs "include/stdlib.h"))))))
-
-                   (for-each wrap-carp-program
-                             (list "carp"
-                                   "carp-header-parse")))))))
-    (inputs
-     (list bash-minimal
-           clang
-           ghc-blaze-markup
-           ghc-blaze-html
-           ghc-split
-           ghc-ansi-terminal
-           ghc-cmark
-           ghc-edit-distance
-           ghc-hashable
-           ghc-open-browser
-           ghc-optparse-applicative))
-    (native-inputs
-     (list ghc-hunit))
-    (home-page "https://carp-lang.org/")
-    (synopsis "Statically typed Lisp without a garbage collector")
-    (description
-     "@code{carp} is a Lisp-like programming language that compiles to
+  ;; Release 0.5.5 does not support GHC 9.2.
+  (let ((commit "339722325ec607091f6035866ebedea2b69080fe")
+        (revision "1"))
+    (package
+      (name "carp")
+      (version (git-version "0.5.5" revision commit))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/carp-lang/Carp")
+                      (commit commit)))
+                (file-name (git-file-name name version))
+                (sha256
+                 (base32
+                  "0w0j3imi4270dsmrh96spsc9xllsk5rrh817l80q1nyay9p53xwd"))))
+      (build-system haskell-build-system)
+      (arguments
+       (list #:phases
+             #~(modify-phases %standard-phases
+                 ;; Carp looks inside the sources checkout to know where to
+                 ;; find its core libraries and other files.
+                 ;; Carp emits C code and tries to compile it with an external
+                 ;; C compiler. On Linux it defaults to Clang.
+                 (add-after 'install 'wrap-programs
+                   (lambda* (#:key inputs #:allow-other-keys)
+                     (define (wrap-carp-program program)
+                       (wrap-program (string-append
+                                      #$output "/bin/" program)
+                         `("CARP_DIR" prefix
+                           (#$(package-source this-package)))
+                         `("PATH" prefix
+                           ,(list (dirname
+                                   (search-input-file inputs "bin/clang"))
+                                  (dirname
+                                   (search-input-file inputs "bin/ld"))))
+                         `("C_INCLUDE_PATH" prefix
+                           ,(list (dirname
+                                   (search-input-directory
+                                    inputs "include/linux"))
+                                  (dirname
+                                   (search-input-file
+                                    inputs "include/stdlib.h"))))))
+  
+                     (for-each wrap-carp-program
+                               (list "carp"
+                                     "carp-header-parse")))))))
+      (inputs
+       (list bash-minimal
+             clang
+             ghc-blaze-markup
+             ghc-blaze-html
+             ghc-split
+             ghc-ansi-terminal
+             ghc-cmark
+             ghc-edit-distance
+             ghc-hashable
+             ghc-open-browser
+             ghc-optparse-applicative))
+      (native-inputs
+       (list ghc-hunit))
+      (home-page "https://carp-lang.org/")
+      (synopsis "Statically typed Lisp without a garbage collector")
+      (description
+       "@code{carp} is a Lisp-like programming language that compiles to
 C.  It features inferred static typing, macros, automatic memory
 management without a garbage collector, a REPL, and straightforward
 integration with code written in C.")
-    (license license:asl2.0)))
+      (license license:asl2.0))))
 (define-public lisp-repl-core-dumper
   (package
     (name "lisp-repl-core-dumper")
diff --git a/gnu/packages/patches/cabal-install-base16-bytestring1.0.patch b/gnu/packages/patches/cabal-install-base16-bytestring1.0.patch
deleted file mode 100644
index 998bf08718..0000000000
--- a/gnu/packages/patches/cabal-install-base16-bytestring1.0.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-Restore compatibility with newer version of base16-bytestring.
-
-Taken from https://raw.githubusercontent.com/archlinux/svntogit-community/packages/trunk/cabal-install-base16-bytestring1.0.patch
-
-diff --git a/Distribution/Client/HashValue.hs b/Distribution/Client/HashValue.hs
-index 54b8aee9e..11e647c1c 100644
---- a/Distribution/Client/HashValue.hs
-+++ b/Distribution/Client/HashValue.hs
-@@ -1,3 +1,4 @@
-+{-# LANGUAGE CPP          #-}
- {-# LANGUAGE DeriveDataTypeable #-}
- {-# LANGUAGE DeriveGeneric      #-}
- module Distribution.Client.HashValue (
-@@ -72,10 +73,14 @@ hashFromTUF (Sec.Hash hashstr) =
-     --TODO: [code cleanup] either we should get TUF to use raw bytestrings or
-     -- perhaps we should also just use a base16 string as the internal rep.
-     case Base16.decode (BS.pack hashstr) of
-+#if MIN_VERSION_base16_bytestring(1,0,0)
-+      Right hash -> HashValue hash
-+      Left _ -> error "hashFromTUF: cannot decode base16"
-+#else
-       (hash, trailing) | not (BS.null hash) && BS.null trailing
-         -> HashValue hash
-       _ -> error "hashFromTUF: cannot decode base16 hash"
--
-+#endif
- 
- -- | Truncate a 32 byte SHA256 hash to
- --
diff --git a/gnu/packages/patches/cabal-install-ghc8.10.patch b/gnu/packages/patches/cabal-install-ghc8.10.patch
deleted file mode 100644
index 67c0953058..0000000000
--- a/gnu/packages/patches/cabal-install-ghc8.10.patch
+++ /dev/null
@@ -1,393 +0,0 @@
-From ac9b41eef3c781ce188ded2551f98fe75152e30c Mon Sep 17 00:00:00 2001
-From: Oleg Grenrus <oleg.grenrus@iki.fi>
-Date: Tue, 14 Apr 2020 11:31:34 +0300
-Subject: [PATCH] GHC-8.10 support for 3.2
-
-Includes cherry-picked commits:
-
-- Test cabal-install with GHC-8.10 #6709
-- Add GHC-8.10.1 job. Only tests Cabal-the-lib part atm. #6617
-
-Also add topHandler' signature.
----
- .docker/validate-8.10.1.dockerfile            |  60 ++++++
- .github/workflows/artifacts.yml               |   6 +-
- .github/workflows/bootstrap.yml               |   4 +-
- .github/workflows/linux.yml                   | 179 ++++++++++++------
- .github/workflows/macos.yml                   |  40 ++--
- .github/workflows/quick-jobs.yml              |   4 +-
- .github/workflows/windows.yml                 | 117 +++++++++++-
- .../Distribution/PackageDescription/Quirks.hs |  19 +-
- Makefile                                      |   4 +
- boot/ci-artifacts.template.yml                |   6 +-
- boot/ci-bootstrap.template.yml                |   4 +-
- boot/ci-linux.template.yml                    |   8 +-
- boot/ci-macos.template.yml                    |   7 +-
- boot/ci-quick-jobs.template.yml               |   4 +-
- boot/ci-windows.template.yml                  |   8 +-
- cabal-dev-scripts/src/GenValidate.hs          |  33 ++--
- Distribution/Client/CmdSdist.hs |   3 +
- .../Distribution/Client/FetchUtils.hs         |   4 +-
- .../Distribution/Client/IndexUtils.hs         |   2 +-
- Distribution/Client/Sandbox.hs  |   5 +-
- .../Distribution/Client/TargetSelector.hs     |   2 +-
- Distribution/Client/Update.hs   |   4 +-
- .../Distribution/Client/Utils/Json.hs         |  13 +-
- .../Distribution/Solver/Modular/Assignment.hs |  11 +-
- .../Distribution/Solver/Modular/Builder.hs    |  10 +-
- .../Distribution/Solver/Modular/Index.hs      |   6 +-
- .../Solver/Modular/IndexConversion.hs         |   8 +-
- .../Distribution/Solver/Modular/Solver.hs     |  12 +-
- .../Distribution/Solver/Modular/Validate.hs   |   5 +-
- bootstrap.sh                    |   6 +-
- cabal-install.cabal             |   4 +-
- cabal-install.cabal.pp          |   4 +-
- .../targets/complex/q/q.cabal                 |   3 +-
- cabal-testsuite/cabal-testsuite.cabal         |   4 +-
- validate.sh                                   |  21 +-
- 35 files changed, 461 insertions(+), 169 deletions(-)
- create mode 100644 .docker/validate-8.10.1.dockerfile
-diff --git a/Distribution/Client/CmdSdist.hs b/Distribution/Client/CmdSdist.hs
-index 9ce0c80100e..a22317004c4 100644
---- a/Distribution/Client/CmdSdist.hs
-+++ b/Distribution/Client/CmdSdist.hs
-@@ -237,7 +237,10 @@ packageToSdist verbosity projectRootDir format outputFile pkg = do
-         (norm NoExec -> nonexec, norm Exec -> exec) <-
-            listPackageSources verbosity (flattenPackageDescription $ packageDescription pkg) knownSuffixHandlers
- 
-+        print $ map snd exec
-+        print $ map snd nonexec
-         let files =  nub . sortOn snd $ nonexec ++ exec
-+        print files
- 
-         case format of
-             SourceList nulSep -> do
-diff --git a/Distribution/Client/FetchUtils.hs b/Distribution/Client/FetchUtils.hs
-index e9a31a91f84..4e5e581f9ec 100644
---- a/Distribution/Client/FetchUtils.hs
-+++ b/Distribution/Client/FetchUtils.hs
-@@ -176,8 +176,8 @@ fetchRepoTarball verbosity' repoCtxt repo pkgid = do
-     verbosity = verboseUnmarkOutput verbosity'
- 
-     downloadRepoPackage = case repo of
--      RepoLocal{..} -> return (packageFile repo pkgid)
--      RepoLocalNoIndex{..} -> return (packageFile repo pkgid)
-+      RepoLocal{} -> return (packageFile repo pkgid)
-+      RepoLocalNoIndex{} -> return (packageFile repo pkgid)
- 
-       RepoRemote{..} -> do
-         transport <- repoContextGetTransport repoCtxt
-diff --git a/Distribution/Client/IndexUtils.hs b/Distribution/Client/IndexUtils.hs
-index a76becc05ba..bf0ff7cf5ba 100644
---- a/Distribution/Client/IndexUtils.hs
-+++ b/Distribution/Client/IndexUtils.hs
-@@ -634,7 +634,7 @@ withIndexEntries
-     -> ([IndexCacheEntry] -> IO a)
-     -> ([NoIndexCacheEntry] -> IO a)
-     -> IO a
--withIndexEntries _ (RepoIndex repoCtxt repo@RepoSecure{..}) callback _ =
-+withIndexEntries _ (RepoIndex repoCtxt repo@RepoSecure{}) callback _ =
-     repoContextWithSecureRepo repoCtxt repo $ \repoSecure ->
-       Sec.withIndex repoSecure $ \Sec.IndexCallbacks{..} -> do
-         -- Incrementally (lazily) read all the entries in the tar file in order,
-diff --git a/Distribution/Client/Sandbox.hs b/Distribution/Client/Sandbox.hs
-index 66b415d7239..14bad3f2135 100644
---- a/Distribution/Client/Sandbox.hs
-+++ b/Distribution/Client/Sandbox.hs
-@@ -666,7 +666,7 @@ reinstallAddSourceDeps :: Verbosity
-                           -> FilePath
-                           -> IO WereDepsReinstalled
- reinstallAddSourceDeps verbosity configFlags' configExFlags
--                       installFlags globalFlags sandboxDir = topHandler' $ do
-+                       installFlags globalFlags sandboxDir = topHandlerWith errorMsg $ do
-   let sandboxDistPref     = sandboxBuildDir sandboxDir
-       configFlags         = configFlags'
-                             { configDistPref  = Flag sandboxDistPref }
-@@ -710,7 +710,8 @@ reinstallAddSourceDeps verbosity configFlags' configExFlags
-         ++ "offending packages or recreating the sandbox."
-       logMsg message rest = debugNoWrap verbosity message >> rest
- 
--      topHandler' = topHandlerWith $ \_ -> do
-+      errorMsg :: a -> IO WereDepsReinstalled
-+      errorMsg _ = do
-         warn verbosity "Couldn't reinstall some add-source dependencies."
-         -- Here we can't know whether any deps have been reinstalled, so we have
-         -- to be conservative.
-diff --git a/Distribution/Client/TargetSelector.hs b/Distribution/Client/TargetSelector.hs
-index 23d92f580fd..f8f683d9875 100644
---- a/Distribution/Client/TargetSelector.hs
-+++ b/Distribution/Client/TargetSelector.hs
-@@ -222,7 +222,7 @@ readTargetSelectorsWith :: (Applicative m, Monad m) => DirActions m
-                         -> Maybe ComponentKindFilter
-                         -> [String]
-                         -> m (Either [TargetSelectorProblem] [TargetSelector])
--readTargetSelectorsWith dirActions@DirActions{..} pkgs mfilter targetStrs =
-+readTargetSelectorsWith dirActions@DirActions{} pkgs mfilter targetStrs =
-     case parseTargetStrings targetStrs of
-       ([], usertargets) -> do
-         usertargets' <- mapM (getTargetStringFileStatus dirActions) usertargets
-diff --git a/Distribution/Client/Update.hs b/Distribution/Client/Update.hs
-index 52bb1f76c96..8ded78b9d2e 100644
---- a/Distribution/Client/Update.hs
-+++ b/Distribution/Client/Update.hs
-@@ -73,8 +73,8 @@ updateRepo :: Verbosity -> UpdateFlags -> RepoContext -> Repo -> IO ()
- updateRepo verbosity updateFlags repoCtxt repo = do
-   transport <- repoContextGetTransport repoCtxt
-   case repo of
--    RepoLocal{..} -> return ()
--    RepoLocalNoIndex{..} -> return ()
-+    RepoLocal{} -> return ()
-+    RepoLocalNoIndex{} -> return ()
-     RepoRemote{..} -> do
-       downloadResult <- downloadIndex transport verbosity repoRemote repoLocalDir
-       case downloadResult of
-diff --git a/Distribution/Client/Utils/Json.hs b/Distribution/Client/Utils/Json.hs
-index 89a13af87a4..01d5753136b 100644
---- a/Distribution/Client/Utils/Json.hs
-+++ b/Distribution/Client/Utils/Json.hs
-@@ -15,12 +15,9 @@ module Distribution.Client.Utils.Json
-     )
-     where
- 
--import Data.Char
--import Data.Int
--import Data.String
--import Data.Word
--import Data.List
--import Data.Monoid
-+import Distribution.Client.Compat.Prelude
-+
-+import Data.Char (intToDigit)
- 
- import Data.ByteString.Builder (Builder)
- import qualified Data.ByteString.Builder as BB
-@@ -135,13 +132,13 @@ encodeArrayBB :: [Value] -> Builder
- encodeArrayBB [] = "[]"
- encodeArrayBB jvs = BB.char8 '[' <> go jvs <> BB.char8 ']'
-   where
--    go = Data.Monoid.mconcat . intersperse (BB.char8 ',') . map encodeValueBB
-+    go = mconcat . intersperse (BB.char8 ',') . map encodeValueBB
- 
- encodeObjectBB :: Object -> Builder
- encodeObjectBB [] = "{}"
- encodeObjectBB jvs = BB.char8 '{' <> go jvs <> BB.char8 '}'
-   where
--    go = Data.Monoid.mconcat . intersperse (BB.char8 ',') . map encPair
-+    go = mconcat . intersperse (BB.char8 ',') . map encPair
-     encPair (l,x) = encodeStringBB l <> BB.char8 ':' <> encodeValueBB x
- 
- encodeStringBB :: String -> Builder
-diff --git a/Distribution/Solver/Modular/Assignment.hs b/Distribution/Solver/Modular/Assignment.hs
-index be5e63bfbc1..b05a099ec5a 100644
---- a/Distribution/Solver/Modular/Assignment.hs
-+++ b/Distribution/Solver/Modular/Assignment.hs
-@@ -9,10 +9,11 @@ module Distribution.Solver.Modular.Assignment
- import Prelude ()
- import Distribution.Solver.Compat.Prelude hiding (pi)
- 
--import Data.Array as A
--import Data.List as L
--import Data.Map as M
--import Data.Maybe
-+import qualified Data.Array as A
-+import qualified Data.List as L
-+import qualified Data.Map as M
-+
-+import Data.Maybe (fromJust)
- 
- import Distribution.PackageDescription (FlagAssignment, mkFlagAssignment) -- from Cabal
- 
-@@ -79,7 +80,7 @@ toCPs (A pa fa sa) rdm =
-     -- Dependencies per package.
-     depp :: QPN -> [(Component, PI QPN)]
-     depp qpn = let v :: Vertex
--                   v   = fromJust (cvm qpn)
-+                   v   = fromJust (cvm qpn) -- TODO: why this is safe?
-                    dvs :: [(Component, Vertex)]
-                    dvs = tg A.! v
-                in L.map (\ (comp, dv) -> case vm dv of (_, x, _) -> (comp, PI x (pa M.! x))) dvs
-diff --git a/Distribution/Solver/Modular/Builder.hs b/Distribution/Solver/Modular/Builder.hs
-index eb11a36aa16..5d196f4fd9f 100644
---- a/Distribution/Solver/Modular/Builder.hs
-+++ b/Distribution/Solver/Modular/Builder.hs
-@@ -19,10 +19,10 @@ module Distribution.Solver.Modular.Builder (
- -- flag-guarded dependencies, we cannot introduce them immediately. Instead, we
- -- store the entire dependency.
- 
--import Data.List as L
--import Data.Map as M
--import Data.Set as S
--import Prelude hiding (sequence, mapM)
-+import qualified Data.List as L
-+import qualified Data.Map as M
-+import qualified Data.Set as S
-+import Prelude
- 
- import qualified Distribution.Solver.Modular.ConflictSet as CS
- import Distribution.Solver.Modular.Dependency
-@@ -55,7 +55,7 @@ data BuildState = BS {
- }
- 
- -- | Map of available linking targets.
--type LinkingState = Map (PN, I) [PackagePath]
-+type LinkingState = M.Map (PN, I) [PackagePath]
- 
- -- | Extend the set of open goals with the new goals listed.
- --
-diff --git a/Distribution/Solver/Modular/Index.hs b/Distribution/Solver/Modular/Index.hs
-index fdddfc8237a..ac60fec7d65 100644
---- a/Distribution/Solver/Modular/Index.hs
-+++ b/Distribution/Solver/Modular/Index.hs
-@@ -6,10 +6,12 @@ module Distribution.Solver.Modular.Index
-     , mkIndex
-     ) where
- 
--import Data.List as L
--import Data.Map as M
- import Prelude hiding (pi)
- 
-+import Data.Map (Map)
-+import qualified Data.List as L
-+import qualified Data.Map as M
-+
- import Distribution.Solver.Modular.Dependency
- import Distribution.Solver.Modular.Flag
- import Distribution.Solver.Modular.Package
-diff --git a/Distribution/Solver/Modular/IndexConversion.hs b/Distribution/Solver/Modular/IndexConversion.hs
-index c9565c80dba..8e9ef614184 100644
---- a/Distribution/Solver/Modular/IndexConversion.hs
-+++ b/Distribution/Solver/Modular/IndexConversion.hs
-@@ -2,12 +2,12 @@ module Distribution.Solver.Modular.IndexConversion
-     ( convPIs
-     ) where
- 
--import Data.List as L
-+import qualified Data.List as L
- import Data.Map.Strict (Map)
- import qualified Data.Map.Strict as M
--import Data.Maybe
-+import Data.Maybe (mapMaybe, fromMaybe, maybeToList)
- import Data.Monoid as Mon
--import Data.Set as S
-+import qualified Data.Set as S
- 
- import Distribution.Compiler
- import Distribution.InstalledPackageInfo as IPI
-@@ -330,7 +330,7 @@ flagInfo (StrongFlags strfl) =
- 
- -- | Internal package names, which should not be interpreted as true
- -- dependencies.
--type IPNs = Set PN
-+type IPNs = S.Set PN
- 
- -- | Convenience function to delete a 'Dependency' if it's
- -- for a 'PN' that isn't actually real.
-diff --git a/Distribution/Solver/Modular/Solver.hs b/Distribution/Solver/Modular/Solver.hs
-index 32452550556..e6aa1fb4374 100644
---- a/Distribution/Solver/Modular/Solver.hs
-+++ b/Distribution/Solver/Modular/Solver.hs
-@@ -9,9 +9,9 @@ module Distribution.Solver.Modular.Solver
-     , PruneAfterFirstSuccess(..)
-     ) where
- 
--import Data.Map as M
--import Data.List as L
--import Data.Set as S
-+import qualified Data.Map as M
-+import qualified Data.List as L
-+import qualified Data.Set as S
- import Distribution.Verbosity
- 
- import Distribution.Compiler (CompilerInfo)
-@@ -91,8 +91,8 @@ solve :: SolverConfig                         -- ^ solver parameters
-       -> Index                                -- ^ all available packages as an index
-       -> PkgConfigDb                          -- ^ available pkg-config pkgs
-       -> (PN -> PackagePreferences)           -- ^ preferences
--      -> Map PN [LabeledPackageConstraint]    -- ^ global constraints
--      -> Set PN                               -- ^ global goals
-+      -> M.Map PN [LabeledPackageConstraint]  -- ^ global constraints
-+      -> S.Set PN                             -- ^ global goals
-       -> RetryLog Message SolverFailure (Assignment, RevDepMap)
- solve sc cinfo idx pkgConfigDB userPrefs userConstraints userGoals =
-   explorePhase     $
-@@ -232,7 +232,7 @@ instance GSimpleTree (Tree d c) where
- 
-       -- Show conflict set
-       goCS :: ConflictSet -> String
--      goCS cs = "{" ++ (intercalate "," . L.map showVar . CS.toList $ cs) ++ "}"
-+      goCS cs = "{" ++ (L.intercalate "," . L.map showVar . CS.toList $ cs) ++ "}"
- #endif
- 
- -- | Replace all goal reasons with a dummy goal reason in the tree
-diff --git a/Distribution/Solver/Modular/Validate.hs b/Distribution/Solver/Modular/Validate.hs
-index 6195d101b02..a3dec6e1f67 100644
---- a/Distribution/Solver/Modular/Validate.hs
-+++ b/Distribution/Solver/Modular/Validate.hs
-@@ -15,11 +15,12 @@ module Distribution.Solver.Modular.Validate (validateTree) where
- import Control.Applicative
- import Control.Monad.Reader hiding (sequence)
- import Data.Function (on)
--import Data.List as L
--import Data.Set as S
- import Data.Traversable
- import Prelude hiding (sequence)
- 
-+import qualified Data.List as L
-+import qualified Data.Set as S
-+
- import Language.Haskell.Extension (Extension, Language)
- 
- import Data.Map.Strict as M
-diff --git a/bootstrap.sh b/bootstrap.sh
-index 077d7f4efd2..d5141660474 100755
---- a/bootstrap.sh
-+++ b/bootstrap.sh
-@@ -260,9 +260,9 @@ EDIT_DISTANCE_VER="0.2.2.1"; EDIT_DISTANCE_VER_REGEXP="0\.2\.2\.?"
-                        # 0.2.2.*
- ED25519_VER="0.0.5.0"; ED25519_VER_REGEXP="0\.0\.?"
-                        # 0.0.*
--HACKAGE_SECURITY_VER="0.6.0.0"; HACKAGE_SECURITY_VER_REGEXP="0\.6\."
--                       # >= 0.7.0.0 && < 0.7
--TAR_VER="0.5.1.0";     TAR_VER_REGEXP="0\.5\.([1-9]|1[0-9]|0\.[3-9]|0\.1[0-9])\.?"
-+HACKAGE_SECURITY_VER="0.6.0.1"; HACKAGE_SECURITY_VER_REGEXP="0\.6\."
-+                       # >= 0.6.0.0 && < 0.7
-+TAR_VER="0.5.1.1";     TAR_VER_REGEXP="0\.5\.([1-9]|1[0-9]|0\.[3-9]|0\.1[0-9])\.?"
-                        # >= 0.5.0.3  && < 0.6
- DIGEST_VER="0.0.1.2"; DIGEST_REGEXP="0\.0\.(1\.[2-9]|[2-9]\.?)"
-                        # >= 0.0.1.2 && < 0.1
-diff --git a/cabal-install.cabal b/cabal-install.cabal
-index 985ea9a5a69..c9d713c29fe 100644
---- a/cabal-install.cabal
-+++ b/cabal-install.cabal
-@@ -316,7 +316,7 @@ executable cabal
-     build-depends:
-         async      >= 2.0      && < 2.3,
-         array      >= 0.4      && < 0.6,
--        base       >= 4.8      && < 4.14,
-+        base       >= 4.8      && < 4.15,
-         base16-bytestring >= 0.1.1 && < 0.2,
-         binary     >= 0.7.3    && < 0.9,
-         bytestring >= 0.10.6.0 && < 0.11,
-@@ -341,7 +341,7 @@ executable cabal
-         time       >= 1.5.0.1  && < 1.10,
-         transformers >= 0.4.2.0 && < 0.6,
-         zlib       >= 0.5.3    && < 0.7,
--        hackage-security >= 0.6.0.0 && < 0.7,
-+        hackage-security >= 0.6.0.1 && < 0.7,
-         text       >= 1.2.3    && < 1.3,
-         parsec     >= 3.1.13.0 && < 3.2
- 
-diff --git a/tests/IntegrationTests2/targets/complex/q/q.cabal b/tests/IntegrationTests2/targets/complex/q/q.cabal
-index 556fa4a4202..7ee22fcb28d 100644
---- a/tests/IntegrationTests2/targets/complex/q/q.cabal
-+++ b/tests/IntegrationTests2/targets/complex/q/q.cabal
-@@ -5,7 +5,8 @@ cabal-version: >= 1.2
- 
- library
-   exposed-modules: Q
--  build-depends: base, filepath
-+  -- we rely that filepath has filepath-tests component
-+  build-depends: base, filepath >=1.4.0.0
- 
- executable buildable-false
-   main-is: Main.hs
diff --git a/gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch b/gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch
new file mode 100644
index 0000000000..97caf2cc9b
--- /dev/null
+++ b/gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch
@@ -0,0 +1,303 @@
+Taken from https://github.com/bos/bloomfilter/pull/20
+
+From fb79b39c44404fd791a3bed973e9d844fb084f1e Mon Sep 17 00:00:00 2001
+From: Simon Jakobi <simon.jakobi@gmail.com>
+Date: Fri, 12 Nov 2021 01:37:36 +0100
+Subject: [PATCH] Fix build with GHC 9.2
+
+The `FastShift.shift{L,R}` methods are replaced with `unsafeShift{L,R}`
+introduced in base-4.5.
+
+Fixes #19.
+---
+ Data/BloomFilter.hs         | 16 +++++------
+ Data/BloomFilter/Hash.hs    | 15 +++++-----
+ Data/BloomFilter/Mutable.hs | 20 +++++++-------
+ Data/BloomFilter/Util.hs    | 55 ++++++-------------------------------
+ bloomfilter.cabal           |  2 +-
+ 5 files changed, 34 insertions(+), 74 deletions(-)
+
+diff --git a/Data/BloomFilter.hs b/Data/BloomFilter.hs
+index 2210cef..6b47c21 100644
+--- a/Data/BloomFilter.hs
++++ b/Data/BloomFilter.hs
+@@ -78,8 +78,8 @@ import Control.DeepSeq (NFData(..))
+ import Data.Array.Base (unsafeAt)
+ import qualified Data.Array.Base as ST
+ import Data.Array.Unboxed (UArray)
+-import Data.Bits ((.&.))
+-import Data.BloomFilter.Util (FastShift(..), (:*)(..))
++import Data.Bits ((.&.), unsafeShiftL, unsafeShiftR)
++import Data.BloomFilter.Util ((:*)(..))
+ import qualified Data.BloomFilter.Mutable as MB
+ import qualified Data.BloomFilter.Mutable.Internal as MB
+ import Data.BloomFilter.Mutable.Internal (Hash, MBloom)
+@@ -98,7 +98,7 @@ data Bloom a = B {
+     }
+ 
+ instance Show (Bloom a) where
+-    show ub = "Bloom { " ++ show ((1::Int) `shiftL` shift ub) ++ " bits } "
++    show ub = "Bloom { " ++ show ((1::Int) `unsafeShiftL` shift ub) ++ " bits } "
+ 
+ instance NFData (Bloom a) where
+     rnf !_ = ()
+@@ -172,7 +172,7 @@ singleton hash numBits elt = create hash numBits (\mb -> MB.insert mb elt)
+ -- | Given a filter's mask and a hash value, compute an offset into
+ -- a word array and a bit offset within that word.
+ hashIdx :: Int -> Word32 -> (Int :* Int)
+-hashIdx mask x = (y `shiftR` logBitsInHash) :* (y .&. hashMask)
++hashIdx mask x = (y `unsafeShiftR` logBitsInHash) :* (y .&. hashMask)
+   where hashMask = 31 -- bitsInHash - 1
+         y = fromIntegral x .&. mask
+ 
+@@ -191,7 +191,7 @@ hashesU ub elt = hashIdx (mask ub) `map` hashes ub elt
+ -- /still/ some possibility that @True@ will be returned.
+ elem :: a -> Bloom a -> Bool
+ elem elt ub = all test (hashesU ub elt)
+-  where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `shiftL` bit) /= 0
++  where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `unsafeShiftL` bit) /= 0
+           
+ modify :: (forall s. (MBloom s a -> ST s z))  -- ^ mutation function (result is discarded)
+         -> Bloom a
+@@ -255,11 +255,11 @@ insertList elts = modify $ \mb -> mapM_ (MB.insert mb) elts
+ -- is /still/ some possibility that @True@ will be returned.
+ notElem :: a -> Bloom a -> Bool
+ notElem elt ub = any test (hashesU ub elt)
+-  where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `shiftL` bit) == 0
++  where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `unsafeShiftL` bit) == 0
+ 
+ -- | Return the size of an immutable Bloom filter, in bits.
+ length :: Bloom a -> Int
+-length = shiftL 1 . shift
++length = unsafeShiftL 1 . shift
+ 
+ -- | Build an immutable Bloom filter from a seed value.  The seeding
+ -- function populates the filter as follows.
+@@ -318,7 +318,7 @@ fromList hashes numBits = unfold hashes numBits convert
+ logPower2 :: Int -> Int
+ logPower2 k = go 0 k
+     where go j 1 = j
+-          go j n = go (j+1) (n `shiftR` 1)
++          go j n = go (j+1) (n `unsafeShiftR` 1)
+ 
+ -- $overview
+ --
+diff --git a/Data/BloomFilter/Hash.hs b/Data/BloomFilter/Hash.hs
+index 132a3a4..d071fd4 100644
+--- a/Data/BloomFilter/Hash.hs
++++ b/Data/BloomFilter/Hash.hs
+@@ -38,8 +38,7 @@ module Data.BloomFilter.Hash
+     ) where
+ 
+ import Control.Monad (foldM)
+-import Data.Bits ((.&.), (.|.), xor)
+-import Data.BloomFilter.Util (FastShift(..))
++import Data.Bits ((.&.), (.|.), unsafeShiftL, unsafeShiftR, xor)
+ import Data.List (unfoldr)
+ import Data.Int (Int8, Int16, Int32, Int64)
+ import Data.Word (Word8, Word16, Word32, Word64)
+@@ -91,11 +90,11 @@ class Hashable a where
+              -> Word64           -- ^ salt
+              -> IO Word64
+     hashIO64 v salt = do
+-                   let s1 = fromIntegral (salt `shiftR` 32) .&. maxBound
++                   let s1 = fromIntegral (salt `unsafeShiftR` 32) .&. maxBound
+                        s2 = fromIntegral salt
+                    h1 <- hashIO32 v s1
+                    h2 <- hashIO32 v s2
+-                   return $ (fromIntegral h1 `shiftL` 32) .|. fromIntegral h2
++                   return $ (fromIntegral h1 `unsafeShiftL` 32) .|. fromIntegral h2
+ 
+ -- | Compute a 32-bit hash.
+ hash32 :: Hashable a => a -> Word32
+@@ -149,8 +148,8 @@ cheapHashes :: Hashable a => Int -- ^ number of hashes to compute
+ cheapHashes k v = go 0
+     where go i | i == j = []
+                | otherwise = hash : go (i + 1)
+-               where !hash = h1 + (h2 `shiftR` i)
+-          h1 = fromIntegral (h `shiftR` 32)
++               where !hash = h1 + (h2 `unsafeShiftR` i)
++          h1 = fromIntegral (h `unsafeShiftR` 32)
+           h2 = fromIntegral h
+           h = hashSalt64 0x9150a946c4a8966e v
+           j = fromIntegral k
+@@ -163,7 +162,7 @@ instance Hashable Integer where
+                                    (salt `xor` 0x3ece731e)
+                   | otherwise = hashIO32 (unfoldr go k) salt
+         where go 0 = Nothing
+-              go i = Just (fromIntegral i :: Word32, i `shiftR` 32)
++              go i = Just (fromIntegral i :: Word32, i `unsafeShiftR` 32)
+ 
+ instance Hashable Bool where
+     hashIO32 = hashOne32
+@@ -224,7 +223,7 @@ instance Hashable Word64 where
+ -- | A fast unchecked shift.  Nasty, but otherwise GHC 6.8.2 does a
+ -- test and branch on every shift.
+ div4 :: CSize -> CSize
+-div4 k = fromIntegral ((fromIntegral k :: HTYPE_SIZE_T) `shiftR` 2)
++div4 k = fromIntegral ((fromIntegral k :: HTYPE_SIZE_T) `unsafeShiftR` 2)
+ 
+ alignedHash :: Ptr a -> CSize -> Word32 -> IO Word32
+ alignedHash ptr bytes salt
+diff --git a/Data/BloomFilter/Mutable.hs b/Data/BloomFilter/Mutable.hs
+index edff1fc..0bb5cc9 100644
+--- a/Data/BloomFilter/Mutable.hs
++++ b/Data/BloomFilter/Mutable.hs
+@@ -65,9 +65,9 @@ module Data.BloomFilter.Mutable
+ import Control.Monad (liftM, forM_)
+ import Control.Monad.ST (ST)
+ import Data.Array.Base (unsafeRead, unsafeWrite)
+-import Data.Bits ((.&.), (.|.))
++import Data.Bits ((.&.), (.|.), unsafeShiftL, unsafeShiftR)
+ import Data.BloomFilter.Array (newArray)
+-import Data.BloomFilter.Util (FastShift(..), (:*)(..), nextPowerOfTwo)
++import Data.BloomFilter.Util ((:*)(..), nextPowerOfTwo)
+ import Data.Word (Word32)
+ import Data.BloomFilter.Mutable.Internal
+ 
+@@ -86,9 +86,9 @@ new hash numBits = MB hash shft msk `liftM` newArray numElems numBytes
+                 | numBits > maxHash = maxHash
+                 | isPowerOfTwo numBits = numBits
+                 | otherwise = nextPowerOfTwo numBits
+-        numElems = max 2 (twoBits `shiftR` logBitsInHash)
+-        numBytes = numElems `shiftL` logBytesInHash
+-        trueBits = numElems `shiftL` logBitsInHash
++        numElems = max 2 (twoBits `unsafeShiftR` logBitsInHash)
++        numBytes = numElems `unsafeShiftL` logBytesInHash
++        trueBits = numElems `unsafeShiftL` logBitsInHash
+         shft     = logPower2 trueBits
+         msk      = trueBits - 1
+         isPowerOfTwo n = n .&. (n - 1) == 0
+@@ -109,7 +109,7 @@ logBytesInHash = 2 -- logPower2 (sizeOf (undefined :: Hash))
+ -- | Given a filter's mask and a hash value, compute an offset into
+ -- a word array and a bit offset within that word.
+ hashIdx :: Int -> Word32 -> (Int :* Int)
+-hashIdx msk x = (y `shiftR` logBitsInHash) :* (y .&. hashMask)
++hashIdx msk x = (y `unsafeShiftR` logBitsInHash) :* (y .&. hashMask)
+   where hashMask = 31 -- bitsInHash - 1
+         y = fromIntegral x .&. msk
+ 
+@@ -125,7 +125,7 @@ insert mb elt = do
+   let mu = bitArray mb
+   forM_ (hashesM mb elt) $ \(word :* bit) -> do
+       old <- unsafeRead mu word
+-      unsafeWrite mu word (old .|. (1 `shiftL` bit))
++      unsafeWrite mu word (old .|. (1 `unsafeShiftL` bit))
+ 
+ -- | Query a mutable Bloom filter for membership.  If the value is
+ -- present, return @True@.  If the value is not present, there is
+@@ -135,7 +135,7 @@ elem elt mb = loop (hashesM mb elt)
+   where mu = bitArray mb
+         loop ((word :* bit):wbs) = do
+           i <- unsafeRead mu word
+-          if i .&. (1 `shiftL` bit) == 0
++          if i .&. (1 `unsafeShiftL` bit) == 0
+             then return False
+             else loop wbs
+         loop _ = return True
+@@ -145,7 +145,7 @@ elem elt mb = loop (hashesM mb elt)
+ 
+ -- | Return the size of a mutable Bloom filter, in bits.
+ length :: MBloom s a -> Int
+-length = shiftL 1 . shift
++length = unsafeShiftL 1 . shift
+ 
+ 
+ -- | Slow, crummy way of computing the integer log of an integer known
+@@ -153,7 +153,7 @@ length = shiftL 1 . shift
+ logPower2 :: Int -> Int
+ logPower2 k = go 0 k
+     where go j 1 = j
+-          go j n = go (j+1) (n `shiftR` 1)
++          go j n = go (j+1) (n `unsafeShiftR` 1)
+ 
+ -- $overview
+ --
+diff --git a/Data/BloomFilter/Util.hs b/Data/BloomFilter/Util.hs
+index 7f695dc..6ade6e5 100644
+--- a/Data/BloomFilter/Util.hs
++++ b/Data/BloomFilter/Util.hs
+@@ -2,15 +2,11 @@
+ 
+ module Data.BloomFilter.Util
+     (
+-      FastShift(..)
+-    , nextPowerOfTwo
++      nextPowerOfTwo
+     , (:*)(..)
+     ) where
+ 
+-import Data.Bits ((.|.))
+-import qualified Data.Bits as Bits
+-import GHC.Base
+-import GHC.Word
++import Data.Bits ((.|.), unsafeShiftR)
+ 
+ -- | A strict pair type.
+ data a :* b = !a :* !b
+@@ -22,46 +18,11 @@ nextPowerOfTwo :: Int -> Int
+ {-# INLINE nextPowerOfTwo #-}
+ nextPowerOfTwo n =
+     let a = n - 1
+-        b = a .|. (a `shiftR` 1)
+-        c = b .|. (b `shiftR` 2)
+-        d = c .|. (c `shiftR` 4)
+-        e = d .|. (d `shiftR` 8)
+-        f = e .|. (e `shiftR` 16)
+-        g = f .|. (f `shiftR` 32)  -- in case we're on a 64-bit host
++        b = a .|. (a `unsafeShiftR` 1)
++        c = b .|. (b `unsafeShiftR` 2)
++        d = c .|. (c `unsafeShiftR` 4)
++        e = d .|. (d `unsafeShiftR` 8)
++        f = e .|. (e `unsafeShiftR` 16)
++        g = f .|. (f `unsafeShiftR` 32)  -- in case we're on a 64-bit host
+         !h = g + 1
+     in h
+-
+--- | This is a workaround for poor optimisation in GHC 6.8.2.  It
+--- fails to notice constant-width shifts, and adds a test and branch
+--- to every shift.  This imposes about a 10% performance hit.
+-class FastShift a where
+-    shiftL :: a -> Int -> a
+-    shiftR :: a -> Int -> a
+-
+-instance FastShift Word32 where
+-    {-# INLINE shiftL #-}
+-    shiftL (W32# x#) (I# i#) = W32# (x# `uncheckedShiftL#` i#)
+-
+-    {-# INLINE shiftR #-}
+-    shiftR (W32# x#) (I# i#) = W32# (x# `uncheckedShiftRL#` i#)
+-
+-instance FastShift Word64 where
+-    {-# INLINE shiftL #-}
+-    shiftL (W64# x#) (I# i#) = W64# (x# `uncheckedShiftL64#` i#)
+-
+-    {-# INLINE shiftR #-}
+-    shiftR (W64# x#) (I# i#) = W64# (x# `uncheckedShiftRL64#` i#)
+-
+-instance FastShift Int where
+-    {-# INLINE shiftL #-}
+-    shiftL (I# x#) (I# i#) = I# (x# `iShiftL#` i#)
+-
+-    {-# INLINE shiftR #-}
+-    shiftR (I# x#) (I# i#) = I# (x# `iShiftRA#` i#)
+-
+-instance FastShift Integer where
+-    {-# INLINE shiftL #-}
+-    shiftL = Bits.shiftL
+-
+-    {-# INLINE shiftR #-}
+-    shiftR = Bits.shiftR
+diff --git a/bloomfilter.cabal b/bloomfilter.cabal
+index 821a5d7..c621f7f 100644
+--- a/bloomfilter.cabal
++++ b/bloomfilter.cabal
+@@ -18,7 +18,7 @@ extra-source-files: README.markdown cbits/lookup3.c cbits/lookup3.h
+ library
+   build-depends:
+     array,
+-    base       >= 4.4 && < 5,
++    base       >= 4.5 && < 5,
+     bytestring >= 0.9,
+     deepseq
+   exposed-modules:  Data.BloomFilter
diff --git a/gnu/packages/patches/ghc-bytestring-handle-ghc9.patch b/gnu/packages/patches/ghc-bytestring-handle-ghc9.patch
new file mode 100644
index 0000000000..43dd472bf6
--- /dev/null
+++ b/gnu/packages/patches/ghc-bytestring-handle-ghc9.patch
@@ -0,0 +1,67 @@
+Taken from https://raw.githubusercontent.com/archlinux/svntogit-community/packages/haskell-bytestring-handle/trunk/ghc9.patch
+
+--- bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Write.hs.orig	2021-06-21 14:54:12.217134401 +0800
++++ bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Write.hs	2021-06-21 15:24:01.794796505 +0800
+@@ -17,7 +17,7 @@
+ 
+ import GHC.IO.Buffer ( BufferState(..), emptyBuffer, Buffer(..) )
+ import GHC.IO.BufferedIO ( BufferedIO(..) )
+-import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..) )
++import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..), RawIO(..) )
+ #if MIN_VERSION_base(4,5,0)
+ import GHC.IO.Encoding ( getLocaleEncoding )
+ #else
+@@ -138,6 +138,7 @@
+                                 seek_base = error "seek_base needs to be updated"
+                    })
+         modifyIORef (write_size ws) (`max` newSeekPos)
++        pure newSeekPos
+ 
+     tell ws = do
+         ss <- readIORef (write_seek_state ws)
+@@ -152,6 +153,12 @@
+ 
+     devType _ = return RegularFile -- TODO: is this correct?
+ 
++instance RawIO WriteState where
++    read _ _ _ _ = return 0
++    readNonBlocking _ _ _ _ = return Nothing
++    write _ _ _ _ = return ()
++    writeNonBlocking _ _ _ _ = return 0
++
+ ioe_seekOutOfRange :: IO a
+ ioe_seekOutOfRange =
+     ioException $ IOError Nothing InvalidArgument ""
+--- bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Read.hs.orig	2021-06-21 14:53:55.433129276 +0800
++++ bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Read.hs	2021-06-21 15:24:25.998784996 +0800
+@@ -24,7 +24,7 @@
+     , emptyBuffer, isEmptyBuffer, newBuffer, newByteBuffer
+     , bufferElems, withBuffer, withRawBuffer )
+ import GHC.IO.BufferedIO ( BufferedIO(..) )
+-import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..) )
++import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..), RawIO(..) )
+ #if MIN_VERSION_base(4,5,0)
+ import GHC.IO.Encoding ( getLocaleEncoding )
+ #else
+@@ -155,7 +155,7 @@
+                                                       (seek_before_length curSeekState)
+                                                       (fromIntegral (seek_pos curSeekState) + seekPos)
+                   SeekFromEnd -> normalisedSeekState (read_chunks_backwards rs) [] (read_length rs) seekPos
+-        maybe ioe_seekOutOfRange (writeIORef (read_seek_state rs)) newSeekState
++        maybe ioe_seekOutOfRange (\nss -> writeIORef (read_seek_state rs) nss >> pure (fromIntegral(seek_pos nss))) newSeekState
+ 
+     tell rs = do
+         ss <- readIORef (read_seek_state rs)
+@@ -166,6 +166,12 @@
+ 
+     devType _ = return RegularFile -- TODO: is this correct?
+ 
++instance RawIO ReadState where
++    read _ _ _ _ = return 0
++    readNonBlocking _ _ _ _ = return Nothing
++    write _ _ _ _ = return ()
++    writeNonBlocking _ _ _ _ = return 0
++
+ ioe_seekOutOfRange :: IO a
+ ioe_seekOutOfRange =
+     ioException $ IOError Nothing InvalidArgument ""
diff --git a/gnu/packages/patches/ngless-unliftio.patch b/gnu/packages/patches/ngless-unliftio.patch
deleted file mode 100644
index 87f5e79fcf..0000000000
--- a/gnu/packages/patches/ngless-unliftio.patch
+++ /dev/null
@@ -1,66 +0,0 @@
-From 919565adc1216b9d3108b3043e8d307292b37393 Mon Sep 17 00:00:00 2001
-From: Luis Pedro Coelho <luis@luispedro.org>
-Date: Fri, 7 May 2021 11:42:56 +0800
-Subject: [PATCH] BLD Update to LTS-17.10
-
-- Updates the GHC version
-- Requires `extra-deps` for `diagrams` package
-- Simplifies code for NGLessIO monad as UnliftIO can now be auto-derived
----
- NGLess/NGLess/NGError.hs |  8 ++------
- stack.yaml               | 11 ++++++++---
- 2 files changed, 10 insertions(+), 9 deletions(-)
-
-diff --git a/NGLess/NGLess/NGError.hs b/NGLess/NGLess/NGError.hs
-index a22e557f..c7eddf5b 100644
---- a/NGLess/NGLess/NGError.hs
-+++ b/NGLess/NGLess/NGError.hs
-@@ -50,7 +50,8 @@ type NGLess = Either NGError
- 
- newtype NGLessIO a = NGLessIO { unwrapNGLessIO :: ResourceT IO a }
-                         deriving (Functor, Applicative, Monad, MonadIO,
--                        MonadResource, MonadThrow, MonadCatch, MonadMask)
-+                        MonadResource, MonadThrow, MonadCatch, MonadMask,
-+                        MonadUnliftIO)
- 
- 
- instance MonadError NGError NGLessIO where
-@@ -62,11 +63,6 @@ instance PrimMonad NGLessIO where
-     primitive act = NGLessIO (primitive act)
-     {-# INLINE primitive #-}
- 
--instance MonadUnliftIO NGLessIO where
--    askUnliftIO = NGLessIO $ do
--        u <- askUnliftIO
--        return $ UnliftIO (\(NGLessIO act) -> unliftIO u act)
--
- instance MonadFail NGLessIO where
-     fail err = throwShouldNotOccur err
- 
-diff --git a/stack.yaml b/stack.yaml
-index 051d973d..11b65887 100644
---- a/stack.yaml
-+++ b/stack.yaml
-@@ -1,14 +1,19 @@
- # For more information, see: https://github.com/commercialhaskell/stack/blob/release/doc/yaml_configuration.md
- 
--resolver: lts-14.20
-+resolver: lts-17.10
- compiler-check: newer-minor
- 
- # Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
- extra-deps:
-   - git: "https://github.com/ngless-toolkit/interval-to-int"
-     commit: "78289f6b48d41f7cc48169520ec9b77b050a0029"
--
--
-+  - diagrams-core-1.4.2@sha256:47de45658e8a805b7cb7f535e7b093daf7e861604fa3c70e25bd4ef481bf1571,2997
-+  - diagrams-lib-1.4.3@sha256:04f77778d4b550d3c8e54440800685f88467bef91075e82e009a8a6f45c51033,8232
-+  - diagrams-svg-1.4.3@sha256:36708b0b4cf35507ccf689f1a25f6f81b8f41c2c4c2900793de820f66d4e241c,3181
-+  - active-0.2.0.14@sha256:e618aba4a7881eb85dc1585e0a01230af6b4fbab6693931e4a5d0d3a5b184406,1823
-+  - dual-tree-0.2.2.1@sha256:9ff31e461d873ae74ba51d93b454c0c4094726d7cb78a0c454394c965e83539d,2830
-+  - monoid-extras-0.5.1@sha256:438dbfd7b4dce47d8f0ca577f56caf94bd1e21391afa545cad09fe7cf2e5793d,2333
-+  - svg-builder-0.1.1@sha256:22de54d326a6b6912e461e1302edb9108b02aac0b6a6368fcdc3c4a224d487fd,1440
- allow-newer: true
- 
- # Override default flag values for local packages and extra-deps
diff --git a/gnu/packages/patches/xmonad-dynamic-linking.patch b/gnu/packages/patches/xmonad-dynamic-linking.patch
index 4f3386e53a..a1d71825b6 100644
--- a/gnu/packages/patches/xmonad-dynamic-linking.patch
+++ b/gnu/packages/patches/xmonad-dynamic-linking.patch
@@ -2,15 +2,15 @@ This patch is required for xmonad to make use of shared libraries.
 Without it, xmonad will not work since we do not (by default) use
 statically linked Haskell libraries.
 
-diff -ruN xmonad-0.15-a/src/XMonad/Core.hs xmonad-0.15-b/src/XMonad/Core.hs
---- xmonad-0.15-a/src/XMonad/Core.hs	1969-12-31 19:00:00.000000000 -0500
-+++ xmonad-0.15-b/src/XMonad/Core.hs	1969-12-31 19:00:00.000000000 -0500
-@@ -681,6 +681,8 @@
-        compileGHC bin dir errHandle =
-          runProcess "ghc" ["--make"
-                           , "xmonad.hs"
-+                          , "-dynamic"
-+                          , "-fPIC"
-                           , "-i"
-                           , "-ilib"
-                           , "-fforce-recomp"
+index 46a0939..5ad4f8f 100644
+--- a/src/XMonad/Core.hs
++++ b/src/XMonad/Core.hs
+@@ -664,6 +664,8 @@ compile dirs method =
+   where
+     ghcArgs = [ "--make"
+               , "xmonad.hs"
++              , "-dynamic"
++              , "-fPIC"
+               , "-i" -- only look in @lib@
+               , "-ilib"
+               , "-fforce-recomp"
diff --git a/gnu/packages/patches/xmonad-next-dynamic-linking.patch b/gnu/packages/patches/xmonad-next-dynamic-linking.patch
deleted file mode 100644
index a1d71825b6..0000000000
--- a/gnu/packages/patches/xmonad-next-dynamic-linking.patch
+++ /dev/null
@@ -1,16 +0,0 @@
-This patch is required for xmonad to make use of shared libraries.
-Without it, xmonad will not work since we do not (by default) use
-statically linked Haskell libraries.
-
-index 46a0939..5ad4f8f 100644
---- a/src/XMonad/Core.hs
-+++ b/src/XMonad/Core.hs
-@@ -664,6 +664,8 @@ compile dirs method =
-   where
-     ghcArgs = [ "--make"
-               , "xmonad.hs"
-+              , "-dynamic"
-+              , "-fPIC"
-               , "-i" -- only look in @lib@
-               , "-ilib"
-               , "-fforce-recomp"
diff --git a/gnu/packages/purescript.scm b/gnu/packages/purescript.scm
index dd048197b4..d968a6f0e6 100644
--- a/gnu/packages/purescript.scm
+++ b/gnu/packages/purescript.scm
@@ -34,79 +34,67 @@
 (define-public purescript
   (package
     (name "purescript")
-    (version "0.14.5")
+    (version "0.15.7")
     (source
      (origin
        (method url-fetch)
        (uri (hackage-uri "purescript" version))
        (sha256
-        (base32 "06f318hdah076vkviw1ryyg2p0gpbabsp8lbm5x03f2qv92n9j1n"))))
+        (base32 "1krjkgmxpfqf5a1jqs7qbg6r7ball1464zw6vgrdfzl9057c6l4f"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "purescript")))
-    (inputs
-     (list ghc-glob
-           ghc-aeson
-           ghc-aeson-better-errors
-           ghc-aeson-pretty
-           ghc-ansi-terminal
-           ghc-base-compat
-           ghc-blaze-html
-           ghc-bower-json
-           ghc-boxes
-           ghc-cborg
-           ghc-cheapskate
-           ghc-clock
-           ghc-cryptonite
-           ghc-data-ordlist
-           ghc-dlist
-           ghc-edit-distance
-           ghc-file-embed
-           ghc-fsnotify
-           ghc-happy
-           ghc-language-javascript
-           ghc-lifted-async
-           ghc-lifted-base
-           ghc-memory
-           ghc-microlens-platform
-           ghc-monad-control
-           ghc-monad-logger
-           ghc-network
-           ghc-parallel
-           ghc-pattern-arrows
-           ghc-protolude
-           ghc-purescript-cst
-           ghc-regex-tdfa
-           ghc-safe
-           ghc-scientific
-           ghc-semialign
-           ghc-semigroups
-           ghc-serialise
-           ghc-sourcemap
-           ghc-split
-           ghc-stringsearch
-           ghc-syb
-           ghc-these
-           ghc-transformers-base
-           ghc-transformers-compat
-           ghc-unordered-containers
-           ghc-utf8-string
-           ghc-vector
-           ghc-ansi-wl-pprint
-           ghc-http-types
-           ghc-network
-           ghc-optparse-applicative-0.15.1.0 ; XXX: needs specific version
-           ghc-wai
-           ghc-wai-websockets
-           ghc-warp
-           ghc-websockets))
-    (native-inputs
-     (list ghc-happy
-           ghc-hunit
-           ghc-hspec
-           hspec-discover
-           ghc-tasty
-           ghc-tasty-golden
-           ghc-tasty-hspec))
+    (inputs (list ghc-aeson
+                  ghc-aeson-better-errors
+                  ghc-ansi-terminal
+                  ghc-blaze-html
+                  ghc-bower-json
+                  ghc-boxes
+                  ghc-cborg
+                  ghc-serialise
+                  ghc-cheapskate
+                  ghc-clock
+                  ghc-cryptonite
+                  ghc-data-ordlist
+                  ghc-dlist
+                  ghc-edit-distance
+                  ghc-file-embed
+                  ghc-glob
+                  ghc-language-javascript
+                  ghc-lens
+                  ghc-lifted-async
+                  ghc-lifted-base
+                  ghc-memory
+                  ghc-monad-control
+                  ghc-monad-logger
+                  ghc-monoidal-containers
+                  ghc-parallel
+                  ghc-pattern-arrows
+                  ghc-protolude
+                  ghc-regex-tdfa
+                  ghc-safe
+                  ghc-scientific
+                  ghc-semigroups
+                  ghc-semialign
+                  ghc-sourcemap
+                  ghc-stringsearch
+                  ghc-these
+                  ghc-transformers-base
+                  ghc-utf8-string
+                  ghc-vector
+                  ghc-witherable
+                  ghc-ansi-wl-pprint
+                  ghc-network
+                  ghc-optparse-applicative
+                  ghc-gitrev))
+    (native-inputs (list ghc-generic-random
+                         ghc-hspec
+                         ghc-hunit
+                         ghc-newtype
+                         ghc-quickcheck
+                         ghc-regex-base
+                         ghc-split
+                         ghc-typed-process
+                         ghc-happy))
     (arguments
      `(;; Tests require npm
        #:tests? #f
@@ -116,7 +104,7 @@
          (add-before 'configure 'update-constraints
            (lambda _
              (substitute* "purescript.cabal"
-               (("\\b(ansi-terminal|cryptonite|dlist|language-javascript)\\s+[^,]+" all dep)
+               (("\\b(language-javascript|process)\\s+[^,]+" all dep)
                 dep)))))))
     (home-page "https://www.purescript.org/")
     (synopsis "Haskell inspired programming language compiling to JavaScript")
@@ -125,39 +113,3 @@
 expressive types, inspired by Haskell and compiling to JavaScript.")
     (license license:bsd-3)))
 
-(define-public ghc-purescript-cst
-  (package
-    (name "ghc-purescript-cst")
-    (version "0.4.0.0")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (hackage-uri "purescript-cst" version))
-        (sha256
-          (base32 "0r3f5lr9lrv9wpgkwj6nyl42lvxryj2lvr1w7ld4gki8ylq24n8g"))))
-    (build-system haskell-build-system)
-    (properties '((upstream-name . "purescript-cst")))
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "purescript-cst.cabal"
-               (("\\b(dlist)\\s+[^,]+" all dep)
-                dep)))))))
-    (inputs
-      (list ghc-aeson
-            ghc-base-compat
-            ghc-dlist
-            ghc-microlens
-            ghc-protolude
-            ghc-scientific
-            ghc-semigroups
-            ghc-serialise
-            ghc-vector))
-    (native-inputs (list ghc-happy))
-    (home-page "https://www.purescript.org/")
-    (synopsis "PureScript Programming Language Concrete Syntax Tree")
-    (description
-     "This package implements parser for the PureScript programming language.")
-    (license license:bsd-3)))
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index f7a4a3214f..6594a48273 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -801,40 +801,26 @@ background wallpaper manager with transparency support, a simple session
 manager and a system tray.")
     (license license:lgpl2.0)))
 
-
-(define-public xmonad-next
+(define-public xmonad
   (package
-    (name "xmonad-next")
-    (version "0.17.0")
-    (synopsis "Tiling window manager")
+    (name "xmonad")
+    (version "0.17.1")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "xmonad" version))
               (sha256
                (base32
-                "04qspdz9w6xpw1npcmx2zx0595wc68q985pv4i0hvp32zillvdqy"))
-              (patches (search-patches "xmonad-next-dynamic-linking.patch"))))
+                "1apqwyqmc51gamfgsvlanzqqig9qvjss89ibcamhnha1gs1k4jl8"))
+              (patches (search-patches "xmonad-dynamic-linking.patch"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "xmonad")))
-    (inputs (list ghc-data-default-class ghc-setlocale ghc-x11))
+    (inputs (list ghc-x11 ghc-data-default-class ghc-setlocale))
     (native-inputs (list ghc-quickcheck ghc-quickcheck-classes))
     (arguments
-     (list #:phases
-           #~(modify-phases %standard-phases
-               (add-after 'install 'install-xsession
-                 (lambda _
-                   (let ((xsessions (string-append #$output "/share/xsessions")))
-                     (mkdir-p xsessions)
-                     (call-with-output-file (string-append xsessions
-                                                           "/xmonad.desktop")
-                       (lambda (port)
-                         (format port "~
-                    [Desktop Entry]~@
-                    Name=~a~@
-                    Comment=~a~@
-                    Exec=~a/bin/xmonad~@
-                    Type=Application~%" #$name #$synopsis #$output)))))))))
-    (home-page "https://xmonad.org")
+     `(#:cabal-revision ("2"
+                         "1rgwrnyb7kijzl2mqm8ks2nydh37q5vkbg4400rg9n6x13w2r9b3")))
+    (home-page "http://xmonad.org")
+    (synopsis "Tiling window manager")
     (description
      "Xmonad is a tiling window manager for X.  Windows are arranged
 automatically to tile the screen without gaps or overlap, maximising screen
@@ -846,42 +832,16 @@ used on each workspace.  Xinerama is fully supported, allowing windows to be
 tiled on several screens.")
     (license license:bsd-3)))
 
-(define-public xmonad
-  (package
-    (inherit xmonad-next)
-    (name "xmonad")
-    (version "0.15")
-    (source (origin
-              (method url-fetch)
-              (uri (hackage-uri "xmonad" version))
-              (sha256
-               (base32
-                "0a7rh21k9y6g8fwkggxdxjns2grvvsd5hi2ls4klmqz5xvk4hyaa"))
-              (patches (search-patches "xmonad-dynamic-linking.patch"))))
-    (inputs
-     (list ghc-extensible-exceptions
-           ghc-data-default
-           ghc-quickcheck
-           ghc-semigroups
-           ghc-setlocale
-           ghc-utf8-string
-           ghc-x11))
-    (native-inputs '())
-    (arguments
-     `(#:cabal-revision
-       ("1" "0yqh96qqphllr0zyz5j93cij5w2qvf39xxnrb52pz0qz3pywz9wd")
-       ,@(package-arguments xmonad-next)))))
-
 (define-public xmobar
   (package
     (name "xmobar")
-    (version "0.44.2")
+    (version "0.46")
     (source (origin
               (method url-fetch)
               (uri (hackage-uri "xmobar" version))
               (sha256
                (base32
-                "0gdphjn5ll5lkb2psdsb34563wsz6g0y2gg3z8cj4jy8lvbbv808"))))
+                "0glpiq7c0qwfcxnc2flgzj7afm5m1a9ghzwwcq7f8q27m21kddrd"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "xmobar")))
     (native-inputs
@@ -904,6 +864,8 @@ tiled on several screens.")
            ghc-timezone-olson
            ghc-x11
            ghc-x11-xft
+           ghc-cairo
+           ghc-pango
            libxpm))
     (arguments
      `(#:configure-flags (list "--flags=all_extensions")
@@ -945,53 +907,30 @@ Unlike dmenu, it mangles the input before it presents its choices.  In
 particular, it displays commonly-chosen options before uncommon ones.")
     (license license:bsd-3)))
 
-(define-public ghc-xmonad-contrib-next
+(define-public ghc-xmonad-contrib
   (package
-    (name "ghc-xmonad-contrib-next")
-    (version "0.17.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "xmonad-contrib" version))
-       (sha256
-        (base32 "11g1cyfgfvcmz35qhgi9wzxrk3br8m8b7qy3jvph4nnf6aj13wvy"))))
+    (name "ghc-xmonad-contrib")
+    (version "0.17.1")
+    (source (origin
+              (method url-fetch)
+              (uri (hackage-uri "xmonad-contrib" version))
+              (sha256
+               (base32
+                "0lwj8xkyaw6h0rv3lz2jdqrwzz7yghfmnhpndygkb3wgyhvq6dxb"))))
     (build-system haskell-build-system)
     (properties '((upstream-name . "xmonad-contrib")))
-    (propagated-inputs (list ghc-random ghc-x11 ghc-utf8-string ghc-x11-xft xmonad-next))
+    (inputs (list ghc-random ghc-x11 xmonad ghc-utf8-string ghc-x11-xft))
     (native-inputs (list ghc-quickcheck ghc-hspec))
-    (home-page "https://xmonad.org")
+    (arguments
+     `(#:cabal-revision ("1"
+                         "0dc9nbn0kaw98rgpi1rq8np601zjhdr1y0ydg6yb82wwaqawql6z")))
+    (home-page "https://xmonad.org/")
     (synopsis "Third party extensions for xmonad")
     (description
      "Third party tiling algorithms, configurations, and scripts to Xmonad, a
 tiling window manager for X.")
     (license license:bsd-3)))
 
-(define-public ghc-xmonad-contrib
-  (package
-    (inherit ghc-xmonad-contrib-next)
-    (name "ghc-xmonad-contrib")
-    (version "0.16")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (hackage-uri "xmonad-contrib" version))
-       (sha256
-        (base32 "1pddgkvnbww28wykncc7j0yb0lv15bk7xnnhdcbrwkxzw66w6wmd"))))
-    (arguments
-     `(#:cabal-revision
-       ("1" "0vimkby2gq6sgzxzbvz67caba609xqlv2ii2gi8a1cjrnn6ib011")
-       ,@(package-arguments ghc-xmonad-contrib-next)))
-    (native-inputs '())
-    (propagated-inputs
-     (list ghc-old-time
-           ghc-random
-           ghc-utf8-string
-           ghc-extensible-exceptions
-           ghc-semigroups
-           ghc-x11
-           ghc-x11-xft
-           xmonad))))
-
 (define-public evilwm
   (package
     (name "evilwm")