gnu: Add ghc-inspection-testing.
[jackhill/guix/guix.git] / gnu / packages / haskell-xyz.scm
index 03ae83d..29d3077 100644 (file)
@@ -4,7 +4,7 @@
 ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
 ;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
 ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
 ;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
 ;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
-;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
 ;;; Copyright © 2016, 2019 Efraim Flashner <efraim@flashner.co.il>
 ;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
 ;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
 ;;; Copyright © 2016, 2019 Efraim Flashner <efraim@flashner.co.il>
 ;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
 ;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
 ;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
 ;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com>
 ;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
 ;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
 ;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com>
 ;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
+;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
+;;; Copyright © 2020 JoJo <jo@jo.zone>
+;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr>
+;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -53,6 +57,7 @@
   #:use-module (gnu packages haskell-web)
   #:use-module (gnu packages libffi)
   #:use-module (gnu packages linux)
   #:use-module (gnu packages haskell-web)
   #:use-module (gnu packages libffi)
   #:use-module (gnu packages linux)
+  #:use-module (gnu packages llvm)
   #:use-module (gnu packages lua)
   #:use-module (gnu packages maths)
   #:use-module (gnu packages ncurses)
   #:use-module (gnu packages lua)
   #:use-module (gnu packages maths)
   #:use-module (gnu packages ncurses)
@@ -451,6 +456,34 @@ colored output using the ansi-terminal package.")
 style.")
     (license license:bsd-3)))
 
 style.")
     (license license:bsd-3)))
 
