gnu: hyperestraier: Use HTTPS home page.

[jackhill/guix/guix.git] / gnu / packages / haskell-xyz.scm

diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index d68428a..418eb7c 100644 (file)
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -22,6 +22,9 @@
 ;;; 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>

 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;


@@ -53,6 +56,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)


@@ -129,6 +133,36 @@ of @code{Par} functionality.  See the @code{Control.Monad.Par.Class}
 module for more details.")
     (license license:bsd-3)))
 
 module for more details.")
     (license license:bsd-3)))
 

+(define-public ghc-active
+  (package
+    (name "ghc-active")
+    (version "0.2.0.14")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "active/active-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0x3b4ln6csa554qls28wbxvclkbdz3yi60i1m0q5ing0cs16fifz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-linear" ,ghc-linear)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://hackage.haskell.org/package/active")
+    (synopsis "Abstractions for animation")
+    (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/,
+diagrams framework}.")
+    (license license:bsd-3)))
+

 (define-public ghc-adjunctions
   (package
     (name "ghc-adjunctions")
 (define-public ghc-adjunctions
   (package
     (name "ghc-adjunctions")


@@ -756,7 +790,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


@@ -2766,7 +2800,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.")


@@ -2804,6 +2838,157 @@ related modules split from the statistics library.")
 and parsers with useful semantics.")
     (license license:bsd-3)))
 
 and parsers with useful semantics.")
     (license license:bsd-3)))
 