+(define-public ghc-assoc
+  (package
+    (name "ghc-assoc")
+    (version "1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/assoc/assoc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1m9n4vp190bvn2wcrd4ggfwa9pi93jp0zgx02mdgywn2zfidw020"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-bifunctors" ,ghc-bifunctors)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page
+     "http://hackage.haskell.org/package/assoc")
+    (synopsis
+     "Swap and assoc: Symmetric and Semigroupy Bifunctors")
+    (description
+     "Provides generalisations of @code{swap :: (a,b) -> (b,a)} and
+@code{assoc :: ((a,b),c) -> (a,(b,c))} to @code{Bifunctor}s supporting
+similar operations (e.g. @code{Either}, @code{These}).")
+    (license license:bsd-3)))
+
 (define-public ghc-async
   (package
     (name "ghc-async")
 (define-public ghc-async
   (package
     (name "ghc-async")
@@ -786,7 +819,7 @@ pragmas in your code.")
     (arguments
      `(#:cabal-revision
        ("1" "15sn2qc8k0hxbb2nai341kkrci98hlhzcj2ci087m0zxcg5jcdbp")))
     (arguments
      `(#:cabal-revision
        ("1" "15sn2qc8k0hxbb2nai341kkrci98hlhzcj2ci087m0zxcg5jcdbp")))
-    (home-page "http://hackage.haskell.org/package/base-compat-batteries")
+    (home-page "https://hackage.haskell.org/package/base-compat-batteries")
     (synopsis "base-compat with extra batteries")
     (description "This library provides functions available in later
 versions of @code{base} to a wider range of compilers, without requiring
     (synopsis "base-compat with extra batteries")
     (description "This library provides functions available in later
 versions of @code{base} to a wider range of compilers, without requiring
@@ -902,6 +935,45 @@ stand for certain ASCII character sequences, i.e. → instead of @code{->},
 ∀ instead of @code{forall} and many others.")
     (license license:bsd-3)))
 
 ∀ instead of @code{forall} and many others.")
     (license license:bsd-3)))
 
+(define-public ghc-basic-prelude
+  (package
+    (name "ghc-basic-prelude")
+    (version "0.7.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/basic-prelude/"
+             "basic-prelude-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0yckmnvm6i4vw0mykj4fzl4ldsf67v8d2h0vp1bakyj84n4myx8h"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hashable" ,ghc-hashable)
+       ("ghc-unordered-containers"
+        ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)))
+    (home-page "https://github.com/snoyberg/basic-prelude#readme")
+    (synopsis "Enhanced core prelude; a common foundation for alternate preludes")
+    (description
+     "The premise of basic-prelude is that there are a lot of very commonly
+desired features missing from the standard Prelude, such as commonly used
+operators (<$> and >=>, for instance) and imports for common datatypes
+(e.g., ByteString and Vector).  At the same time, there are lots of other
+components which are more debatable, such as providing polymorphic versions
+of common functions.
+
+So basic-prelude is intended to give a common foundation for a number of
+alternate preludes.  The package provides two modules: CorePrelude provides
+the common ground for other preludes to build on top of, while BasicPrelude
+exports CorePrelude together with commonly used list functions to provide a
+drop-in replacement for the standard Prelude.
+
+Users wishing to have an improved Prelude can use BasicPrelude.  Developers
+wishing to create a new prelude should use CorePrelude.")
+    (license license:expat)))
+
 (define-public ghc-bifunctors
   (package
     (name "ghc-bifunctors")
 (define-public ghc-bifunctors
   (package
     (name "ghc-bifunctors")
@@ -2796,7 +2868,7 @@ providing an @code{rnf} implementation.")
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)
        ("ghc-quickcheck" ,ghc-quickcheck)))
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)
        ("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page "http://hackage.haskell.org/package/dense-linear-algebra")
+    (home-page "https://hackage.haskell.org/package/dense-linear-algebra")
     (synopsis "Simple and incomplete implementation of linear algebra")
     (description "This library is simply a collection of linear-algebra
 related modules split from the statistics library.")
     (synopsis "Simple and incomplete implementation of linear algebra")
     (description "This library is simply a collection of linear-algebra
 related modules split from the statistics library.")
@@ -3573,7 +3645,7 @@ Double.")
      `(("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-hspec" ,ghc-hspec)
        ("hspec-discover" ,hspec-discover)))
      `(("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-hspec" ,ghc-hspec)
        ("hspec-discover" ,hspec-discover)))
-    (home-page "http://hackage.haskell.org/package/errorcall-eq-instance")
+    (home-page "https://hackage.haskell.org/package/errorcall-eq-instance")
     (synopsis "Orphan Eq instance for ErrorCall")
     (description
      "Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}.
     (synopsis "Orphan Eq instance for ErrorCall")
     (description
      "Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}.
@@ -3608,7 +3680,7 @@ directly uses the type system, rather than out-of-band exceptions.")
 (define-public ghc-esqueleto
   (package
     (name "ghc-esqueleto")
 (define-public ghc-esqueleto
   (package
     (name "ghc-esqueleto")
-    (version "3.0.0")
+    (version "3.3.1.1")
     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)
@@ -3616,7 +3688,7 @@ directly uses the type system, rather than out-of-band exceptions.")
                            "esqueleto/esqueleto-" version ".tar.gz"))
        (sha256
         (base32
                            "esqueleto/esqueleto-" version ".tar.gz"))
        (sha256
         (base32
-         "187c098h2xyf2nhifkdy2bqfl6iap7a93mzwd2kirl5yyicpc9zy"))))
+         "1qi28ma8j5kfygjxnixlazxsyrkdqv8ljz3icwqi5dlscsnj6v3v"))))
     (build-system haskell-build-system)
     (arguments
      `(#:haddock? #f  ; Haddock reports an internal error.
     (build-system haskell-build-system)
     (arguments
      `(#:haddock? #f  ; Haddock reports an internal error.
@@ -3689,7 +3761,7 @@ generated SQL and optimize it for your backend.")
        ("ghc-silently" ,ghc-silently)
        ("ghc-filemanip" ,ghc-filemanip)))
     (home-page
        ("ghc-silently" ,ghc-silently)
        ("ghc-filemanip" ,ghc-filemanip)))
     (home-page
-     "http://hackage.haskell.org/package/ghc-exactprint")
+     "https://hackage.haskell.org/package/ghc-exactprint")
     (synopsis "ExactPrint for GHC")
     (description
      "Using the API Annotations available from GHC 7.10.2, this library
     (synopsis "ExactPrint for GHC")
     (description
      "Using the API Annotations available from GHC 7.10.2, this library
@@ -3770,7 +3842,7 @@ versions of GHC (i.e., < 6.10).")
 (define-public ghc-extra
   (package
     (name "ghc-extra")
 (define-public ghc-extra
   (package
     (name "ghc-extra")
-    (version "1.6.18")
+    (version "1.6.21")
     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)
@@ -3780,12 +3852,13 @@ versions of GHC (i.e., < 6.10).")
              ".tar.gz"))
        (sha256
         (base32
              ".tar.gz"))
        (sha256
         (base32
-         "0jvd4l0hi8pf5899pxc32yc638y0mrc357w0rph99k3hm277i0cy"))))
+         "1gjx98w4w61g043k6rzc8i34cbxpcigi8lb6i7pp1vwp8w8jm5vl"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-clock" ,ghc-clock)
        ("ghc-semigroups" ,ghc-semigroups)
     (build-system haskell-build-system)
     (inputs
      `(("ghc-clock" ,ghc-clock)
        ("ghc-semigroups" ,ghc-semigroups)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
     (home-page "https://github.com/ndmitchell/extra")
     (synopsis "Extra Haskell functions")
     (description "This library provides extra functions for the standard
     (home-page "https://github.com/ndmitchell/extra")
     (synopsis "Extra Haskell functions")
     (description "This library provides extra functions for the standard
@@ -4014,7 +4087,7 @@ file contents, and more.")
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)))
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page "http://hackage.haskell.org/package/filepath-bytestring")
+    (home-page "https://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
 @code{filepath} library, operating on @code{RawFilePath} values rather than
     (synopsis "Library for manipulating RawFilePaths in a cross-platform way")
     (description "This package provides a drop-in replacement for the standard
 @code{filepath} library, operating on @code{RawFilePath} values rather than
@@ -5007,7 +5080,7 @@ combine hash values.")
      `(#:cabal-revision
        ("2" "006phc5y9rrvsshdcmjmhxzxh8dpgs685mpqbkjm9c40xb1ydjbz")))
     (inputs `(("ghc-hashable" ,ghc-hashable)))
      `(#:cabal-revision
        ("2" "006phc5y9rrvsshdcmjmhxzxh8dpgs685mpqbkjm9c40xb1ydjbz")))
     (inputs `(("ghc-hashable" ,ghc-hashable)))
-    (home-page "http://hackage.haskell.org/package/hashable-time")
+    (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
     (synopsis "Hashable instances for Data.Time")
     (description
      "This package provides @code{Hashable} instances for types in
@@ -5052,7 +5125,7 @@ a set of wrappers to use the hash tables in the IO monad.")
        (sha256
         (base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
     (build-system haskell-build-system)
        (sha256
         (base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
     (build-system haskell-build-system)
-    (home-page "http://hackage.haskell.org/package/haskell-lexer")
+    (home-page "https://hackage.haskell.org/package/haskell-lexer")
     (synopsis "Fully compliant Haskell 98 lexer")
     (description
      "This package provides a fully compliant Haskell 98 lexer.")
     (synopsis "Fully compliant Haskell 98 lexer")
     (description
      "This package provides a fully compliant Haskell 98 lexer.")
@@ -5281,8 +5354,7 @@ descriptions.")
            (lambda* (#:key inputs outputs #:allow-other-keys)
              (let* ((out   (assoc-ref outputs "out"))
                     (elisp-file "elisp/hindent.el")
            (lambda* (#:key inputs outputs #:allow-other-keys)
              (let* ((out   (assoc-ref outputs "out"))
                     (elisp-file "elisp/hindent.el")
-                    (dest  (string-append out "/share/emacs/site-lisp"
-                                          "/guix.d/hindent-" ,version))
+                    (dest  (string-append out "/share/emacs/site-lisp"))
                     (emacs (string-append (assoc-ref inputs "emacs")
                                           "/bin/emacs")))
                (make-file-writable elisp-file)
                     (emacs (string-append (assoc-ref inputs "emacs")
                                           "/bin/emacs")))
                (make-file-writable elisp-file)
@@ -5788,7 +5860,7 @@ for general types.")
         (base32
          "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
     (build-system haskell-build-system)
         (base32
          "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
     (build-system haskell-build-system)
-    (home-page "http://hackage.haskell.org/package/IfElse")
+    (home-page "https://hackage.haskell.org/package/IfElse")
     (synopsis "Monadic control flow with anaphoric variants")
     (description "This library provides functions for control flow inside of
 monads with anaphoric variants on @code{if} and @code{when} and a C-like
     (synopsis "Monadic control flow with anaphoric variants")
     (description "This library provides functions for control flow inside of
 monads with anaphoric variants on @code{if} and @code{when} and a C-like
@@ -5841,7 +5913,7 @@ lines continued at an indented level below.")
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)
        ("hspec-discover" ,hspec-discover)))
     (native-inputs
      `(("ghc-hspec" ,ghc-hspec)
        ("hspec-discover" ,hspec-discover)))
-    (home-page "http://hackage.haskell.org/package/infer-license")
+    (home-page "https://hackage.haskell.org/package/infer-license")
     (synopsis "Infer software license from a given license file")
     (description "This library provides tools to infer a software
 license from a given license file.")
     (synopsis "Infer software license from a given license file")
     (description "This library provides tools to infer a software
 license from a given license file.")
@@ -5872,7 +5944,7 @@ license from a given license file.")
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-raw-strings-qq" ,ghc-raw-strings-qq)
        ("ghc-regex-posix" ,ghc-regex-posix)))
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-raw-strings-qq" ,ghc-raw-strings-qq)
        ("ghc-regex-posix" ,ghc-regex-posix)))
-    (home-page "http://hackage.haskell.org/package/inline-c")
+    (home-page "https://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
     (synopsis "Write Haskell source files including C code inline")
     (description
      "inline-c lets you seamlessly call C libraries and embed high-performance
@@ -6096,7 +6168,7 @@ functors).  For more information, see Edward Kmett's article
        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
        ("ghc-zlib" ,ghc-zlib)))
        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
        ("ghc-zlib" ,ghc-zlib)))
-    (home-page "http://hackage.haskell.org/package/io-streams")
+    (home-page "https://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.")
     (synopsis "Simple and composable stream I/O")
     (description "This library contains simple and easy-to-use
 primitives for I/O using streams.")
@@ -6337,7 +6409,7 @@ and a large set of GNU extensions.")
      `(#:tests? #f
        #:cabal-revision
        ("1" "10ac9pk4jy75k03j1ns4b5136l4kw8krr2d2nw2fdmpm5jzyghc5")))
      `(#:tests? #f
        #:cabal-revision
        ("1" "10ac9pk4jy75k03j1ns4b5136l4kw8krr2d2nw2fdmpm5jzyghc5")))