+(define-public ghc-diagrams-core
+  (package
+    (name "ghc-diagrams-core")
+    (version "1.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "diagrams-core/diagrams-core-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0qgb43vy23g4fxh3nmxfq6jyp34imqvkhgflaa6rz0iq6d60gl43"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-monoid-extras" ,ghc-monoid-extras)
+       ("ghc-dual-tree" ,ghc-dual-tree)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-linear" ,ghc-linear)
+       ("ghc-adjunctions" ,ghc-adjunctions)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-profunctors" ,ghc-profunctors)))
+    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+    (synopsis "Core libraries for diagrams embedded domain-specific language")
+    (description "This package provides the core modules underlying
+diagrams, an embedded domain-specific language for compositional,
+declarative drawing.")
+    (license license:bsd-3)))
+
+(define-public ghc-diagrams-lib
+  (package
+    (name "ghc-diagrams-lib")
+    (version "1.4.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "diagrams-lib/diagrams-lib-" version ".tar.gz"))
+       (sha256
+        (base32
+         "175yzi5kw4yd8ykdkpf64q85c7j3p89l90m3h6qcsx9ipv6av9r5"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-monoid-extras" ,ghc-monoid-extras)
+       ("ghc-dual-tree" ,ghc-dual-tree)
+       ("ghc-diagrams-core" ,ghc-diagrams-core)
+       ("ghc-diagrams-solve" ,ghc-diagrams-solve)
+       ("ghc-active" ,ghc-active)
+       ("ghc-colour" ,ghc-colour)
+       ("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-fingertree" ,ghc-fingertree)
+       ("ghc-intervals" ,ghc-intervals)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-juicypixels" ,ghc-juicypixels)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-linear" ,ghc-linear)
+       ("ghc-adjunctions" ,ghc-adjunctions)
+       ("ghc-distributive" ,ghc-distributive)
+       ("ghc-fsnotify" ,ghc-fsnotify)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-profunctors" ,ghc-profunctors)
+       ("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-cereal" ,ghc-cereal)))
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-numeric-extras" ,ghc-numeric-extras)))
+    (arguments
+     `(#:cabal-revision
+       ("3" "157y2qdsh0aczs81vzlm377mks976mpv6y3aqnchwsnr7apzp8ai")))
+    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+    (synopsis "Embedded domain-specific language for declarative graphics")
+    (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
+primitives and operations for creating diagrams.")
+    (license license:bsd-3)))
+
+(define-public ghc-diagrams-solve
+  (package
+    (name "ghc-diagrams-solve")
+    (version "0.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "diagrams-solve/diagrams-solve-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "17agchqkmj14b17sw50kzxq4hm056g5d8yy0wnqn5w8h1d0my7x4"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (arguments
+     `(#:cabal-revision
+       ("5" "1yl8cs05fzqcz49p601am1ij66m9pa70yamhfxgcvya2pf8nimlf")))
+    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+    (synopsis "Pure Haskell solver routines used by diagrams")
+    (description "This library provides Pure Haskell solver routines for
+use by the
+@url{https://archives.haskell.org/projects.haskell.org/diagrams/,
+diagrams framework}.  It currently includes routines for finding real
+roots of low-degree (@math{n < 5}) polynomials, and solving tridiagonal
+and cyclic tridiagonal linear systems.")
+    (license license:bsd-3)))
+
+(define-public ghc-diagrams-svg
+  (package
+    (name "ghc-diagrams-svg")
+    (version "1.4.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "diagrams-svg/diagrams-svg-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1lnyxx45yawqas7hmvvannwaa3ycf1l9g40lsl2m8sl2ja6vcmal"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-colour" ,ghc-colour)
+       ("ghc-diagrams-core" ,ghc-diagrams-core)
+       ("ghc-diagrams-lib" ,ghc-diagrams-lib)
+       ("ghc-monoid-extras" ,ghc-monoid-extras)
+       ("ghc-svg-builder" ,ghc-svg-builder)
+       ("ghc-juicypixels" ,ghc-juicypixels)
+       ("ghc-split" ,ghc-split)
+       ("ghc-lens" ,ghc-lens)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (arguments
+     `(#:cabal-revision
+       ("2" "15sn85xaachw4cj56w61bjcwrbf4qmnkfl8mbgdapxi5k0y4f2qv")))
+    (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+    (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
+language (EDSL) to Scalable Vector Graphics (SVG) files.")
+    (license license:bsd-3)))
+

 (define-public ghc-dictionary-sharing
   (package
     (name "ghc-dictionary-sharing")
 (define-public ghc-dictionary-sharing
   (package
     (name "ghc-dictionary-sharing")


@@ -3017,6 +3202,35 @@ It is modeled after doctest for Python, see
 between double precision floating point and text.")
     (license license:bsd-3)))
 
 between double precision floating point and text.")
     (license license:bsd-3)))
 

+(define-public ghc-dual-tree
+  (package
+    (name "ghc-dual-tree")
+    (version "0.2.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "dual-tree/dual-tree-" version ".tar.gz"))
+       (sha256
+        (base32
+         "17kdfnf0df0z5pkiifxrlmyd1xd7hjjaazd2kzyajl0gd00vbszx"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-newtype-generics" ,ghc-newtype-generics)
+       ("ghc-monoid-extras" ,ghc-monoid-extras)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-testing-feat" ,ghc-testing-feat)))
+    (home-page "https://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.
+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/,
+diagrams framework}, but potentially has other applications as well.")
+    (license license:bsd-3)))
+

 (define-public ghc-easy-file
   (package
     (name "ghc-easy-file")
 (define-public ghc-easy-file
   (package
     (name "ghc-easy-file")


@@ -3363,7 +3577,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}.


@@ -3479,7 +3693,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


@@ -3560,7 +3774,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.7.1")

     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)


@@ -3570,12 +3784,13 @@ versions of GHC (i.e., < 6.10).")
              ".tar.gz"))
        (sha256
         (base32
              ".tar.gz"))
        (sha256
         (base32

-         "0jvd4l0hi8pf5899pxc32yc638y0mrc357w0rph99k3hm277i0cy"))))
+         "0zshxv9dnd8vksncmb8dj4wvq2wdybzwxyhmy2zp6a81icm4azx4"))))

     (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


@@ -3788,6 +4003,29 @@ directories.  It includes code for pattern matching, finding files, modifying
 file contents, and more.")
     (license license:bsd-3)))
 
 file contents, and more.")
     (license license:bsd-3)))
 

+(define-public ghc-filepath-bytestring
+  (package
+    (name "ghc-filepath-bytestring")
+    (version "1.4.2.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+              "https://hackage.haskell.org/package/filepath-bytestring/"
+              "filepath-bytestring-" version ".tar.gz"))
+       (sha256
+        (base32
+         "06shdskjj391hb9295slm9gg2rbn5fdq5v6fg0mgn3yl5dv8q5dx"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (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
+@code{FilePath} values to get the speed benefits of using @code{ByteStrings}.")
+    (license license:bsd-3)))
+

 (define-public ghc-findbin
   (package
     (name "ghc-findbin")
 (define-public ghc-findbin
   (package
     (name "ghc-findbin")


@@ -3930,6 +4168,16 @@ and are often as efficient as hand-written folds.")
         (base32
          "0q6kx57ygmznlpf8n499hid4x6mj3180paijx0a8dgi9hh7man61"))))
     (build-system haskell-build-system)
         (base32
          "0q6kx57ygmznlpf8n499hid4x6mj3180paijx0a8dgi9hh7man61"))))
     (build-system haskell-build-system)

+    (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)))))

     (inputs `(("ghc-basement" ,ghc-basement)))
     (home-page "https://github.com/haskell-foundation/foundation")
     (synopsis "Alternative prelude with batteries and no dependencies")
     (inputs `(("ghc-basement" ,ghc-basement)))
     (home-page "https://github.com/haskell-foundation/foundation")
     (synopsis "Alternative prelude with batteries and no dependencies")


@@ -4379,6 +4627,25 @@ and edge labels with positional information, etc.
 @end enumerate\n")
     (license license:bsd-3)))
 
 @end enumerate\n")
     (license license:bsd-3)))
 

+(define-public ghc-groups
+  (package
+    (name "ghc-groups")
+    (version "0.4.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (string-append "https://hackage.haskell.org/package/"
+                            "groups/groups-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0ggkygkyxw5ga4cza82bjvdraavl294k0h6b62d2px7z3nvqhifx"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/groups")
+    (synopsis "Haskell 98 groups")
+    (description "This package provides Haskell 98 groups.  A group is a
+monoid with invertibility.")
+    (license license:bsd-3)))
+

 (define-public ghc-gtk2hs-buildtools
   (package
     (name "ghc-gtk2hs-buildtools")
 (define-public ghc-gtk2hs-buildtools
   (package
     (name "ghc-gtk2hs-buildtools")


@@ -4460,7 +4727,7 @@ Tor project}.")
 (define-public ghc-haddock
   (package
     (name "ghc-haddock")
 (define-public ghc-haddock
   (package
     (name "ghc-haddock")

-    (version "2.19.0.1")
+    (version "2.22.0")

     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)


@@ -4470,16 +4737,15 @@ Tor project}.")
              ".tar.gz"))
        (sha256
         (base32
              ".tar.gz"))
        (sha256
         (base32

-         "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7"))))
+         "1k42z2zh550rl93c8pa9cg2xsanp6wvb031xvan6cmngnplmdib6"))))

     (build-system haskell-build-system)
     (arguments
      `(#:phases
        (modify-phases %standard-phases
     (build-system haskell-build-system)
     (arguments
      `(#:phases
        (modify-phases %standard-phases

-         ;; There are four test suites that require the ghc-haddock-test
-         ;; package, which no longer builds with GHC 8.4.3.  This phase
-         ;; removes these four test suites from the Cabal file, so that we
-         ;; do not need ghc-haddock-test as an input.
-         (add-before 'configure 'remove-haddock-test-test-suites
+         ;; The release tarball for 2.22.0 is missing the test data for
+         ;; the Hoogle test, causing it to fail.  This is fixed in the
+         ;; next release, but for now we disable it.
+         (add-before 'configure 'remove-hoogle-test

            (lambda _
              (use-modules (ice-9 rdelim))
              (with-atomic-file-replacement "haddock.cabal"
            (lambda _
              (use-modules (ice-9 rdelim))
              (with-atomic-file-replacement "haddock.cabal"


@@ -4490,17 +4756,20 @@ Tor project}.")
                     ((string-every char-set:whitespace line)
                      (unless deleting? (display line out))
                      (loop (read-line in 'concat) #f))
                     ((string-every char-set:whitespace line)
                      (unless deleting? (display line out))
                      (loop (read-line in 'concat) #f))

-                    ((member line '("test-suite html-test\n"
-                                    "test-suite hypsrc-test\n"
-                                    "test-suite latex-test\n"
-                                    "test-suite hoogle-test\n"))
+                    ((string=? line "test-suite hoogle-test\n")

                      (loop (read-line in 'concat) #t))
                     (else
                      (unless deleting? (display line out))
                      (loop (read-line in 'concat) #t))
                     (else
                      (unless deleting? (display line out))

-                     (loop (read-line in 'concat) deleting?)))))))))))
+                     (loop (read-line in 'concat) deleting?))))))))
+         (add-before 'check 'add-haddock-to-path
+           (lambda _
+             (setenv "PATH" (string-append (getcwd) "/dist/build/haddock"
+                                           ":" (getenv "PATH")))
+             #t)))))

     (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
     (native-inputs
     (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
     (native-inputs

-     `(("ghc-hspec" ,ghc-hspec)))
+     `(("ghc-haddock-test" ,ghc-haddock-test)
+       ("ghc-hspec" ,ghc-hspec)))

     (home-page "https://www.haskell.org/haddock/")
     (synopsis
      "Documentation-generation tool for Haskell libraries")
     (home-page "https://www.haskell.org/haddock/")
     (synopsis
      "Documentation-generation tool for Haskell libraries")


@@ -4511,7 +4780,7 @@ Tor project}.")
 (define-public ghc-haddock-api
   (package
     (name "ghc-haddock-api")
 (define-public ghc-haddock-api
   (package
     (name "ghc-haddock-api")

-    (version "2.19.0.1")
+    (version "2.22.0")

     (source
      (origin
        (method url-fetch)
     (source
      (origin
        (method url-fetch)


@@ -4519,9 +4788,10 @@ Tor project}.")
              "https://hackage.haskell.org/package/haddock-api/haddock-api-"
              version
              ".tar.gz"))
              "https://hackage.haskell.org/package/haddock-api/haddock-api-"
              version
              ".tar.gz"))

+       (patches (search-patches "ghc-haddock-api-fix-haddock.patch"))

        (sha256
         (base32
        (sha256
         (base32

-         "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3"))))
+         "149q4zlf4m7wcrr4af2n2flh0jxjsypshbc229vsj1m0kmz4z014"))))

     (build-system haskell-build-system)
     (arguments
      `(#:phases
     (build-system haskell-build-system)
     (arguments
      `(#:phases


@@ -4529,10 +4799,10 @@ Tor project}.")
          (add-before 'configure 'update-constraints
            (lambda _
              (substitute* "haddock-api.cabal"
          (add-before 'configure 'update-constraints
            (lambda _
              (substitute* "haddock-api.cabal"

-               (("Cabal           \\^>= 2\\.0\\.0")
-                "Cabal           ^>= 2.2.0")
-               (("hspec           \\^>= 2\\.4\\.4")
-                "hspec            >= 2.4.4 && < 2.6")))))))
+               (("QuickCheck      \\^>= 2\\.11")
+                "QuickCheck      ^>= 2.13")
+               (("hspec           >= 2\\.4\\.4 && < 2\\.6")
+                "hspec           >= 2.4.4 && < 2.8")))))))

     (inputs
      `(("ghc-paths" ,ghc-paths)
        ("ghc-haddock-library" ,ghc-haddock-library)))
     (inputs
      `(("ghc-paths" ,ghc-paths)
        ("ghc-haddock-library" ,ghc-haddock-library)))


@@ -4589,6 +4859,39 @@ project if you can't release often.  For interacting with Haddock itself, see
 the ‘haddock’ package.")
     (license license:bsd-3)))
 
 the ‘haddock’ package.")
     (license license:bsd-3)))
 

+;; This package is needed for testing 'ghc-haddock'.  It is no longer
+;; published to Hackage, but it is maintained in the Haddock Git
+;; repository.
+(define ghc-haddock-test
+  (package
+    (name "ghc-haddock-test")
+    (version "2.22.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/haskell/haddock.git")
+             (commit (string-append "haddock-" version "-release"))))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "1ywxmqqan10gs0ppybdmdgsmvkzkpw7yirj2rw4qylg3x49a9zca"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'change-directory
+           (lambda _
+             (chdir "haddock-test"))))))
+    (inputs
+     `(("ghc-syb" ,ghc-syb)
+       ("ghc-xml" ,ghc-xml)))
+    (home-page "http://www.haskell.org/haddock/")
+    (synopsis "Test utilities for Haddock")
+    (description "This package provides test utilities for Haddock.")
+    (license license:bsd-3)
+    (properties '((hidden? #t)))))
+

 (define-public ghc-half
   (package
     (name "ghc-half")
 (define-public ghc-half
   (package
     (name "ghc-half")


@@ -4709,7 +5012,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


@@ -4754,7 +5057,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.")


@@ -5490,7 +5793,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


@@ -5543,7 +5846,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.")


@@ -5574,7 +5877,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


@@ -5706,6 +6009,35 @@ search for all keys containing a point or overlapping an interval.  See the
 example code on the home page for a quick introduction.")
     (license license:bsd-3)))
 
 example code on the home page for a quick introduction.")
     (license license:bsd-3)))
 

+(define-public ghc-intervals
+  (package
+    (name "ghc-intervals")
+    (version "0.8.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "intervals/intervals-" version ".tar.gz"))
+       (sha256
+        (base32
+         "00vyxf3ba9d7aas3npfapr53w71fslgh69fczjb25axr66fvzqww"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-distributive" ,ghc-distributive)))
+    (native-inputs
+     `(("cabal-doctest" ,cabal-doctest)
+       ("ghc-doctest" ,ghc-doctest)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (arguments
+     `(#:cabal-revision
+       ("4" "1qx3q0v13l1zaln9zdk8chxpxhshbz5x0vqm0qda7d1kpv7h6a7r")))
+    (home-page "https://github.com/ekmett/intervals")
+    (synopsis "Interval arithmetic")
+    (description "This library provides
+@code{Numeric.Interval.Interval}, which represets a closed, convex set
+of floating point values.")
+    (license license:bsd-3)))
+

 (define-public ghc-invariant
   (package
     (name "ghc-invariant")
 (define-public ghc-invariant
   (package
     (name "ghc-invariant")


@@ -5769,7 +6101,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.")


@@ -6010,7 +6342,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.")


@@ -6114,7 +6446,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


@@ -6376,6 +6708,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")


@@ -6502,7 +6900,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.


@@ -6866,7 +7264,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


@@ -7166,6 +7564,34 @@ you are used to, it adds on an IsSequence typeclass and has code for marking
 data structures as non-empty.")
     (license license:expat)))
 
 data structures as non-empty.")
     (license license:expat)))
 

+(define-public ghc-monoid-extras
+  (package
+    (name "ghc-monoid-extras")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monoid-extras/monoid-extras-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0xfrkgqn9d31z54l617m3w3kkd5m9vjb4yl247r3zzql3mpb1f37"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-groups" ,ghc-groups)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)))
+    (arguments
+     `(#:cabal-revision
+       ("1" "0b8x5d6vh7mpigvjvcd8f38a1nyzn1vfdqypslw7z9fgsr742913")))
+    (home-page "https://hackage.haskell.org/package/monoid-extras")
+    (synopsis "Various extra monoid-related definitions and utilities")
+    (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.")
+    (license license:bsd-3)))
+

 (define-public ghc-murmur-hash
   (package
     (name "ghc-murmur-hash")
 (define-public ghc-murmur-hash
   (package
     (name "ghc-murmur-hash")


@@ -7361,7 +7787,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.")


@@ -7472,6 +7898,26 @@ 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-numeric-extras
+  (package
+    (name "ghc-numeric-extras")
+    (version "0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "numeric-extras/numeric-extras-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1mk11c0gz1yjy5b8dvq6czfny57pln0bs7x28fz38qyr44872067"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/ekmett/numeric-extras")
+    (synopsis "Useful tools from the C standard library")
+    (description "This library provides some useful tools from the C
+standard library.")
+    (license license:bsd-3)))
+

 (define-public ghc-objectname
   (package
     (name "ghc-objectname")
 (define-public ghc-objectname
   (package
     (name "ghc-objectname")


@@ -7721,6 +8167,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")


@@ -8015,7 +8569,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.")


@@ -8240,6 +8794,74 @@ system dependencies.")
 functions for the ghc-persistent package.")
     (license license:expat)))
 
 functions for the ghc-persistent package.")
     (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")


@@ -8325,7 +8947,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


@@ -8692,7 +9314,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


@@ -8960,7 +9582,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.")


@@ -9315,6 +9937,40 @@ are not exception safe and can be broken by @code{killThread}.")
     (description "Reasonably fast data encoding library.")
     (license license:bsd-3)))
 
     (description "Reasonably fast data encoding library.")
     (license license:bsd-3)))
 

+(define-public ghc-say
+  (package
+    (name "ghc-say")
+    (version "0.1.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/say/say-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1r5kffjfwpas45g74sip8glrj1m9nygrnxjm7xgw898rq9pnafgn"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-unliftio" ,ghc-unliftio)))
+    (home-page "https://github.com/fpco/say")
+    (synopsis
+     "Send textual messages to a Handle in a thread-friendly way")
+    (description
+     "A thread safe API to write a line of textual data to a Handle, such
+as sending some messages to the terminal - that has the following properties:
+@itemize
+@item Properly handle character encoding settings on the Handle
+@item For reasonably sized messages, ensure that the entire message is written
+ in one chunk to avoid interleaving data with other threads
+@item Avoid unnecessary memory allocations and copies
+@item Minimize locking.
+@end itemize")
+    (license license:expat)))
+

 (define-public ghc-scientific
   (package
     (name "ghc-scientific")
 (define-public ghc-scientific
   (package
     (name "ghc-scientific")


@@ -9412,7 +10068,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


@@ -9443,7 +10099,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}.")


@@ -9471,7 +10127,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}.")


@@ -9830,6 +10486,32 @@ them.")
 are the bottleneck of web servers.")
     (license license:bsd-3)))
 
 are the bottleneck of web servers.")
     (license license:bsd-3)))
 

+(define-public ghc-size-based
+  (package
+    (name "ghc-size-based")
+    (version "0.1.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "size-based/size-based-" version ".tar.gz"))
+       (sha256
+        (base32
+         "06hmlic0n73ncwlkpx49xlv09bzsrr27ncnp5byhzlknak2gd7vp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-dictionary-sharing" ,ghc-dictionary-sharing)
+       ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers)
+       ("ghc-semigroups" ,ghc-semigroups)))
+    (arguments
+     `(#:cabal-revision
+       ("1" "0kax1ypjyglkn6iff1x4yz12y7f2n249m95xvdhrc63hsa4xlcqv")))
+    (home-page "https://hackage.haskell.org/package/size-based")
+    (synopsis "Sized functors for size-based enumerations")
+    (description "This library provides a framework for size-based
+enumerations.")
+    (license license:bsd-3)))
+

 (define-public ghc-skylighting-core
   (package
     (name "ghc-skylighting-core")
 (define-public ghc-skylighting-core
   (package
     (name "ghc-skylighting-core")


@@ -9949,7 +10631,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}


@@ -10008,7 +10690,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\"


@@ -10403,7 +11085,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


@@ -10501,6 +11183,32 @@ default)
 @end itemize")
     (license license:bsd-3)))
 
 @end itemize")
     (license license:bsd-3)))
 

+(define-public ghc-svg-builder
+  (package
+    (name "ghc-svg-builder")
+    (version "0.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "svg-builder/svg-builder-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1k420f497lzkymmxin88ql6ib8dziic43avykv31yq65rgrf7l2g"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (arguments
+     `(#:cabal-revision
+       ("1" "1bhp9gvid2iis411k1vvyj5krzc4ahxcqcd9cwx9h37jxg180xw1")))
+    (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
+building Scalable Vector Graphics (SVG).")
+    (license license:bsd-3)))
+

 (define-public ghc-syb
   (package
     (name "ghc-syb")
 (define-public ghc-syb
   (package
     (name "ghc-syb")


@@ -11144,7 +11852,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)))
 


@@ -11506,7 +12214,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


@@ -12517,7 +13225,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)))