-    (home-page "http://hackage.haskell.org/package/language-glsl")
+    (home-page "https://hackage.haskell.org/package/language-glsl")
     (synopsis "GLSL abstract syntax tree, parser, and pretty-printer")
     (description "This package is a Haskell library for the
 representation, parsing, and pretty-printing of GLSL 1.50 code.")
     (synopsis "GLSL abstract syntax tree, parser, and pretty-printer")
     (description "This package is a Haskell library for the
 representation, parsing, and pretty-printing of GLSL 1.50 code.")
@@ -6441,7 +6513,7 @@ indexed variants.")
     (build-system haskell-build-system)
     (native-inputs `(("pkg-config" ,pkg-config)))
     (inputs `(("libffi" ,libffi)))
     (build-system haskell-build-system)
     (native-inputs `(("pkg-config" ,pkg-config)))
     (inputs `(("libffi" ,libffi)))
-    (home-page "http://hackage.haskell.org/package/libffi")
+    (home-page "https://hackage.haskell.org/package/libffi")
     (synopsis "Haskell binding to libffi")
     (description
      "A binding to libffi, allowing C functions of types only known at runtime
     (synopsis "Haskell binding to libffi")
     (description
      "A binding to libffi, allowing C functions of types only known at runtime
@@ -6556,7 +6628,7 @@ compiler versions.")
     (inputs
      `(("ghc-conduit" ,ghc-conduit)
        ("ghc-resourcet" ,ghc-resourcet)
     (inputs
      `(("ghc-conduit" ,ghc-conduit)
        ("ghc-resourcet" ,ghc-resourcet)
-       ("libyaml" ,libyaml-2.1)))
+       ("libyaml" ,libyaml)))
     (home-page "https://github.com/snoyberg/yaml#readme")
     (synopsis "Low-level, streaming YAML interface.")
     (description "This package provides a Haskell wrapper over the
     (home-page "https://github.com/snoyberg/yaml#readme")
     (synopsis "Low-level, streaming YAML interface.")
     (description "This package provides a Haskell wrapper over the
@@ -6703,6 +6775,72 @@ ByteString, for types that support input and output, and for types that
 can handle infinite lists.")
     (license license:bsd-3)))
 
 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 (string-append "https://hackage.haskell.org/package/llvm-hs-pure/"
+                           "llvm-hs-pure-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0pxb5ah8r5pzpz2ibqw3g9g1isigb4z7pbzfrwr8kmcjn74ab3kf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-fail" ,ghc-fail)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,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 (string-append "https://hackage.haskell.org/package/llvm-hs/llvm-hs-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "0723xgh45h9cyxmmjsvxnsp8bpn1ljy4qgh7a7vqq3sj9d6wzq00"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-llvm-hs-pure" ,ghc-llvm-hs-pure)
+       ("llvm" ,llvm-9)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-temporary" ,ghc-temporary)
+       ("ghc-pretty-show" ,ghc-pretty-show)
+       ("ghc-temporary" ,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")
 (define-public ghc-logging-facade
   (package
     (name "ghc-logging-facade")
@@ -6829,7 +6967,7 @@ compression algorithm used in the @code{.xz} file format.")
         (base32
          "10p0gjjjwr1dda7hahwrwn5njbfhl67arq3v3nf1jr3vymlkn75j"))))
     (build-system haskell-build-system)
         (base32
          "10p0gjjjwr1dda7hahwrwn5njbfhl67arq3v3nf1jr3vymlkn75j"))))
     (build-system haskell-build-system)
-    (home-page "http://hackage.haskell.org/package/magic")
+    (home-page "https://hackage.haskell.org/package/magic")
     (synopsis "Interface to C file/magic library")
     (description
      "This package provides a full-featured binding to the C libmagic library.
     (synopsis "Interface to C file/magic library")
     (description
      "This package provides a full-featured binding to the C libmagic library.
@@ -7193,7 +7331,7 @@ used both from lens and microlens).")
      `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
        ("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-hunit" ,ghc-hunit)))
      `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
        ("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-hunit" ,ghc-hunit)))
-    (home-page "http://software.complete.org/missingh")
+    (home-page "https://software.complete.org/missingh")
     (synopsis "Large utility library")
     (description
      "MissingH is a library of all sorts of utility functions for Haskell
     (synopsis "Large utility library")
     (description
      "MissingH is a library of all sorts of utility functions for Haskell
@@ -7521,6 +7659,41 @@ semi-direct products, \"deletable\" monoids, \"split\" monoids, and
 \"cut\" monoids.")
     (license license:bsd-3)))
 
 \"cut\" monoids.")
     (license license:bsd-3)))
 
+(define-public ghc-mtl-compat
+  (package
+    (name "ghc-mtl-compat")
+    (version "0.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/mtl-compat/mtl-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "17iszr5yb4f17g8mq6i74hsamii8z6m2qfsmgzs78mhiwa7kjm8r"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://github.com/haskell-compat/mtl-compat")
+    (synopsis
+     "Backported Control.Monad.Except module from mtl")
+    (description
+     "This package backports the Control.Monad.Except module from mtl (if
+using mtl-2.2.0.1 or earlier), which reexports the ExceptT monad transformer
+and the MonadError class.
+
+This package should only be used if there is a need to use the
+Control.Monad.Except module specifically.  If you just want the mtl class
+instances for ExceptT, use transformers-compat instead, since mtl-compat does
+nothing but reexport the instances from that package.
+
+Note that unlike how mtl-2.2 or later works, the Control.Monad.Except
+module defined in this package exports all of ExceptT's monad class instances.
+Therefore, you may have to declare @code{import Control.Monad.Except ()} at
+the top of your file to get all of the ExceptT instances in scope.")
+    (license license:bsd-3)))
+
 (define-public ghc-murmur-hash
   (package
     (name "ghc-murmur-hash")
 (define-public ghc-murmur-hash
   (package
     (name "ghc-murmur-hash")
@@ -7716,7 +7889,7 @@ network database (<netdb.h>) API.")
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-doctest" ,ghc-doctest)))
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-doctest" ,ghc-doctest)))
-    (home-page "http://hackage.haskell.org/package/network-byte-order")
+    (home-page "https://hackage.haskell.org/package/network-byte-order")
     (synopsis "Network byte order utilities")
     (description "This library provides peek and poke functions for network
 byte order.")
     (synopsis "Network byte order utilities")
     (description "This library provides peek and poke functions for network
 byte order.")
@@ -7827,6 +8000,36 @@ class, and a lazy number type for non-negative numbers (a generalization
 of Peano numbers).")
     (license license:gpl3+)))
 
 of Peano numbers).")
     (license license:gpl3+)))
 
+(define-public ghc-nonce
+  (package
+    (name "ghc-nonce")
+    (version "1.0.7")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/nonce/"
+             "nonce-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1q9ph0aq51mvdvydnriqd12sfin36pfb8f588zgac1ybn8r64ksb"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-entropy" ,ghc-entropy)
+       ("ghc-unliftio" ,ghc-unliftio)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)))
+    (home-page "https://github.com/prowdsponsor/nonce")
+    (synopsis "Generate cryptographic nonces in Haskell")
+    (description
+     "A nonce is an arbitrary number used only once in a cryptographic
+communication.  This package contain helper functions for generating nonces.
+There are many kinds of nonces used in different situations.  It's not
+guaranteed that by using the nonces from this package you won't have any
+security issues.  Please make sure that the nonces generated via this
+package are usable on your design.")
+    (license license:bsd-3)))
+
 (define-public ghc-numeric-extras
   (package
     (name "ghc-numeric-extras")
 (define-public ghc-numeric-extras
   (package
     (name "ghc-numeric-extras")
@@ -8096,6 +8299,114 @@ easily work with command-line options.")
 command line options in Haskell.")
     (license license:bsd-3)))
 
 command line options in Haskell.")
     (license license:bsd-3)))
 
+(define-public ghc-jira-wiki-markup
+  (package
+    (name "ghc-jira-wiki-markup")
+    (version "1.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/jira-wiki-markup/"
+             "jira-wiki-markup-" version ".tar.gz"))
+       (sha256
+        (base32 "1sl2jjcsqg61si33mxjwpf8zdn56kbbgcwqqqzbgifx2qbv4wmf8"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/tarleb/jira-wiki-markup")
+    (synopsis "Handle Jira wiki markup")
+    (description
+     "Parse jira wiki text into an abstract syntax tree for easy transformation
+to other formats.")
+    (license license:expat)))
+
+(define-public ghc-emojis
+  (package
+    (name "ghc-emojis")
+    (version "0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/emojis/"
+             "emojis-" version ".tar.gz"))
+       (sha256
+        (base32 "1c6zkj9gmk1y90gbdrn50hyp7mw1mggzhnr2khqd728ryipw60ss"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/jgm/emojis#readme")
+    (synopsis "Conversion between emoji characters and their names.")
+    (description
+     "This package provides functions for converting emoji names to emoji
+characters and vice versa.
+
+How does it differ from the @code{emoji} package?
+@itemize
+@item It supports a fuller range of emojis, including all those supported by
+GitHub
+@item It supports lookup of emoji aliases from emoji
+@item It uses Text rather than String
+@item It has a lighter dependency footprint: in particular, it does not
+require aeson
+@item It does not require TemplateHaskell
+@end itemize")
+    (license license:bsd-3)))
+
+(define-public ghc-text-conversions
+  (package
+    (name "ghc-text-conversions")
+    (version "0.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/text-conversions/"
+             "text-conversions-" version ".tar.gz"))
+       (sha256
+        (base32 "089c56vdj9xysqfr1hnvbnrghlg83q6w10xk02gflpsidcpvwmhp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-errors" ,ghc-errors)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
+    (home-page "https://github.com/cjdev/text-conversions#readme")
+    (synopsis "Safe conversions between textual types")
+    (description "Safe conversions between textual types")
+    (license license:isc)))
+
+(define-public ghc-doclayout
+  (package
+    (name "ghc-doclayout")
+    (version "0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/doclayout/"
+             "doclayout-" version ".tar.gz"))
+       (sha256
+        (base32 "1wmnwq28jcyd6c80srivsnd5znmyl9sgmwwnlk2crwiiwqadbal7"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-safe" ,ghc-safe)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/jgm/doclayout")
+    (synopsis "Pretty-printing library for laying out text documents")
+    (description
+     "doclayout is a pretty-printing library for laying out text documents,
+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
   (package
     (name "ghc-pandoc")
 (define-public ghc-pandoc
   (package
     (name "ghc-pandoc")
@@ -8390,7 +8701,7 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-validity" ,ghc-validity)))
     (home-page
        ("ghc-hspec" ,ghc-hspec)
        ("ghc-validity" ,ghc-validity)))
     (home-page
-     "http://hackage.haskell.org/package/path")
+     "https://hackage.haskell.org/package/path")
     (synopsis "Support for well-typed paths")
     (description "This package introduces a type for paths upholding useful
 invariants.")
     (synopsis "Support for well-typed paths")
     (description "This package introduces a type for paths upholding useful
 invariants.")
@@ -8476,6 +8787,29 @@ of two versions of a source file.  It provides a good balance between
 performance, nice output for humans, and simplicity of implementation.")
     (license license:bsd-3)))
 
 performance, nice output for humans, and simplicity of implementation.")
     (license license:bsd-3)))
 
+(define-public ghc-pattern-arrows
+  (package
+    (name "ghc-pattern-arrows")
+    (version "0.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/pattern-arrows/pattern-arrows-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "13q7bj19hd60rnjfc05wxlyck8llxy11z3mns8kxg197wxrdkhkg"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html")
+    (synopsis "Arrows for Pretty Printing")
+    (description
+     "A library for generating concise pretty printers based on precedence
+rules.")
+    (license license:expat)))
+
 (define-public ghc-pcre-light
   (package
     (name "ghc-pcre-light")
 (define-public ghc-pcre-light
   (package
     (name "ghc-pcre-light")
@@ -8506,41 +8840,36 @@ syntax and semantics as Perl 5.")
 (define-public ghc-persistent
   (package
     (name "ghc-persistent")
 (define-public ghc-persistent
   (package
     (name "ghc-persistent")
-    (version "2.9.2")
+    (version "2.10.4")
     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "persistent-" version "/"
-                           "persistent-" version ".tar.gz"))
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent/"
+             "persistent-" version ".tar.gz"))
        (sha256
         (base32
        (sha256
         (base32
-         "1wsa3kn427v88a6r0vwr6mz23snik2krbsgc8zqp18xajqn5szj9"))))
+         "1cxswz72sqdg2z1nbpgp1k5qr41djgk8qbf8nz7wfppsrhacyffi"))))
     (build-system haskell-build-system)
     (build-system haskell-build-system)
-    (inputs `(("ghc-old-locale" ,ghc-old-locale)
-              ("ghc-conduit" ,ghc-conduit)
-              ("ghc-resourcet" ,ghc-resourcet)
-              ("ghc-exceptions" ,ghc-exceptions)
-              ("ghc-monad-control" ,ghc-monad-control)
-              ("ghc-lifted-base" ,ghc-lifted-base)
-              ("ghc-resource-pool" ,ghc-resource-pool)
-              ("ghc-path-pieces" ,ghc-path-pieces)
-              ("ghc-http-api-data" ,ghc-http-api-data)
-              ("ghc-aeson" ,ghc-aeson)
-              ("ghc-monad-logger" ,ghc-monad-logger)
-              ("ghc-transformers-base" ,ghc-transformers-base)
-              ("ghc-base64-bytestring" ,ghc-base64-bytestring)
-              ("ghc-unordered-containers" ,ghc-unordered-containers)
-              ("ghc-vector" ,ghc-vector)
-              ("ghc-attoparsec" ,ghc-attoparsec)
-              ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
-              ("ghc-blaze-html" ,ghc-blaze-html)
-              ("ghc-blaze-markup" ,ghc-blaze-markup)
-              ("ghc-silently" ,ghc-silently)
-              ("ghc-fast-logger" ,ghc-fast-logger)
-              ("ghc-scientific" ,ghc-scientific)
-              ("ghc-tagged" ,ghc-tagged)
-              ("ghc-void" ,ghc-void)))
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-http-api-data" ,ghc-http-api-data)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-path-pieces" ,ghc-path-pieces)
+       ("ghc-resource-pool" ,ghc-resource-pool)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-silently" ,ghc-silently)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("ghc-unliftio" ,ghc-unliftio)
+       ("ghc-unordered-containers"
+        ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)))
     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
     (home-page "https://www.yesodweb.com/book/persistent")
     (synopsis "Type-safe, multi-backend data serialization for Haskell")
     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
     (home-page "https://www.yesodweb.com/book/persistent")
     (synopsis "Type-safe, multi-backend data serialization for Haskell")
@@ -8552,30 +8881,40 @@ way.")
 (define-public ghc-persistent-sqlite
   (package
     (name "ghc-persistent-sqlite")
 (define-public ghc-persistent-sqlite
   (package
     (name "ghc-persistent-sqlite")
-    (version "2.9.3")
+    (version "2.10.5.2")
     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "persistent-sqlite-" version "/"
-                           "persistent-sqlite-" version ".tar.gz"))
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent-sqlite/"
+             "persistent-sqlite-" version ".tar.gz"))
        (sha256
         (base32
        (sha256
         (base32
-         "13wbn88ixv4d4dfjl1gabm1q60fbcnygbmixz57pi3z84drrynwq"))))
+         "0agag3cgivl6mk38pqzr0qw5lxps9p2bgdwvi5658l46hs7bixxn"))))
     (build-system haskell-build-system)
     (build-system haskell-build-system)
-    (inputs `(("ghc-persistent" ,ghc-persistent)
-              ("ghc-unliftio-core" ,ghc-unliftio-core)
-              ("ghc-aeson" ,ghc-aeson)
-              ("ghc-conduit" ,ghc-conduit)
-              ("ghc-monad-logger" ,ghc-monad-logger)
-              ("ghc-microlens-th" ,ghc-microlens-th)
-              ("ghc-resourcet" ,ghc-resourcet)
-              ("ghc-old-locale" ,ghc-old-locale)
-              ("ghc-resource-pool" ,ghc-resource-pool)
-              ("ghc-unordered-containers" ,ghc-unordered-containers)))
-    (native-inputs `(("ghc-hspec" ,ghc-hspec)
-                     ("ghc-persistent-template" ,ghc-persistent-template)
-                     ("ghc-temporary" ,ghc-temporary)))
+    (inputs
+     `(("ghc-persistent" ,ghc-persistent)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-microlens-th" ,ghc-microlens-th)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-resource-pool" ,ghc-resource-pool)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("ghc-unordered-containers"
+        ,ghc-unordered-containers)))
+    (native-inputs
+     `(("ghc-persistent-template"
+        ,ghc-persistent-template)
+       ("ghc-persistent-test" ,ghc-persistent-test)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-system-fileio" ,ghc-system-fileio)
+       ("ghc-system-filepath" ,ghc-system-filepath)
+       ("ghc-temporary" ,ghc-temporary)))
     (home-page
      "https://www.yesodweb.com/book/persistent")
     (synopsis "Backend for the persistent library using sqlite3")
     (home-page
      "https://www.yesodweb.com/book/persistent")
     (synopsis "Backend for the persistent library using sqlite3")
@@ -8587,34 +8926,147 @@ system dependencies.")
 (define-public ghc-persistent-template
   (package
     (name "ghc-persistent-template")
 (define-public ghc-persistent-template
   (package
     (name "ghc-persistent-template")
-    (version "2.6.0")
+    (version "2.8.0")
     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "persistent-template-" version "/"
-                           "persistent-template-" version ".tar.gz"))
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent-template/"
+             "persistent-template-" version ".tar.gz"))
        (sha256
         (base32
        (sha256
         (base32
-         "0wr1z2nfrl6jv1lprxb0d2jw4izqfcbcwvkdrhryzg95gjz8ryjv"))))
+         "16yjrl0gh4jbs4skr7iv6a55lny59bqhd6hjmvch1cl9j5d0c0g3"))))
     (build-system haskell-build-system)
     (build-system haskell-build-system)
-    (inputs `(("ghc-persistent" ,ghc-persistent)
-              ("ghc-monad-control" ,ghc-monad-control)
-              ("ghc-aeson" ,ghc-aeson)
-              ("ghc-aeson-compat" ,ghc-aeson-compat)
-              ("ghc-monad-logger" ,ghc-monad-logger)
-              ("ghc-unordered-containers" ,ghc-unordered-containers)
-              ("ghc-tagged" ,ghc-tagged)
-              ("ghc-path-pieces" ,ghc-path-pieces)
-              ("ghc-http-api-data" ,ghc-http-api-data)))
-    (native-inputs `(("ghc-hspec" ,ghc-hspec)
-                     ("ghc-quickcheck" ,ghc-quickcheck)))
+    (inputs
+     `(("ghc-persistent" ,ghc-persistent)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-http-api-data" ,ghc-http-api-data)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-path-pieces" ,ghc-path-pieces)
+       ("ghc-th-lift-instances" ,ghc-th-lift-instances)
+       ("ghc-unordered-containers"
+        ,ghc-unordered-containers)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
     (home-page "https://www.yesodweb.com/book/persistent")
     (synopsis "Type-safe, non-relational, multi-backend persistence")
     (description "This Haskell package provides interfaces and helper
 functions for the ghc-persistent package.")
     (license license:expat)))
 
     (home-page "https://www.yesodweb.com/book/persistent")
     (synopsis "Type-safe, non-relational, multi-backend persistence")
     (description "This Haskell package provides interfaces and helper
 functions for the ghc-persistent package.")
     (license license:expat)))
 
+(define-public ghc-persistent-test
+  (package
+    (name "ghc-persistent-test")
+    (version "2.0.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent-test/"
+             "persistent-test-" version ".tar.gz"))
+       (sha256
+        (base32
+         "11aq5cy0n43jamf6mg4sr4300bc2zdbjxsczzxwjkb4hzs0ijsdv"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-blaze-html" ,ghc-blaze-html)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-path-pieces" ,ghc-path-pieces)
+       ("ghc-persistent" ,ghc-persistent)
+       ("ghc-persistent-template" ,ghc-persistent-template)
+       ("ghc-random" ,ghc-random)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-transformers-base" ,ghc-transformers-base)
+       ("ghc-unliftio" ,ghc-unliftio)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://www.yesodweb.com/book/persistent")
+    (synopsis "Tests for the Persistent database library")
+    (description
+     "This is only for use in developing libraries that should conform to
+the persistent interface, not for users of the persistent suite of database
+libraries.")
+    (license license:expat)))
+
+(define-public ghc-pipes
+  (package
+    (name "ghc-pipes")
+    (version "4.3.13")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/pipes/"
+             "pipes-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1ch3xr5f5if0psd3lsyrpkwrgh36synnzqcpimghprys68l4zfkn"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-mmorph" ,ghc-mmorph)
+       ("ghc-void" ,ghc-void)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2"
+        ,ghc-test-framework-quickcheck2)))
+    (home-page
+     "https://hackage.haskell.org/package/pipes")
+    (synopsis "Compositional pipelines")
+    (description
+     "A clean and powerful stream processing library that lets you build
+and connect reusable streaming components.  Advantages over traditional streaming
+libraries:
+@itemize
+@item Concise API: Use simple commands like @code{for}, (@code{>->}), @code{await},
+and @code{yield}
+@item Blazing fast: Implementation tuned for speed, including shortcut fusion
+@item Lightweight Dependency: pipes is small and compiles very rapidly, including
+dependencies
+@item Elegant semantics: Use practical category theory
+@item ListT: Correct implementation of @code{ListT} that interconverts with pipes
+@item Bidirectionality: Implement duplex channels
+@end itemize")
+    (license license:bsd-3)))
+
+(define-public ghc-pointedlist
+  (package
+    (name "ghc-pointedlist")
+    (version "0.6.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/pointedlist/"
+             "pointedlist-" version ".tar.gz"))
+       (sha256
+        (base32
+         "16xsrzqql7i4z6a3xy07sqnbyqdmcar1jiacla58y4mvkkwb0g3l"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://hackage.haskell.org/package/pointedlist")
+    (synopsis
+     "Zipper-like comonad which works as a list, tracking a position")
+    (description
+     "A PointedList tracks the position in a non-empty list which works
+similarly to a zipper.  A current item is always required, and therefore
+the list may never be empty.  A circular PointedList wraps around to the
+other end when progressing past the actual edge.")
+    (license license:bsd-3)))
+
 (define-public ghc-polyparse
   (package
     (name "ghc-polyparse")
 (define-public ghc-polyparse
   (package
     (name "ghc-polyparse")
@@ -8700,7 +9152,7 @@ reduce @code{UndecidableInstances}.")
         (base32
          "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5"))))
     (build-system haskell-build-system)
         (base32
          "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5"))))
     (build-system haskell-build-system)
-    (home-page "http://hackage.haskell.org/package/prettyclass")
+    (home-page "https://hackage.haskell.org/package/prettyclass")
     (synopsis "Pretty printing class similar to Show")
     (description "This package provides a pretty printing class similar
 to @code{Show}, based on the HughesPJ pretty printing library.  It
     (synopsis "Pretty printing class similar to Show")
     (description "This package provides a pretty printing class similar
 to @code{Show}, based on the HughesPJ pretty printing library.  It
@@ -8840,6 +9292,73 @@ API.")
     (description "This library provides profunctors for Haskell.")
     (license license:bsd-3)))
 
     (description "This library provides profunctors for Haskell.")
     (license license:bsd-3)))
 
+(define-public ghc-project-template
+  (package
+    (name "ghc-project-template")
+    (version "0.2.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/project-template/project-template-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1p69ww4rhah2qxragl615wl4a6mk4x9w09am8knmz3s4lxpljlpb"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-resourcet" ,ghc-resourcet)))
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (arguments
+     `(#:cabal-revision
+       ("1"
+        "0lq3sqnq0nr0gbvgzp0lqdl3j3mqdmdlf8xsw0j3pjh581xj3k0a")))
+    (home-page "https://github.com/fpco/haskell-ide")
+    (synopsis "Specify Haskell project templates and generate files")
+    (description
+     "Haskell library for both generating and consuming project templates.
+
+ost IDEs provide the concept of a project template: instead of writing all
+of the code for a project from scratch, you select a template, answer a few
+questions, and a bunch of files are automatically generated.
+
+project-template tries to provide a canonical Haskell library for implementing
+the ideal templating system.")
+    (license license:bsd-3)))
+
+(define-public ghc-protolude
+  (package
+    (name "ghc-protolude")
+    (version "0.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/protolude/protolude-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0zzkyxz0vmcbncpid7gp72fpjj0fla3gqhlfkij5c5lg12skjgfj"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-mtl-compat" ,ghc-mtl-compat)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)))
+    (home-page "https://github.com/protolude/protolude")
+    (synopsis "Sensible set of defaults for writing custom Preludes")
+    (description
+     "Protolude gives you sensible defaults for writing custom Preludes to
+replace the standard one provided by GHC.")
+    (license license:expat)))
+
 (define-public ghc-psqueues
   (package
     (name "ghc-psqueues")
 (define-public ghc-psqueues
   (package
     (name "ghc-psqueues")
@@ -8905,6 +9424,36 @@ Typical applications of Priority Search Queues include:
 @end itemize")
     (license license:bsd-3)))
 
 @end itemize")
     (license license:bsd-3)))
 
+(define-public ghc-pwstore-fast
+  (package
+    (name "ghc-pwstore-fast")
+    (version "2.4.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/pwstore-fast/"
+             "pwstore-fast-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1cpvlwzg3qznhygrr78f75p65mnljd9v5cvnagfxjqppnrkay6bj"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-cryptohash" ,ghc-cryptohash)
+       ("ghc-random" ,ghc-random)
+       ("ghc-byteable" ,ghc-byteable)))
+    (home-page "https://github.com/PeterScott/pwstore")
+    (synopsis "Secure password storage")
+    (description
+     "To store passwords securely, they should be salted, then hashed with
+a slow hash function.  This library uses PBKDF1-SHA256, and handles all the
+details.  It uses the cryptohash package for speed; if you need a pure
+Haskell library, pwstore-purehaskell has the exact same API, but uses only
+pure Haskell.  It is about 25 times slower than this package, but still quite
+usable.")
+    (license license:bsd-3)))
+
 (define-public ghc-random
   (package
     (name "ghc-random")
 (define-public ghc-random
   (package
     (name "ghc-random")
@@ -9067,7 +9616,7 @@ containers and a general map/reduce framework for Haskell.")
         (base32
          "0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
     (build-system haskell-build-system)
         (base32
          "0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
     (build-system haskell-build-system)
-    (home-page "http://hackage.haskell.org/package/refact")
+    (home-page "https://hackage.haskell.org/package/refact")
     (synopsis "Specify refactorings to perform with apply-refact")
     (description
      "This library provides a datatype which can be interpreted by
     (synopsis "Specify refactorings to perform with apply-refact")
     (description
      "This library provides a datatype which can be interpreted by
@@ -9309,7 +9858,7 @@ Haskell library @code{regex-base}.")
     (build-system haskell-build-system)
     (inputs
      `(("ghc-regex-base" ,ghc-regex-base)))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-regex-base" ,ghc-regex-base)))
-    (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
+    (home-page "https://github.com/haskell-hvr/regex-tdfa")
     (synopsis "POSIX extended regular expressions in Haskell.")
     (description
      "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
     (synopsis "POSIX extended regular expressions in Haskell.")
     (description
      "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
@@ -9335,7 +9884,7 @@ inspired by libtre.")
      `(("ghc-regex-base" ,ghc-regex-base)
        ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
     (home-page
      `(("ghc-regex-base" ,ghc-regex-base)
        ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
     (home-page
-     "http://hackage.haskell.org/package/regex-tdfa-text")
+     "https://hackage.haskell.org/package/regex-tdfa-text")
     (synopsis "Text interface for regex-tdfa")
     (description
      "This provides an extra text interface for regex-tdfa.")
     (synopsis "Text interface for regex-tdfa")
     (description
      "This provides an extra text interface for regex-tdfa.")
@@ -9821,7 +10370,7 @@ award winning Linux port of \"Civilization: Call To Power.\"")
     (native-inputs
      `(("ghc-weigh" ,ghc-weigh)
        ("pkg-config" ,pkg-config)))
     (native-inputs
      `(("ghc-weigh" ,ghc-weigh)
        ("pkg-config" ,pkg-config)))
-    (home-page "http://hackage.haskell.org/package/sdl2")
+    (home-page "https://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
     (synopsis "High- and low-level bindings to the SDL library")
     (description
      "This package contains bindings to the SDL 2 library, in both high- and
@@ -9852,7 +10401,7 @@ programming.")
        ("sdl2-image" ,sdl2-image)))
     (native-inputs
      `(("pkg-config" ,pkg-config)))
        ("sdl2-image" ,sdl2-image)))
     (native-inputs
      `(("pkg-config" ,pkg-config)))
-    (home-page "http://hackage.haskell.org/package/sdl2-image")
+    (home-page "https://hackage.haskell.org/package/sdl2-image")
     (synopsis "Bindings to SDL2_image")
     (description "This package provides Haskell bindings to
 @code{SDL2_image}.")
     (synopsis "Bindings to SDL2_image")
     (description "This package provides Haskell bindings to
 @code{SDL2_image}.")
@@ -9880,7 +10429,7 @@ programming.")
        ("sdl2-mixer" ,sdl2-mixer)))
     (native-inputs
      `(("pkg-config" ,pkg-config)))
        ("sdl2-mixer" ,sdl2-mixer)))
     (native-inputs
      `(("pkg-config" ,pkg-config)))
-    (home-page "http://hackage.haskell.org/package/sdl2-mixer")
+    (home-page "https://hackage.haskell.org/package/sdl2-mixer")
     (synopsis "Bindings to SDL2 mixer")
     (description "This package provides Haskell bindings to
 @code{SDL2_mixer}.")
     (synopsis "Bindings to SDL2 mixer")
     (description "This package provides Haskell bindings to
 @code{SDL2_mixer}.")
@@ -9970,6 +10519,46 @@ Haskell")
 a memory chunk that will be auto-scrubbed after it run out of scope.")
     (license license:bsd-3)))
 
 a memory chunk that will be auto-scrubbed after it run out of scope.")
     (license license:bsd-3)))
 
+(define-public ghc-semialign
+  (package
+    (name "ghc-semialign")
+    (version "1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/semialign/semialign-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "004x0a80sqqdgvsyk4z0nasxpi6z3g1d8kgwj804bj9ka8dlc75m"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-these" ,ghc-these)
+       ("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)))
+    (arguments
+     `(#:cabal-revision
+       ("1"
+        "0qnqnyfng4kwy2h2anrcy5id2ijnawava3zcc5h5b8ri1y6ks6zi")))
+    (home-page
+     "https://github.com/isomorphism/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
+generalized notion of \"zipping with padding\" that combines
+structures without truncating to the size of the smaller input.  It
+turns out that @code{zip} operation fits well the @code{Semialign}
+class, forming lattice-like structure.")
+    (license license:bsd-3)))
+
 (define-public ghc-semigroupoids
   (package
     (name "ghc-semigroupoids")
 (define-public ghc-semigroupoids
   (package
     (name "ghc-semigroupoids")
@@ -10344,7 +10933,7 @@ provided.  Skylighting is intended to be the successor to highlighting-kate.")
     (home-page
      "https://github.com/feuerbach/smallcheck")
     (synopsis "Property-based testing library")
     (home-page
      "https://github.com/feuerbach/smallcheck")
     (synopsis "Property-based testing library")
-    (description "SmallCheck is a testing library that allows to verify
+    (description "SmallCheck is a testing library that verifies
 properties for all test cases up to some depth.  The test cases are generated
 automatically by SmallCheck.")
     (license license:bsd-3)))
 properties for all test cases up to some depth.  The test cases are generated
 automatically by SmallCheck.")
     (license license:bsd-3)))
@@ -10384,7 +10973,7 @@ automatically by SmallCheck.")
         (base32
          "07ci2mh8cbjvipb576rxsj3iyhkj5c5dnsns4xkdppp2p3pv10d3"))))
     (build-system haskell-build-system)
         (base32
          "07ci2mh8cbjvipb576rxsj3iyhkj5c5dnsns4xkdppp2p3pv10d3"))))
     (build-system haskell-build-system)
-    (home-page "http://hackage.haskell.org/package/sop-core")
+    (home-page "https://hackage.haskell.org/package/sop-core")
     (synopsis "True Sums of Products")
     (description "This package provides an implementation of
 @math{n}-ary sums and @math{n}-ary products.  The module @code{Data.SOP}
     (synopsis "True Sums of Products")
     (description "This package provides an implementation of
 @math{n}-ary sums and @math{n}-ary products.  The module @code{Data.SOP}
@@ -10443,7 +11032,7 @@ mainstream languages.")
        ("ghc-base-compat-batteries" ,ghc-base-compat-batteries)
        ("ghc-tf-random" ,ghc-tf-random)
        ("ghc-vector" ,ghc-vector)))
        ("ghc-base-compat-batteries" ,ghc-base-compat-batteries)
        ("ghc-tf-random" ,ghc-tf-random)
        ("ghc-vector" ,ghc-vector)))
-    (home-page "http://hackage.haskell.org/package/splitmix")
+    (home-page "https://hackage.haskell.org/package/splitmix")
     (synopsis "Fast and splittable pseudorandom number generator")
     (description "This package provides a Pure Haskell implementation of the
 SplitMix pseudorandom number generator.  SplitMix is a \"splittable\"
     (synopsis "Fast and splittable pseudorandom number generator")
     (description "This package provides a Pure Haskell implementation of the
 SplitMix pseudorandom number generator.  SplitMix is a \"splittable\"
@@ -10838,7 +11427,7 @@ literals.")
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)))
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-hunit" ,ghc-hunit)))
-    (home-page "http://hackage.haskell.org/package/string-qq")
+    (home-page "https://hackage.haskell.org/package/string-qq")
     (synopsis
      "QuasiQuoter for non-interpolated strings, texts and bytestrings.")
     (description
     (synopsis
      "QuasiQuoter for non-interpolated strings, texts and bytestrings.")
     (description
@@ -10872,70 +11461,6 @@ functions for breaking or splitting on substrings and replacing all
 occurrences of a substring (the first in case of overlaps) with another.")
     (license license:bsd-3)))
 
 occurrences of a substring (the first in case of overlaps) with another.")
     (license license:bsd-3)))
 
-(define-public ghc-stylish-haskell
-  (package
-    (name "ghc-stylish-haskell")
-    (version "0.9.2.1")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "mirror://hackage/package/stylish-haskell/stylish-haskell-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32
-            "1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w"))))
-    (build-system haskell-build-system)
-    (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (add-before 'configure 'update-constraints
-           (lambda _
-             (substitute* "stylish-haskell.cabal"
-               (("haskell-src-exts >= 1\\.18   && < 1\\.21,")
-                "haskell-src-exts >= 1.18   && < 1.22,"))
-             #t)))))
-    (inputs
-      `(("ghc-aeson" ,ghc-aeson)
-        ("ghc-file-embed" ,ghc-file-embed)
-        ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
-        ("ghc-semigroups" ,ghc-semigroups)
-        ("ghc-syb" ,ghc-syb)
-        ("ghc-yaml" ,ghc-yaml)
-        ("ghc-strict" ,ghc-strict)
-        ("ghc-optparse-applicative"
-         ,ghc-optparse-applicative)))
-    (native-inputs
-      `(("ghc-hunit" ,ghc-hunit)
-        ("ghc-test-framework" ,ghc-test-framework)
-        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
-    (home-page "https://github.com/jaspervdj/stylish-haskell")
-    (synopsis "Haskell code prettifier")
-    (description "Stylish-haskell is a Haskell code prettifier.  The goal is
-not to format all of the code in a file, to avoid \"getting in the way\".
-However, this tool can e.g. clean up import statements and help doing various
-tasks that get tedious very quickly.  It can
-@itemize
-@item
-Align and sort @code{import} statements
-@item
-Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant
-pragmas
-@item
-Remove trailing whitespaces
-@item
-Align branches in @code{case} and fields in records
-@item
-Convert line endings (customisable)
-@item
-Replace tabs by four spaces (turned off by default)
-@item
-Replace some ASCII sequences by their Unicode equivalent (turned off by
-default)
-@end itemize")
-    (license license:bsd-3)))
-
 (define-public ghc-svg-builder
   (package
     (name "ghc-svg-builder")
 (define-public ghc-svg-builder
   (package
     (name "ghc-svg-builder")
@@ -11515,6 +12040,63 @@ and @code{Eq} instances.  These instances used to live in the haskell-src-meta
 package, and that's where the version number started.")
     (license license:bsd-3)))
 
 package, and that's where the version number started.")
     (license license:bsd-3)))
 
+(define-public ghc-these
+  (package
+    (name "ghc-these")
+    (version "1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/these/these-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1k0pi65g7cm9hzdw6my6bzz2zvddkmj1qs45ymqmi316bpiixk3r"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-assoc" ,ghc-assoc)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (arguments
+     `(#:cabal-revision
+       ("1"
+        "0923r86fnmgpx0msm68aszirh2n19nn5bccgjxfh2146jw4z7w3z")))
+    (home-page
+     "https://github.com/isomorphism/these")
+    (synopsis "Either-or-both data type")
+    (description
+     "This package provides a data type @code{These a b} which can
+hold a value of either type or values of each type.  This is usually
+thought of as an \"inclusive or\" type (contrasting @code{Either a b} as
+\"exclusive or\") or as an \"outer join\" type (contrasting @code{(a, b)}
+as \"inner join\").
+
+@code{data These a b = This a | That b | These a b}
+
+Since version 1, this package was split into parts:
+
+@itemize
+@item
+https://hackage.haskell.org/package/semialign For @code{Align} and
+@code{Zip} type-classes.
+@item
+https://hackage.haskell.org/package/semialign-indexed For
+@code{SemialignWithIndex} class, providing @code{ialignWith} and
+@code{izipWith}
+@item
+https://hackage.haskell.org/package/these-lens For lens combinators.
+@item
+http://hackage.haskell.org/package/monad-chronicle For transformers
+variant of @code{These}.
+@end itemize")
+    (license license:bsd-3)))
+
 (define-public ghc-threads
   (package
     (name "ghc-threads")
 (define-public ghc-threads
   (package
     (name "ghc-threads")
@@ -11605,7 +12187,7 @@ function which generates instances.")
        ("1" "0k8ph4sydaiqp8dav4if6hpiaq8h1xsr93khmdr7a1mmfwdxr64r")))
     (home-page "https://github.com/phadej/time-compat")
     (synopsis "Compatibility package for time")
        ("1" "0k8ph4sydaiqp8dav4if6hpiaq8h1xsr93khmdr7a1mmfwdxr64r")))
     (home-page "https://github.com/phadej/time-compat")
     (synopsis "Compatibility package for time")
-    (description "This packages tries to compat as many @code{time}
+    (description "This package tries to compat as many @code{time}
 features as possible.")
     (license license:bsd-3)))
 
 features as possible.")
     (license license:bsd-3)))
 
@@ -11755,6 +12337,45 @@ from a shell.  The @code{tldr} pages are a community effort to simplify the
 man pages with practical examples.")
     (license license:bsd-3)))
 
 man pages with practical examples.")
     (license license:bsd-3)))
 
+(define-public ghc-transformers
+  (package
+    (name "ghc-transformers")
+    (version "0.5.6.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/transformers/transformers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0v66j5k0xqk51pmca55wq192qyw2p43s2mgxlz4f95q2c1fpjs5n"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://hackage.haskell.org/package/transformers")
+    (synopsis "Concrete functor and monad transformers")
+    (description
+     "Transformers provides functor and monad transformers, inspired by the
+paper \"Functional Programming with Overloading and Higher-Order
+Polymorphism\", by Mark P Jones, in Advanced School of Functional Programming,
+1995 @url{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html}.
+
+This package contains:
+@itemize
+@item the monad transformer class (in @code{Control.Monad.Trans.Class})
+@item concrete functor and monad transformers, each with associated operations
+and functions to lift operations associated with other transformers.
+@end itemize
+
+This package can be used on its own in portable Haskell code, in which case
+operations need to be manually lifted through transformer stacks (see
+@code{Control.Monad.Trans.Class} for some examples).  Alternatively, it can be
+used with the non-portable monad classes in the mtl or monads-tf packages,
+which automatically lift operations introduced by monad transformers through
+other transformers.")
+    (license license:bsd-3)))
+
 (define-public ghc-transformers-base
   (package
     (name "ghc-transformers-base")
 (define-public ghc-transformers-base
   (package
     (name "ghc-transformers-base")
@@ -11967,7 +12588,7 @@ upon it.")
        #:cabal-revision
        ("1"
         "09pqi867wskwgc5lpn197f895mbn1174ydgllvcppcsmrz2b6yr6")))
        #:cabal-revision
        ("1"
         "09pqi867wskwgc5lpn197f895mbn1174ydgllvcppcsmrz2b6yr6")))
-    (home-page "http://hackage.haskell.org/package/unagi-chan")
+    (home-page "https://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
     (synopsis "Fast concurrent queues with a Chan-like API, and more")
     (description
      "This library provides implementations of concurrent FIFO queues (for
@@ -12299,6 +12920,31 @@ a style ready for qualification, that is, you should import them by
 parser that uses ByteStrings for parsing and representing the URI data.")
     (license license:bsd-3)))
 
 parser that uses ByteStrings for parsing and representing the URI data.")
     (license license:bsd-3)))
 
+(define-public ghc-utf8-light
+  (package
+    (name "ghc-utf8-light")
+    (version "0.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "mirror://hackage/package/utf8-light/utf8-light-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q"))))
+    (build-system haskell-build-system)
+    (home-page
+     "http://hackage.haskell.org/package/utf8-light")
+    (synopsis "Lightweight unicode support for Haskell")
+    (description
+     "This package profides a class for encoding and decoding UTF8 strings
+with instances for several common types.  It also includes several functions
+for working with UTF8.  It aims to be lightweight, depending only on Base and
+including only one module.")
+    (license license:bsd-3)))
+
 (define-public ghc-utf8-string
   (package
     (name "ghc-utf8-string")
 (define-public ghc-utf8-string
   (package
     (name "ghc-utf8-string")
@@ -12978,7 +13624,7 @@ parts.")
         (base32
          "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
     (build-system haskell-build-system)
         (base32
          "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
     (build-system haskell-build-system)
-    (home-page "http://code.galois.com")
+    (home-page "https://github.com/GaloisInc/xml")
     (synopsis "Simple XML library for Haskell")
     (description "This package provides a simple XML library for Haskell.")
     (license license:bsd-3)))
     (synopsis "Simple XML library for Haskell")
     (description "This package provides a simple XML library for Haskell.")
     (license license:bsd-3)))