From 921cf30835963bc27fcf6672b33da45dbcfe6da0 Mon Sep 17 00:00:00 2001
Message-Id: <921cf30835963bc27fcf6672b33da45dbcfe6da0.1633108979.git.public@yoctocell.xyz>
From: Xinglu Chen <public@yoctocell.xyz>
Date: Mon, 27 Sep 2021 17:13:32 +0200
Subject: [PATCH] fixup! gnu: Update Haskell ecosystem.

---
 gnu/packages/haskell-check.scm |   18 +-
 gnu/packages/haskell-web.scm   |    5 +-
 gnu/packages/haskell-xyz.scm   | 1343 ++++++++++++++++++--------------
 gnu/packages/purescript.scm    |    5 +-
 4 files changed, 767 insertions(+), 604 deletions(-)

diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm
index 42ec3e9c27..bfceb2e45b 100644
--- a/gnu/packages/haskell-check.scm
+++ b/gnu/packages/haskell-check.scm
@@ -1176,9 +1176,10 @@ (define-public ghc-doctest-exitcode-stdio
         ("ghc-quickcheck" ,ghc-quickcheck)
         ("ghc-semigroups" ,ghc-semigroups)))
     (home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/")
-    (synopsis "Run doctest's in a Cabal.Test.exitcode-stdio environment")
+    (synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environment")
     (description
-      "Run doctest's in a Cabal.Test.exitcode-stdio environment. For use with the @doctest-extract@ utility. Normally, you should not need to import a module from this package, only generated code will do this.")
+      "This package allows on to run Doctests in a Cabal.Test.exitcode-stdio
+environment.")
     (license license:bsd-3)))
 
 (define-public ghc-cabal-doctest
@@ -1199,9 +1200,9 @@ (define-public ghc-cabal-doctest
       `(#:cabal-revision
         ("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
     (home-page "https://github.com/phadej/cabal-doctest")
-    (synopsis "A Setup.hs helper for doctests running")
+    (synopsis "@file{Setup.hs} helper for Doctests running")
     (description
-      "Currently (beginning of 2017), there isn't @cabal doctest@ command. Yet, to properly work doctest needs plenty of configuration. This library provides the common bits for writing custom Setup.hs See <https://github.com/haskell/cabal/issues/2327 Cabal/2327> for the progress of @cabal doctest@, i.e. whether this library is obsolete.")
+      "This package provides helpers for running Doctests in @file{Setup.hs}."
     (license license:bsd-3)))
 
 (define-public ghc-tasty-silver
@@ -1232,8 +1233,13 @@ (define-public ghc-tasty-silver
       `(#:cabal-revision
         ("1" "0mgdk77xz38zc46qbxvss6vnp4yk328zbpw1l0c1n0f5gyf6sbav")))
     (home-page "https://github.com/phile314/tasty-silver")
-    (synopsis "A fancy test runner, including support for golden tests.")
+    (synopsis "Fancy test runner, including support for golden tests")
     (description
-      "This package provides a fancy test runner and support for Â«golden testingÂ». A golden test is an IO action that writes its result to a file. To pass the test, this output file should be identical to the corresponding Â«goldenÂ» file, which contains the correct result for the test. The test runner allows filtering tests using regexes, and to interactively inspect the result of golden tests. This package is a heavily extended fork of tasty-golden.")
+      "This package provides a fancy test runner and support for @dfn{golden
+testing}.  A golden test is an IO action that writes its result to a file.  To
+pass the test, this output file should be identical to the corresponding
+``golden'' file, which contains the correct result for the test.  The test
+runner allows filtering tests using regexes, and to interactively inspect the
+result of golden tests.")
     (license license:expat)))
 
diff --git a/gnu/packages/haskell-web.scm b/gnu/packages/haskell-web.scm
index 76c5e906f4..ad8713dbd8 100644
--- a/gnu/packages/haskell-web.scm
+++ b/gnu/packages/haskell-web.scm
@@ -2310,8 +2310,9 @@ (define-public ghc-network-run
           (base32 "0w3dmwk03j4n01xkiq8m4sqa27bskh239mpw7m4ihjmkxqcwc5gl"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-network" ,ghc-network)))
-    (home-page "http://hackage.haskell.org/package/network-run")
+    (home-page "https://hackage.haskell.org/package/network-run")
     (synopsis "Simple network runner library")
-    (description "Simple functions to run network clients and servers.")
+    (description
+     "This package provides a simple network runner library in Haskell.")
     (license license:bsd-3)))
 
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 3df5320c09..b07e5a1ee5 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -6655,9 +6655,8 @@ (define-public ghc-intervals
      `(("ghc-quickcheck" ,ghc-quickcheck)))
     (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.")
+    (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
@@ -6869,8 +6868,8 @@ (define-public ghc-json
     (home-page "https://hackage.haskell.org/package/json")
     (synopsis "Serializes Haskell data to and from JSON")
     (description "This package provides a parser and pretty printer for
-converting between Haskell values and JSON.
-JSON (JavaScript Object Notation) is a lightweight data-interchange format.")
+converting between Haskell values and JSON.  @acronym{JavaScript Object
+Notation, JSON} is a lightweight data-interchange format.")
     (license license:bsd-3)))
 
 (define-public ghc-juicypixels
@@ -12942,7 +12941,6 @@ (define ghc-system-fileio-bootstrap
 which can't be decoded in the current locale encoding.")
     (license license:expat)))
 
-
 (define-public ghc-system-filepath
   (package
     (name "ghc-system-filepath")
@@ -15492,28 +15490,48 @@ (define-public ghc-zstd
 targeting real-time compression scenarios at zlib-level and better
 compression ratios.")
     (license license:bsd-3)))
+
 (define-public ghc-indexed-traversable
   (package
     (name "ghc-indexed-traversable")
     (version "0.1.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/indexed-traversable/indexed-traversable-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0fc18vdm1894yjbjkj9wjm27bf37ac3gvkzak677mgiw2pinmhvs"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/indexed-traversable/indexed-traversable-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0fc18vdm1894yjbjkj9wjm27bf37ac3gvkzak677mgiw2pinmhvs"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-generic-deriving" ,ghc-generic-deriving)))
     (arguments
-      `(#:cabal-revision
-        ("1" "0krvp9v5dh4w2076kar48cpkk62ndqp769v2ai3b38rsa5bj6q74")))
-    (home-page "http://hackage.haskell.org/package/indexed-traversable")
-    (synopsis "FunctorWithIndex, FoldableWithIndex, TraversableWithIndex")
+     `(#:cabal-revision
+       ("1" "0krvp9v5dh4w2076kar48cpkk62ndqp769v2ai3b38rsa5bj6q74")))
+    (home-page "https://hackage.haskell.org/package/indexed-traversable")
+    (synopsis "Indexed Functor, Foldable, and Traversable typeclasses")
     (description
-      "This package provides three useful generalizations: . @ class Functor f => FunctorWithIndex i f | f -> i where \\  imap :: (i -> a -> b) -> f a -> f b @ . @ class Foldable f => FoldableWithIndex i f | f -> i where \\  ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m @ . @ class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i t | t -> i where \\  itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b) @ . This package contains instances for types in GHC boot libraries. For some additional instances see [indexed-traversable-instances](https://hackage.haskell.org/package/indexed-traversable-instances). . The [keys](https://hackage.haskell.org/package/keys) package provides similar functionality, but uses (associated) @TypeFamilies@ instead of @FunctionalDependencies@.")
+     "This Haskell package provides three useful generalizations:
+
+@example
+class Functor f => FunctorWithIndex i f | f -> i where
+  imap :: (i -> a -> b) -> f a -> f b
+@end example
+
+@example
+class Foldable f => FoldableWithIndex i f | f -> i where
+  ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m
+@end example
+
+@example
+class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t)
+       => TraversableWithIndex i t | t -> i where
+  itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)
+@end example
+
+The @code{ghc-keys} package provides similar functionality, but uses
+associated @code{TypeFamilies} instead of @code{FunctionalDependencies}.")
     (license license:bsd-2)))
 
 (define-public ghc-type-equality
@@ -15521,22 +15539,31 @@ (define-public ghc-type-equality
     (name "ghc-type-equality")
     (version "1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/type-equality/type-equality-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1s4cl11rvvv7n95i3pq9lmmx08kwh4z7l3d1hbv4wi8il81baa27"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/type-equality/type-equality-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1s4cl11rvvv7n95i3pq9lmmx08kwh4z7l3d1hbv4wi8il81baa27"))))
     (build-system haskell-build-system)
     (arguments
-      `(#:cabal-revision
-        ("2" "1a3irpv5kyg3rywhmcp5fwg5irrdbdr0hrlw7asdk113nakrba7j")))
+     `(#:cabal-revision
+       ("2" "1a3irpv5kyg3rywhmcp5fwg5irrdbdr0hrlw7asdk113nakrba7j")))
     (home-page "https://github.com/hesselink/type-equality")
-    (synopsis "Data.Type.Equality compat package")
+    (synopsis "@code{Data.Type.Equality} compatibility package")
     (description
-      "This library defines a propositional equality data type, shims @Data.Type.Equality@ as well as possible for older GHCs (< 7.8). . @ data a :~: b where \\    Refl :: a :~: a @ . The module @Data.Type.Equality.Hetero@ shims @:~~:@ equality, for compilers with @PolyKinds@")
+     "This library defines a propositional equality data type, shims
+@code{Data.Type.Equality} as well as possible for older GHC versions (< 7.8).
+
+@example
+data a :~: b where
+  Refl :: a :~: a
+@end example
+
+The module @code{Data.Type.Equality.Hetero} shims @@code{:~~:} equality, and
+for compilers with @code{PolyKinds}.")
     (license license:bsd-3)))
 
 (define-public ghc-selective
@@ -15544,24 +15571,28 @@ (define-public ghc-selective
     (name "ghc-selective")
     (version "0.4.2")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/selective/selective-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/selective/selective-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l"))))
     (build-system haskell-build-system)
     (native-inputs
-      `(("ghc-quickcheck" ,ghc-quickcheck)
-        ("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
-        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
     (home-page "https://github.com/snowleopard/selective")
     (synopsis "Selective applicative functors")
     (description
-      "Selective applicative functors: declare your effects statically, select which to execute dynamically. . This is a library for /selective applicative functors/, or just /selective functors/ for short, an abstraction between applicative functors and monads, introduced in <https://www.staff.ncl.ac.uk/andrey.mokhov/selective-functors.pdf this paper>.")
+     "This package implements selective applicative functors, which allow you
+to declare your effects statically, and select which to execute dynamically.
+See the
+@uref{https://www.staff.ncl.ac.uk/andrey.mokhov/selective-functors.pdf, paper
+on selective functors} for more details.")
     (license license:expat)))
 
 (define-public ghc-keys
@@ -15569,28 +15600,31 @@ (define-public ghc-keys
     (name "ghc-keys")
     (version "3.12.3")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/keys/keys-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/keys/keys-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-comonad" ,ghc-comonad)
-        ("ghc-free" ,ghc-free)
-        ("ghc-hashable" ,ghc-hashable)
-        ("ghc-semigroupoids" ,ghc-semigroupoids)
-        ("ghc-semigroups" ,ghc-semigroups)
-        ("ghc-tagged" ,ghc-tagged)
-        ("ghc-transformers-compat" ,ghc-transformers-compat)
-        ("ghc-unordered-containers" ,ghc-unordered-containers)))
+     `(("ghc-comonad" ,ghc-comonad)
+       ("ghc-free" ,ghc-free)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
     (home-page "http://github.com/ekmett/keys/")
     (synopsis "Keyed functors and containers")
     (description
-      "This package provides a bunch of ad hoc classes for accessing parts of a container. . In practice this package is largely subsumed by the <https://hackage.haskell.org/package/lens lens package>, but it is maintained for now as it has much simpler dependencies.")
+     "This package provides a bunch of ad hoc classes for accessing parts of
+a container.  In practice this package is largely subsumed by the
+@code{ghc-lens}, but it is maintained for now as it has much simpler
+dependencies.")
     (license license:bsd-3)))
 
 (define-public ghc-pointed
@@ -15598,28 +15632,29 @@ (define-public ghc-pointed
     (name "ghc-pointed")
     (version "5.0.2")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/pointed/pointed-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "07p92y62dibys3xa59rvx52xyyr39nghl73z7hzwnksa3ry3vfmq"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/pointed/pointed-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "07p92y62dibys3xa59rvx52xyyr39nghl73z7hzwnksa3ry3vfmq"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-data-default-class" ,ghc-data-default-class)
-        ("ghc-comonad" ,ghc-comonad)
-        ("ghc-kan-extensions" ,ghc-kan-extensions)
-        ("ghc-semigroupoids" ,ghc-semigroupoids)
-        ("ghc-semigroups" ,ghc-semigroups)
-        ("ghc-tagged" ,ghc-tagged)
-        ("ghc-transformers-compat" ,ghc-transformers-compat)
-        ("ghc-hashable" ,ghc-hashable)
-        ("ghc-unordered-containers" ,ghc-unordered-containers)))
-    (home-page "http://github.com/ekmett/pointed/")
-    (synopsis "Pointed and copointed data")
-    (description "Pointed and copointed data.")
+     `(("ghc-data-default-class" ,ghc-data-default-class)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-kan-extensions" ,ghc-kan-extensions)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)))
+    (home-page "https://github.com/ekmett/pointed/")
+    (synopsis "Pointed and copointed data types")
+    (description
+     "This Haskell library provides pointed and copointed data types.")
     (license license:bsd-3)))
 
 (define-public ghc-vector-instances
@@ -15627,26 +15662,28 @@ (define-public ghc-vector-instances
     (name "ghc-vector-instances")
     (version "3.4")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/vector-instances/vector-instances-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "10akvpa5w9bp0d8hflab63r9laa9gy2hv167smhjsdzq1kplc0hv"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/vector-instances/vector-instances-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "10akvpa5w9bp0d8hflab63r9laa9gy2hv167smhjsdzq1kplc0hv"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-vector" ,ghc-vector)
-        ("ghc-semigroupoids" ,ghc-semigroupoids)
-        ("ghc-semigroups" ,ghc-semigroups)
-        ("ghc-comonad" ,ghc-comonad)
-        ("ghc-pointed" ,ghc-pointed)
-        ("ghc-keys" ,ghc-keys)
-        ("ghc-hashable" ,ghc-hashable)))
-    (home-page "http://github.com/ekmett/vector-instances")
-    (synopsis "Orphan Instances for 'Data.Vector'")
-    (description "")
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-semigroupoids" ,ghc-semigroupoids)
+       ("ghc-semigroups" ,ghc-semigroups)
+       ("ghc-comonad" ,ghc-comonad)
+       ("ghc-pointed" ,ghc-pointed)
+       ("ghc-keys" ,ghc-keys)
+       ("ghc-hashable" ,ghc-hashable)))
+    (home-page "https://github.com/ekmett/vector-instances")
+    (synopsis "Orphan instances for @code{Data.Vector}")
+    (description
+     "This Haskell library provides a place for lots of orphan instances for
+the @code{ghc-vector} package.")
     (license license:bsd-3)))
 
 (define-public ghc-th-compat
@@ -15654,23 +15691,28 @@ (define-public ghc-th-compat
     (name "ghc-th-compat")
     (version "0.1.3")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/th-compat/th-compat-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/th-compat/th-compat-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b"))))
     (build-system haskell-build-system)
     (native-inputs
-      `(("ghc-base-compat" ,ghc-base-compat)
-        ("ghc-hspec" ,ghc-hspec)
-        ("hspec-discover" ,hspec-discover)))
+     `(("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)))
     (home-page "https://github.com/haskell-compat/th-compat")
-    (synopsis "Backward- (and forward-)compatible Quote and Code types")
+    (synopsis
+     "Backward- and forward-compatible @code{Quote} and @code{Code} types")
     (description
-      "This package defines a \"Language.Haskell.TH.Syntax.Compat\" module, which backports the @Quote@ and @Code@ types to work across a wide range of @template-haskell@ versions. On recent versions of @template-haskell@ (2.17.0.0 or later), this module simply reexports @Quote@ and @Code@ from \"Language.Haskell.TH.Syntax\". Refer to the Haddocks for \"Language.Haskell.TH.Syntax.Compat\" for examples of how to use this module.")
+     "This package defines a @code{Language.Haskell.TH.Syntax.Compat} module,
+which backports the @code{Quote} and @code{Code} types to work across a wide
+range of @code{template-haskell} versions.  On recent versions of
+@code{template-haskell} (2.17.0.0 or later), this module simply re-exports
+@code{Quote} and @code{Code} from @code{Language.Haskell.TH.Syntax}.")
     (license license:bsd-3)))
 
 (define-public ghc-filepattern
@@ -15678,21 +15720,43 @@ (define-public ghc-filepattern
     (name "ghc-filepattern")
     (version "0.1.2")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/filepattern/filepattern-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0nznzji5haxl4ninm2a79dqf4c7fj6pc3z9gdc6wbf5h1pp14afr"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/filepattern/filepattern-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0nznzji5haxl4ninm2a79dqf4c7fj6pc3z9gdc6wbf5h1pp14afr"))))
     (build-system haskell-build-system)
-    (inputs `(("ghc-extra" ,ghc-extra) ("ghc-semigroups" ,ghc-semigroups)))
+    (inputs
+     `(("ghc-extra" ,ghc-extra)
+       ("ghc-semigroups" ,ghc-semigroups)))
     (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page "https://github.com/ndmitchell/filepattern#readme")
+    (home-page "https://github.com/ndmitchell/filepattern")
     (synopsis "File path glob-like matching")
     (description
-      "A library for matching files using patterns such as @\\\"src\\/**\\/*.png\\\"@ for all @.png@ files recursively under the @src@ directory. Features: . * All matching is /O(n)/. Most functions precompute some information given only one argument. . * See \"System.FilePattern\" and @?==@ simple matching and semantics. . * Use @match@ and @substitute@ to extract suitable strings from the @*@ and @**@ matches, and substitute them back into other patterns. . * Use @step@ and @matchMany@ to perform bulk matching of many patterns against many paths simultaneously. . * Use \"System.FilePattern.Directory\" to perform optimised directory traverals using patterns. . Originally taken from the <https://hackage.haskell.org/package/shake Shake library>.")
+     "This package provides Haskell library for matching files using patterns
+such as @code{\\\"src\\/**\\/*.png\\\"} for all @@file{.png} files recursively
+under the @@file{src} directory.
+
+Some of its features include:
+
+@itemize
+@item All matching is O(n).
+
+@item Most functions pre-compute some information given only one argument.
+
+@item Uses @code{match} and @code{substitute} to extract suitable strings from
+the @code{*} and @code{**} matches, and substitutes them back into other
+patterns.
+
+@item Uses @code{step} and @code{matchMany} to perform bulk matching of many
+patterns against many paths simultaneously.
+
+@item Uses @code{System.FilePattern.Directory} to perform optimised directory
+traverals using patterns.
+@end itemize")
     (license license:bsd-3)))
 
 (define-public ghc-lib-parser-ex
@@ -15700,24 +15764,24 @@ (define-public ghc-lib-parser-ex
     (name "ghc-lib-parser-ex")
     (version "8.10.0.23")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/ghc-lib-parser-ex/ghc-lib-parser-ex-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0r5sl7hhn0cxp0b1dskx1lshplc0yka7hcvs2nh10nrj07fjd3vj"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/ghc-lib-parser-ex/ghc-lib-parser-ex-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0r5sl7hhn0cxp0b1dskx1lshplc0yka7hcvs2nh10nrj07fjd3vj"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-uniplate" ,ghc-uniplate)))
     (native-inputs
-      `(("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-        ("ghc-extra" ,ghc-extra)))
-    (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme")
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-extra" ,ghc-extra)))
+    (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex")
     (synopsis "Algorithms on GHC parse trees")
     (description
-      "Please see the README on GitHub at <https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme>")
+     "The @code{ghc-lib-parser-ex} package contains GHC API parse tree utilities.")
     (license license:bsd-3)))
 
 (define-public ghc-lift-type
@@ -15725,20 +15789,22 @@ (define-public ghc-lift-type
     (name "ghc-lift-type")
     (version "0.1.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/lift-type/lift-type-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/lift-type/lift-type-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf"))))
     (build-system haskell-build-system)
-    (home-page "https://github.com/parsonsmatt/lift-type#readme")
+    (home-page "https://github.com/parsonsmatt/lift-type")
     (synopsis
-      "Lift a type from a Typeable constraint to a Template Haskell type")
+     "Lift a type from a Typeable constraint to a Template Haskell type")
     (description
-      "Lift your types from a Typeable constraint to a Template Haskell type")
+     "This library provides a utility function @code{liftType}, which accepts a type
+application argument and returns the Template Haskell @code{Type} representation of
+it.")
     (license license:bsd-3)))
 
 (define-public ghc-unicode-collation
@@ -15746,87 +15812,106 @@ (define-public ghc-unicode-collation
     (name "ghc-unicode-collation")
     (version "0.1.3")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/unicode-collation/unicode-collation-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/unicode-collation/unicode-collation-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-th-lift-instances" ,ghc-th-lift-instances)))
     (native-inputs
-      `(("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
-        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-        ("ghc-unicode-transforms" ,ghc-unicode-transforms)
-        ("ghc-doctest" ,ghc-doctest)))
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-unicode-transforms" ,ghc-unicode-transforms)
+       ("ghc-doctest" ,ghc-doctest)))
     (home-page "https://github.com/jgm/unicode-collation")
     (synopsis "Haskell implementation of the Unicode Collation Algorithm")
     (description
-      "This library provides a pure Haskell implementation of the Unicode Collation Algorithm described at <http://www.unicode.org/reports/tr10/>.  It is not as fully-featured or as performant as @text-icu@, but it avoids a dependency on a large C library. Locale-specific tailorings are also provided.")
-    (license #f)))
+     "This library provides a pure Haskell implementation of the Unicode
+Collation Algorithm described at @uref{http://www.unicode.org/reports/tr10/}.
+It is not as fully-featured or as performant as @code{text-icu}, but it avoids
+a dependency on a large C library.  Locale-specific tailorings are also
+provided.")
+    (license license:bsd-3)))
 
 (define-public ghc-citeproc
   (package
     (name "ghc-citeproc")
     (version "0.4.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/citeproc/citeproc-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/citeproc/citeproc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-safe" ,ghc-safe)
-        ("ghc-case-insensitive" ,ghc-case-insensitive)
-        ("ghc-vector" ,ghc-vector)
-        ("ghc-scientific" ,ghc-scientific)
-        ("ghc-uniplate" ,ghc-uniplate)
-        ("ghc-xml-conduit" ,ghc-xml-conduit)
-        ("ghc-attoparsec" ,ghc-attoparsec)
-        ("ghc-data-default" ,ghc-data-default)
-        ("ghc-aeson" ,ghc-aeson)
-        ("ghc-file-embed" ,ghc-file-embed)
-        ("ghc-pandoc-types" ,ghc-pandoc-types)
-        ("ghc-unicode-collation" ,ghc-unicode-collation)
-        ("ghc-base-compat" ,ghc-base-compat)
-        ("ghc-aeson-pretty" ,ghc-aeson-pretty)))
+     `(("ghc-safe" ,ghc-safe)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-uniplate" ,ghc-uniplate)
+       ("ghc-xml-conduit" ,ghc-xml-conduit)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-data-default" ,ghc-data-default)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-file-embed" ,ghc-file-embed)
+       ("ghc-pandoc-types" ,ghc-pandoc-types)
+       ("ghc-unicode-collation" ,ghc-unicode-collation)
+       ("ghc-base-compat" ,ghc-base-compat)
+       ("ghc-aeson-pretty" ,ghc-aeson-pretty)))
     (native-inputs `(("ghc-timeit" ,ghc-timeit) ("ghc-diff" ,ghc-diff)))
-    (home-page "http://hackage.haskell.org/package/citeproc")
-    (synopsis "Generates citations and bibliography from CSL styles.")
+    (home-page "https://hackage.haskell.org/package/citeproc")
+    (synopsis "Generate citations and bibliography from CSL styles")
     (description
-      "citeproc parses CSL style files and uses them to generate a list of formatted citations and bibliography entries.  For more information about CSL, see <https://citationstyles.org/>.")
-    (license #f)))
+     "@code{ghc-citeproc} parses @acronym{Citation Style Language, CSL} style files
+and uses them to generate a list of formatted citations and bibliography
+entries.  For more information about CSL, see @urefhttps://citationstyles.org/}.")
+    (license license:bsd-2)))
 
 (define-public ghc-commonmark
   (package
     (name "ghc-commonmark")
     (version "0.2.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/commonmark/commonmark-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1vba7v1zaqh811v3j4x42g7mhwvxwgzm997kq1kzd0njby14fq5b"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/commonmark/commonmark-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1vba7v1zaqh811v3j4x42g7mhwvxwgzm997kq1kzd0njby14fq5b"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-unicode-transforms" ,ghc-unicode-transforms)))
     (native-inputs
-      `(("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
-        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
     (home-page "https://github.com/jgm/commonmark-hs")
-    (synopsis "Pure Haskell commonmark parser.")
+    (synopsis "Pure Haskell Commonmark parser")
     (description
-      "This library provides the core data types and functions for parsing commonmark (<https://spec.commonmark.org>). The parser is fully commonmark-compliant and passes the test suite.  It is designed to be customizable and easily extensible. To customize the output, create an AST, or support a new output format, one need only define some new typeclass instances. It is also easy to add new syntax elements or modify existing ones. . Accurate information about source positions is available for all block and inline elements.  Thus the library can be used to create an accurate syntax highlighter or an editor with live preview. . The parser has been designed for robust performance even in pathological cases that tend to cause stack overflows or exponential slowdowns in other parsers, with parsing speed that varies linearly with input length. . Related packages: . - commonmark-extensions (which defines a number of syntax extensions) - commonmark-pandoc (which allows using this parser to create a Pandoc structure) - commonmark-cli (a command-line tool for converting and syntax-highlighting commonmark documents)")
+     "This library provides the core data types and functions for parsing
+@uref{https://spec.commonmark.org, Commonmark}.  The parser is fully
+Commonmark-compliant and passes the test suite.  It is designed to be
+customizable and easily extensible.  To customize the output, create an AST,
+or support a new output format, one need only define some new typeclass
+instances.  It is also easy to add new syntax elements or modify existing
+ones.
+
+Accurate information about source positions is available for all block and
+inline elements.  Thus the library can be used to create an accurate syntax
+highlighter or an editor with live preview. The parser has been designed for
+robust performance even in pathological cases that tend to cause stack
+overflows or exponential slowdowns in other parsers, with parsing speed that
+varies linearly with input length.")
     (license license:bsd-3)))
 
 (define-public ghc-commonmark-extensions
@@ -15834,25 +15919,27 @@ (define-public ghc-commonmark-extensions
     (name "ghc-commonmark-extensions")
     (version "0.2.1.2")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/commonmark-extensions/commonmark-extensions-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1ky0j7086a8mqpg26j2nkrc5wfwiw5cd3h3jqncpy59vmj1prkx4"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/commonmark-extensions/commonmark-extensions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1ky0j7086a8mqpg26j2nkrc5wfwiw5cd3h3jqncpy59vmj1prkx4"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-network-uri" ,ghc-network-uri)
-        ("ghc-commonmark" ,ghc-commonmark)
-        ("ghc-emojis" ,ghc-emojis)))
+     `(("ghc-network-uri" ,ghc-network-uri)
+       ("ghc-commonmark" ,ghc-commonmark)
+       ("ghc-emojis" ,ghc-emojis)))
     (native-inputs
-      `(("ghc-tasty" ,ghc-tasty) ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+     `(("ghc-tasty" ,ghc-tasty) ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
     (home-page "https://github.com/jgm/commonmark-hs")
-    (synopsis "Pure Haskell commonmark parser.")
+    (synopsis "Extensions for @code{ghc-commonmark}")
     (description
-      "This library provides some useful extensions to core commonmark syntax: smart quotes, definition lists, tables, footnotes, math, and more.")
+     "This library provides some useful extensions for @code{ghc-commonmark}
+to parser core commonmark syntax: smart quotes, definition lists, tables,
+footnotes, math, and more.")
     (license license:bsd-3)))
 
 (define-public ghc-commonmark-pandoc
@@ -15860,23 +15947,24 @@ (define-public ghc-commonmark-pandoc
     (name "ghc-commonmark-pandoc")
     (version "0.2.1.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/commonmark-pandoc/commonmark-pandoc-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/commonmark-pandoc/commonmark-pandoc-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-commonmark" ,ghc-commonmark)
-        ("ghc-commonmark-extensions" ,ghc-commonmark-extensions)
-        ("ghc-pandoc-types" ,ghc-pandoc-types)))
+     `(("ghc-commonmark" ,ghc-commonmark)
+       ("ghc-commonmark-extensions" ,ghc-commonmark-extensions)
+       ("ghc-pandoc-types" ,ghc-pandoc-types)))
     (home-page "https://github.com/jgm/commonmark-hs")
-    (synopsis "Bridge between commonmark and pandoc AST.")
+    (synopsis "Bridge between Commonmark and Pandoc AST.")
     (description
-      "This library provides typeclasses for rendering commonmark to Pandoc types.")
+     "This library provides typeclasses for rendering @code{ghc-commonmark} to
+Pandoc types.")
     (license license:bsd-3)))
 
 (define-public ghc-hslua-module-path
@@ -15884,24 +15972,25 @@ (define-public ghc-hslua-module-path
     (name "ghc-hslua-module-path")
     (version "0.1.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/hslua-module-path/hslua-module-path-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1zxfljcn74rky26ijqmba6grpj0h9plgr47wxdaf7gcz1y8dhn68"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hslua-module-path/hslua-module-path-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1zxfljcn74rky26ijqmba6grpj0h9plgr47wxdaf7gcz1y8dhn68"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-hslua" ,ghc-hslua)))
     (native-inputs
-      `(("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-        ("ghc-tasty-lua" ,ghc-tasty-lua)))
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-tasty-lua" ,ghc-tasty-lua)))
     (home-page "https://github.com/hslua/hslua-module-path")
-    (synopsis "Lua module to work with file paths.")
+    (synopsis "Lua module to work with file paths")
     (description
-      "Lua module to work with file paths in a platform independent way.")
+     "This Haskell library provides a Lua module to work with file paths in a
+platform independent way.")
     (license license:expat)))
 
 (define-public ghc-template-haskell
@@ -15909,20 +15998,23 @@ (define-public ghc-template-haskell
     (name "ghc-template-haskell")
     (version "2.16.0.0")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/template-haskell/template-haskell-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1nk1cv35szp80qkhbyh5gn6vn194zzl0wz186qrqdrdx3a9r9w4g"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/template-haskell/template-haskell-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1nk1cv35szp80qkhbyh5gn6vn194zzl0wz186qrqdrdx3a9r9w4g"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-boot-th" ,ghc-boot-th)))
     (home-page "http://hackage.haskell.org/package/template-haskell")
     (synopsis "Support library for Template Haskell")
     (description
-      "This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. . See <http://www.haskell.org/haskellwiki/Template_Haskell> for more information.")
+     "This package provides modules containing facilities for manipulating
+Haskell source code using Template Haskell. See
+@uref{http://www.haskell.org/haskellwiki/Template_Haskell} for more
+information.")
     (license license:bsd-3)))
 
 (define-public ghc-genvalidity-hspec
@@ -15930,27 +16022,28 @@ (define-public ghc-genvalidity-hspec
     (name "ghc-genvalidity-hspec")
     (version "0.7.0.4")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/genvalidity-hspec/genvalidity-hspec-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0aajx07n2rznyqxb0c4pn9j2cvkzw5brz9ki4grhhigbcri3jzmv"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/genvalidity-hspec/genvalidity-hspec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0aajx07n2rznyqxb0c4pn9j2cvkzw5brz9ki4grhhigbcri3jzmv"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-quickcheck" ,ghc-quickcheck)
-        ("ghc-genvalidity" ,ghc-genvalidity)
-        ("ghc-genvalidity-property" ,ghc-genvalidity-property)
-        ("ghc-hspec" ,ghc-hspec)
-        ("hspec-discover" ,hspec-discover)
-        ("ghc-hspec-core" ,ghc-hspec-core)
-        ("ghc-validity" ,ghc-validity)))
-    (home-page "https://github.com/NorfairKing/validity#readme")
-    (synopsis "Standard spec's for GenValidity instances")
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-genvalidity" ,ghc-genvalidity)
+       ("ghc-genvalidity-property" ,ghc-genvalidity-property)
+       ("ghc-hspec" ,ghc-hspec)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-hspec-core" ,ghc-hspec-core)
+       ("ghc-validity" ,ghc-validity)))
+    (home-page "https://github.com/NorfairKing/validity")
+    (synopsis "Standard spec's for @code{GenValidity} instances")
     (description
-      "Note: There are companion packages for this library: . * <https://hackage.haskell.org/package/genvalidity-hspec-aeson genvalidity-hspec-aeson> . * <https://hackage.haskell.org/package/genvalidity-hspec-binary genvalidity-hspec-binary> . * <https://hackage.haskell.org/package/genvalidity-hspec-cereal genvalidity-hspec-cereal> . * <https://hackage.haskell.org/package/genvalidity-hspec-hashable genvalidity-hspec-hashable>")
+     "This haskell library provides validity and validity-based testing for
+@code{ghc-hspec}. ")
     (license license:expat)))
 
 (define-public ghc-boot-th
@@ -15958,49 +16051,53 @@ (define-public ghc-boot-th
     (name "ghc-boot-th")
     (version "8.10.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/ghc-boot-th/ghc-boot-th-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0vhhmsd32p7zn9vhpv4d0k0b55n2dyhzy42xblndrma617kz8gli"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/ghc-boot-th/ghc-boot-th-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0vhhmsd32p7zn9vhpv4d0k0b55n2dyhzy42xblndrma617kz8gli"))))
     (build-system haskell-build-system)
     (home-page "http://hackage.haskell.org/package/ghc-boot-th")
     (synopsis
-      "Shared functionality between GHC and the `template-haskell` library")
+     "Shared functionality between GHC and Template Haskell"
     (description
-      "This library contains various bits shared between the @ghc@ and @template-haskell@ libraries. . This package exists to ensure that @template-haskell@ has a minimal set of transitive dependencies, since it is intended to be depended upon by user code.")
-    (license license:bsd-3)))
+     "This library contains various bits shared between GHC and Template
+Haskell.  This package exists to ensure that @code{template-haskell} has a
+minimal set of transitive dependencies, since it is intended to be depended
+upon by user code.")
+    (license license:bsd-3))))
 
 (define-public ghc-binary-orphans
   (package
     (name "ghc-binary-orphans")
     (version "1.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/binary-orphans/binary-orphans-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0gbmn5rpvyxhw5bxjmxwld6918lslv03b2f6hshssaw1il5x86j3"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/binary-orphans/binary-orphans-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0gbmn5rpvyxhw5bxjmxwld6918lslv03b2f6hshssaw1il5x86j3"))))
     (build-system haskell-build-system)
     (native-inputs
-      `(("ghc-quickcheck" ,ghc-quickcheck)
-        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
-        ("ghc-tagged" ,ghc-tagged)
-        ("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
     (arguments
-      `(#:cabal-revision
-        ("5" "1h2d37szfrcwn9rphnijn4q9l947b0wwqjs1aqmm62xkhbad7jf6")))
+     `(#:cabal-revision
+       ("5" "1h2d37szfrcwn9rphnijn4q9l947b0wwqjs1aqmm62xkhbad7jf6")))
     (home-page "http://hackage.haskell.org/package/binary-orphans")
-    (synopsis "Compatibility package for binary; provides instances")
+    (synopsis "Compatibility package for binary")
     (description
-      "This package provides instances defined in later versions of @binary@ package . Prior version 1 this packages provided instances for other packages. That functionality is moved to [binary-instances](https://hackage.haskell.org/package/binary-instances) package.")
+     "This package provides instances defined in later versions of
+@code{ghc-binary} package.")
     (license license:bsd-3)))
 
 (define-public ghc-netlink
@@ -16008,24 +16105,27 @@ (define-public ghc-netlink
     (name "ghc-netlink")
     (version "1.1.1.0")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/netlink/netlink-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1q8sxycv93sap6dgbw70scklnpjj5vav6qlvsxm5500jlvb3jnf0"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/netlink/netlink-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1q8sxycv93sap6dgbw70scklnpjj5vav6qlvsxm5500jlvb3jnf0"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-cereal" ,ghc-cereal)
-        ("ghc-monad-loops" ,ghc-monad-loops)
-        ("ghc-pretty-hex" ,ghc-pretty-hex)
-        ("ghc-language-c" ,ghc-language-c)
-        ("ghc-regex-pcre" ,ghc-regex-pcre)))
+     `(("ghc-cereal" ,ghc-cereal)
+       ("ghc-monad-loops" ,ghc-monad-loops)
+       ("ghc-pretty-hex" ,ghc-pretty-hex)
+       ("ghc-language-c" ,ghc-language-c)
+       ("ghc-regex-pcre" ,ghc-regex-pcre)))
     (home-page "https://github.com/Ongy/netlink-hs")
     (synopsis "Netlink communication for Haskell")
-    (description "Library to comminicate with Linux kernel via Netlink")
+    (description
+     "This is library provides utility to use Netlink from Haskell.  The scope of
+this package extends over general Netlink support to specific implementations
+of Netlink families.")
     (license license:bsd-3)))
 
 (define-public ghc-doctest-driver-gen
@@ -16033,21 +16133,22 @@ (define-public ghc-doctest-driver-gen
     (name "ghc-doctest-driver-gen")
     (version "0.3.0.4")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/doctest-driver-gen/doctest-driver-gen-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/doctest-driver-gen/doctest-driver-gen-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a"))))
     (build-system haskell-build-system)
     (arguments `(#:tests? #f)) ; TODO: Fail to open shared library.
     (native-inputs `(("ghc-doctest" ,ghc-doctest)))
-    (home-page "https://github.com/Hexirp/doctest-driver-gen#readme")
-    (synopsis "Generate driver file for doctest's cabal integration")
+    (home-page "https://github.com/Hexirp/doctest-driver-gen")
+    (synopsis "Generate driver file for Doctest's Cabal integration")
     (description
-      "doctest-driver-gen is a doctest's driver file generator. It lets you automatically generate driver file for doctest's cabal integration.")
+     "@code{ghc-doctest-driver-gen} is a Doctest's driver file generator.  It
+lets you automatically generate driver file for Doctest's Cabal integration.")
     (license license:bsd-3)))
 
 (define-public ghc-template-haskell-compat-v0208
@@ -16055,20 +16156,20 @@ (define-public ghc-template-haskell-compat-v0208
     (name "ghc-template-haskell-compat-v0208")
     (version "0.1.6")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/template-haskell-compat-v0208/template-haskell-compat-v0208-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/template-haskell-compat-v0208/template-haskell-compat-v0208-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8"))))
     (build-system haskell-build-system)
-    (home-page
-      "https://github.com/nikita-volkov/template-haskell-compat-v0208")
-    (synopsis
-      "A backwards compatibility layer for Template Haskell newer than 2.8")
-    (description "")
+    (home-page "https://github.com/nikita-volkov/template-haskell-compat-v0208")
+    (synopsis "Backwards compatibility layer for Template Haskell newer than 2.8")
+    (description
+     "This package provides a backwards compatibility layer for Template
+Haskell newer than 2.8.")
     (license license:expat)))
 
 (define-public ghc-mysql
@@ -16076,14 +16177,14 @@ (define-public ghc-mysql
     (name "ghc-mysql")
     (version "0.2.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/mysql/mysql-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "16m8hv9yy2nf4jwgqg6n9z53n2pzskbc3gwbp2i3kgff8wsmf8sd"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/mysql/mysql-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "16m8hv9yy2nf4jwgqg6n9z53n2pzskbc3gwbp2i3kgff8wsmf8sd"))))
     (build-system haskell-build-system)
     (arguments `(#:tests? #f)) ; TODO: Fails to connect to server.
     (inputs
@@ -16092,9 +16193,16 @@ (define-public ghc-mysql
        ("openssl" ,openssl)))
     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
     (home-page "https://github.com/paul-rouse/mysql")
-    (synopsis "A low-level MySQL client library.")
+    (synopsis "Low-level MySQL client library")
     (description
-      "A low-level client library for the MySQL database, implemented as bindings to the C @mysqlclient@ API. . /Important licensing note/: This library is BSD-licensed under the terms of the MySQL FOSS License Exception <http://www.mysql.com/about/legal/licensing/foss-exception/>. . Since this library links against the GPL-licensed @mysqlclient@ library, a non-open-source application that uses it /may/ be subject to the terms of the GPL.")
+     "This library provides Haskell bindings to the MySQL @code{mysqlclient}
+client library.  It is a fairly faithful, low level library that implements
+most of the MySQL client API.  The major departure from the C API is that in
+Haskell, resource management is mostly automatic and safe.
+
+This library deliberately avoids the question of providing a ``good'' API.
+Its purpose is to serve as a base upon which higher-level libraries can be
+built.")
     (license license:bsd-3)))
 
 (define-public ghc-blaze-textual
@@ -16102,28 +16210,29 @@ (define-public ghc-blaze-textual
     (name "ghc-blaze-textual")
     (version "0.2.2.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/blaze-textual/blaze-textual-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0zjnwnjpcpnnm0815h9ngr3a3iy0szsnb3nrcavkbx4905s9k4bs"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/blaze-textual/blaze-textual-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0zjnwnjpcpnnm0815h9ngr3a3iy0szsnb3nrcavkbx4905s9k4bs"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-blaze-builder" ,ghc-blaze-builder)
-        ("ghc-old-locale" ,ghc-old-locale)
-        ("ghc-vector" ,ghc-vector)))
+     `(("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-vector" ,ghc-vector)))
     (native-inputs
-      `(("ghc-quickcheck" ,ghc-quickcheck)
-        ("ghc-double-conversion" ,ghc-double-conversion)
-        ("ghc-test-framework" ,ghc-test-framework)
-        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
-    (home-page "http://github.com/bos/blaze-textual")
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-double-conversion" ,ghc-double-conversion)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/blaze-textual")
     (synopsis "Fast rendering of common datatypes")
     (description
-      "A library for efficiently rendering Haskell datatypes to bytestrings. . /Note/: if you use GHCi or Template Haskell, please see the @README@ file for important details about building this package, and other packages that depend on it: <https://github.com/bos/blaze-textual#readme>")
+     "@code{ghc-blaze-textual} is a fast Haskell library for rendering common
+Haskell datatypes in text form using the @code{ghc-blaze-builder} library.")
     (license license:bsd-3)))
 
 (define-public ghc-mysql-simple
@@ -16131,31 +16240,32 @@ (define-public ghc-mysql-simple
     (name "ghc-mysql-simple")
     (version "0.4.6")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/mysql-simple/mysql-simple-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1am8ck092s9cv4x1ambalil4mlazkp8w5qhjbl4nq0j2hpy73rby"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/mysql-simple/mysql-simple-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1am8ck092s9cv4x1ambalil4mlazkp8w5qhjbl4nq0j2hpy73rby"))))
     (build-system haskell-build-system)
     (arguments `(#:tests? #f)) ; TODO: Fails to connect to server.
     (inputs
-      `(("ghc-attoparsec" ,ghc-attoparsec)
-        ("ghc-base16-bytestring" ,ghc-base16-bytestring)
-        ("ghc-blaze-builder" ,ghc-blaze-builder)
-        ("ghc-mysql" ,ghc-mysql)
-        ("ghc-pcre-light" ,ghc-pcre-light)
-        ("ghc-old-locale" ,ghc-old-locale)
-        ("ghc-blaze-textual" ,ghc-blaze-textual)
-        ("openssl" ,openssl)
-        ("zlib" ,zlib)))
+     `(("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-mysql" ,ghc-mysql)
+       ("ghc-pcre-light" ,ghc-pcre-light)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-blaze-textual" ,ghc-blaze-textual)
+       ("openssl" ,openssl)
+       ("zlib" ,zlib)))
     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
     (home-page "https://github.com/paul-rouse/mysql-simple")
-    (synopsis "A mid-level MySQL client library.")
+    (synopsis "Mid-level MySQL client library")
     (description
-      "A mid-level client library for the MySQL database, intended to be fast and easy to use. . /Important licensing note/: This library is BSD-licensed under the terms of the MySQL FOSS License Exception <http://www.mysql.com/about/legal/licensing/foss-exception/>. . Since this library links against the GPL-licensed @mysqlclient@ library, a non-open-source application that uses it /may/ be subject to the terms of the GPL.")
+     "This library implements mid-level Haskell bindings to the MySQL
+@code{mysqlclient} client library.  It is aimed at speed and ease of use.")
     (license license:bsd-3)))
 
 (define-public ghc-persistent-qq
@@ -16163,76 +16273,81 @@ (define-public ghc-persistent-qq
     (name "ghc-persistent-qq")
     (version "2.12.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/persistent-qq/persistent-qq-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1dvniapxjaw2vmdqd5cplwxdxiy2l6z6gns8gp3ci3rn3xp0pf6p"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent-qq/persistent-qq-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1dvniapxjaw2vmdqd5cplwxdxiy2l6z6gns8gp3ci3rn3xp0pf6p"))))
     (build-system haskell-build-system)
     (inputs
-      `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
-        ("ghc-persistent" ,ghc-persistent)))
+     `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
+       ("ghc-persistent" ,ghc-persistent)))
     (native-inputs
-      `(("ghc-hunit" ,ghc-hunit)
-        ("ghc-aeson" ,ghc-aeson)
-        ("ghc-fast-logger" ,ghc-fast-logger)
-        ("ghc-hspec" ,ghc-hspec)
-        ("ghc-monad-logger" ,ghc-monad-logger)
-        ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)
-        ("ghc-resourcet" ,ghc-resourcet)
-        ("ghc-unliftio" ,ghc-unliftio)))
-    (home-page "https://github.com/yesodweb/persistent#readme")
-    (synopsis "Provides a quasi-quoter for raw SQL for persistent")
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-unliftio" ,ghc-unliftio)))
+    (home-page "https://github.com/yesodweb/persistent")
+    (synopsis "Quasi-quoter for raw SQL for @code{ghc-persistent}")
     (description
-      "Please see README and API docs at <http://www.stackage.org/package/persistent>.")
-    (license license:expat)))
+     "This package provides a quasi-quoter for raw @acronym{SQL, Structured Query
+Language} for @code{ghc-persistent}."
+    (license license:expat))))
 
 (define-public ghc-persistent-mysql
   (package
     (name "ghc-persistent-mysql")
     (version "2.13.0.2")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/persistent-mysql/persistent-mysql-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent-mysql/persistent-mysql-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732"))))
     (build-system haskell-build-system)
     (arguments `(#:tests? #f)) ; TODO: Fails to import MaybeFieldDefsTest.
     (inputs
-      `(("ghc-persistent" ,ghc-persistent)
-        ("ghc-aeson" ,ghc-aeson)
-        ("ghc-blaze-builder" ,ghc-blaze-builder)
-        ("ghc-conduit" ,ghc-conduit)
-        ("ghc-monad-logger" ,ghc-monad-logger)
-        ("ghc-mysql" ,ghc-mysql)
-        ("ghc-mysql-simple" ,ghc-mysql-simple)
-        ("ghc-resourcet" ,ghc-resourcet)
-        ("ghc-resource-pool" ,ghc-resource-pool)
-        ("ghc-unliftio-core" ,ghc-unliftio-core)
-        ("openssl" ,openssl)
-        ("zlib" ,zlib)))
+     `(("ghc-persistent" ,ghc-persistent)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-mysql" ,ghc-mysql)
+       ("ghc-mysql-simple" ,ghc-mysql-simple)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-resource-pool" ,ghc-resource-pool)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("openssl" ,openssl)
+       ("zlib" ,zlib)))
     (native-inputs
-      `(("ghc-fast-logger" ,ghc-fast-logger)
-        ("ghc-hspec" ,ghc-hspec)
-        ("ghc-http-api-data" ,ghc-http-api-data)
-        ("ghc-hunit" ,ghc-hunit)
-        ("ghc-path-pieces" ,ghc-path-pieces)
-        ("ghc-persistent-qq" ,ghc-persistent-qq)
-        ("ghc-persistent-test" ,ghc-persistent-test)
-        ("ghc-quickcheck" ,ghc-quickcheck)
-        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+     `(("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-http-api-data" ,ghc-http-api-data)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-path-pieces" ,ghc-path-pieces)
+       ("ghc-persistent-qq" ,ghc-persistent-qq)
+       ("ghc-persistent-test" ,ghc-persistent-test)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
     (home-page "http://www.yesodweb.com/book/persistent")
     (synopsis
-      "Backend for the persistent library using MySQL database server.")
+     "Backend for the @code{ghc-persistent} library using MySQL database server")
     (description
-      "This package contains a backend for persistent using the MySQL database server.  Internally it uses the @mysql-simple@ and @mysql@ packages in order to access the database. . This package supports only MySQL 5.1 and above.  However, it has been tested only on MySQL 5.5. Only the InnoDB storage engine is officially supported. . Known problems: . * This package does not support statements inside other statements.")
+     "This package contains a backend for @code{ghc-persistent} using the MySQL database
+server.  Internally it uses the @code{ghc-mysql-simple} and @code{mysql} packages in order
+to access the database.  This package supports only MySQL 5.1 and above.
+However, it has been tested only on MySQL 5.5.  Only the InnoDB storage engine
+is officially supported.")
     (license license:expat)))
 
 (define-public ghc-hspec-expectations-lifted
@@ -16240,19 +16355,21 @@ (define-public ghc-hspec-expectations-lifted
     (name "ghc-hspec-expectations-lifted")
     (version "0.10.0")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/hspec-expectations-lifted/hspec-expectations-lifted-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0a1qwz0n80lph8m9cq6cb06m8bsmqgg8ifx0acpylvrrkd8g3k92"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hspec-expectations-lifted/hspec-expectations-lifted-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0a1qwz0n80lph8m9cq6cb06m8bsmqgg8ifx0acpylvrrkd8g3k92"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-hspec-expectations" ,ghc-hspec-expectations)))
-    (home-page "http://hackage.haskell.org/package/hspec-expectations-lifted")
-    (synopsis "A version of hspec-expectations generalized to MonadIO")
-    (description "A version of hspec-expectations generalized to MonadIO")
+    (home-page "https://hackage.haskell.org/package/hspec-expectations-lifted")
+    (synopsis "Version of @code{ghc-hspec-expectations} generalized to @code{MonadIO}")
+    (description
+     "This package provides a version of @code{ghc-hspec-expectations} generalized
+to @code{MonadIO}.")
     (license license:expat)))
 
 (define-public ghc-string-conversions
@@ -16260,25 +16377,26 @@ (define-public ghc-string-conversions
     (name "ghc-string-conversions")
     (version "0.4.0.1")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/string-conversions/string-conversions-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "150rdank90h7v08x0wq4dffjbxv2daf5v9sqfs5mab76kinwxg26"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/string-conversions/string-conversions-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "150rdank90h7v08x0wq4dffjbxv2daf5v9sqfs5mab76kinwxg26"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-utf8-string" ,ghc-utf8-string)))
     (native-inputs
-      `(("hspec-discover" ,hspec-discover)
-        ("ghc-hspec" ,ghc-hspec)
-        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
-        ("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page "https://github.com/soenkehahn/string-conversions#readme")
-    (synopsis "Simplifies dealing with different types for strings")
+     `(("hspec-discover" ,hspec-discover)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/soenkehahn/string-conversions")
+    (synopsis "Simplify dealing with different types for strings")
     (description
-      "Provides a simple type class for converting values of different string types into values of other string types.")
+     "This package provides a simple type class for converting values of different
+string types into values of other string types.")
     (license license:bsd-3)))
 
 (define-public ghc-postgresql-libpq
@@ -16286,23 +16404,26 @@ (define-public ghc-postgresql-libpq
     (name "ghc-postgresql-libpq")
     (version "0.9.4.3")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/postgresql-libpq/postgresql-libpq-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "1gfnhc5pibn7zmifdf2g0c112xrpzsk756ln2kjzqljkspf4dqp3"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/postgresql-libpq/postgresql-libpq-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1gfnhc5pibn7zmifdf2g0c112xrpzsk756ln2kjzqljkspf4dqp3"))))
     (build-system haskell-build-system)
     (arguments
-      `(#:cabal-revision
-        ("1" "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2")))
+     `(#:cabal-revision
+       ("1" "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2")))
     (inputs `(("postgresql" ,postgresql)))
     (home-page "https://github.com/haskellari/postgresql-libpq")
-    (synopsis "low-level binding to libpq")
+    (synopsis "Low-level bindings to @code{libpq}")
     (description
-      "This is a binding to libpq: the C application programmer's interface to PostgreSQL. libpq is a set of library functions that allow client programs to pass queries to the PostgreSQL backend server and to receive the results of these queries.")
+     "This package provides bindings to @code{libpq}: the C application
+programmer's interface to PostgreSQL.  @code{libpq} is a set of library
+functions that allow client programs to pass queries to the PostgreSQL backend
+server and to receive the results of these queries.")
     (license license:bsd-3)))
 
 (define-public ghc-postgresql-simple
@@ -16310,44 +16431,45 @@ (define-public ghc-postgresql-simple
     (name "ghc-postgresql-simple")
     (version "0.6.4")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/postgresql-simple/postgresql-simple-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d"))))
-    (build-system haskell-build-system)
-    (inputs
-      `(("ghc-time-compat" ,ghc-time-compat)
-        ("ghc-aeson" ,ghc-aeson)
-        ("ghc-attoparsec" ,ghc-attoparsec)
-        ("ghc-bytestring-builder" ,ghc-bytestring-builder)
-        ("ghc-case-insensitive" ,ghc-case-insensitive)
-        ("ghc-hashable" ,ghc-hashable)
-        ("ghc-only" ,ghc-only)
-        ("ghc-postgresql-libpq" ,ghc-postgresql-libpq)
-        ("ghc-scientific" ,ghc-scientific)
-        ("ghc-uuid-types" ,ghc-uuid-types)
-        ("ghc-vector" ,ghc-vector)))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/postgresql-simple/postgresql-simple-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-time-compat" ,ghc-time-compat)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-only" ,ghc-only)
+       ("ghc-postgresql-libpq" ,ghc-postgresql-libpq)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-uuid-types" ,ghc-uuid-types)
+       ("ghc-vector" ,ghc-vector)))
     (native-inputs
-      `(("ghc-inspection-testing" ,ghc-inspection-testing)
-        ("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-        ("ghc-base16-bytestring" ,ghc-base16-bytestring)
-        ("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
-        ("ghc-hunit" ,ghc-hunit)
-        ("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-golden" ,ghc-tasty-golden)
-        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+     `(("ghc-inspection-testing" ,ghc-inspection-testing)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-golden" ,ghc-tasty-golden)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
     (arguments
-      `(#:cabal-revision
-        ("2" "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv")))
+     `(#:cabal-revision
+       ("2" "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv")))
     (home-page "http://hackage.haskell.org/package/postgresql-simple")
     (synopsis "Mid-Level PostgreSQL client library")
     (description
-      "Mid-Level PostgreSQL client library, forked from mysql-simple.")
+     "This package provides a mid-Level PostgreSQL client library, forked from
+@code{ghc-mysql-simple}.")
     (license license:bsd-3)))
 
 (define-public ghc-persistent-postgresql
@@ -16355,47 +16477,49 @@ (define-public ghc-persistent-postgresql
     (name "ghc-persistent-postgresql")
     (version "2.13.1.0")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/persistent-postgresql/persistent-postgresql-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "05bj3b7kdwaba3szrrsmafxr6vcnvdhq20jk5xx348jnf2flkw0i"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/persistent-postgresql/persistent-postgresql-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "05bj3b7kdwaba3szrrsmafxr6vcnvdhq20jk5xx348jnf2flkw0i"))))
     (build-system haskell-build-system)
     (arguments `(#:tests? #f)) ; TODO: Cannot import MaybeFieldDefsTest.
     (inputs
-      `(("ghc-persistent" ,ghc-persistent)
-        ("ghc-aeson" ,ghc-aeson)
-        ("ghc-attoparsec" ,ghc-attoparsec)
-        ("ghc-blaze-builder" ,ghc-blaze-builder)
-        ("ghc-conduit" ,ghc-conduit)
-        ("ghc-monad-logger" ,ghc-monad-logger)
-        ("ghc-postgresql-simple" ,ghc-postgresql-simple)
-        ("ghc-postgresql-libpq" ,ghc-postgresql-libpq)
-        ("ghc-resourcet" ,ghc-resourcet)
-        ("ghc-resource-pool" ,ghc-resource-pool)
-        ("ghc-string-conversions" ,ghc-string-conversions)
-        ("ghc-unliftio-core" ,ghc-unliftio-core)
-        ("ghc-unliftio" ,ghc-unliftio)))
+     `(("ghc-persistent" ,ghc-persistent)
+       ("ghc-aeson" ,ghc-aeson)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-monad-logger" ,ghc-monad-logger)
+       ("ghc-postgresql-simple" ,ghc-postgresql-simple)
+       ("ghc-postgresql-libpq" ,ghc-postgresql-libpq)
+       ("ghc-resourcet" ,ghc-resourcet)
+       ("ghc-resource-pool" ,ghc-resource-pool)
+       ("ghc-string-conversions" ,ghc-string-conversions)
+       ("ghc-unliftio-core" ,ghc-unliftio-core)
+       ("ghc-unliftio" ,ghc-unliftio)))
     (native-inputs
-      `(("ghc-persistent-qq" ,ghc-persistent-qq)
-        ("ghc-persistent-test" ,ghc-persistent-test)
-        ("ghc-fast-logger" ,ghc-fast-logger)
-        ("ghc-hunit" ,ghc-hunit)
-        ("ghc-hspec" ,ghc-hspec)
-        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
-        ("ghc-hspec-expectations-lifted" ,ghc-hspec-expectations-lifted)
-        ("ghc-quickcheck" ,ghc-quickcheck)
-        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
-        ("ghc-path-pieces" ,ghc-path-pieces)
-        ("ghc-http-api-data" ,ghc-http-api-data)
-        ("ghc-unordered-containers" ,ghc-unordered-containers)
-        ("ghc-vector" ,ghc-vector)))
+     `(("ghc-persistent-qq" ,ghc-persistent-qq)
+       ("ghc-persistent-test" ,ghc-persistent-test)
+       ("ghc-fast-logger" ,ghc-fast-logger)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-hspec-expectations-lifted" ,ghc-hspec-expectations-lifted)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("ghc-path-pieces" ,ghc-path-pieces)
+       ("ghc-http-api-data" ,ghc-http-api-data)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-vector" ,ghc-vector)))
     (home-page "http://www.yesodweb.com/book/persistent")
-    (synopsis "Backend for the persistent library using postgresql.")
-    (description "Based on the postgresql-simple package")
+    (synopsis "Backend for the @code{ghc-persistent library} using Postgresql")
+    (description
+     "This package provides a backend for the @code{ghc-persistent} library
+using the @code{ghc-postgresql-simple} package.")
     (license license:expat)))
 
 (define-public ghc-filtrable
@@ -16403,23 +16527,23 @@ (define-public ghc-filtrable
     (name "ghc-filtrable")
     (version "0.1.6.0")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/filtrable/filtrable-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "058jl7wjaxzvcayc9qzpikxvi9x42civ4sb02jh66rcvpndbfh5y"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/filtrable/filtrable-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "058jl7wjaxzvcayc9qzpikxvi9x42civ4sb02jh66rcvpndbfh5y"))))
     (build-system haskell-build-system)
     (arguments `(#:tests? #f)) ; TODO: Needs tasty >=1.3.1 && <1.4
     (native-inputs
-      `(("ghc-smallcheck" ,ghc-smallcheck)
-        ("ghc-tasty" ,ghc-tasty)
-        ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)))
+     `(("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)))
     (home-page "https://github.com/strake/filtrable.hs")
     (synopsis "Class of filtrable containers")
-    (description "See \"Data.Filtrable\".")
+    (description "This package provides filtrable containers.")
     (license license:bsd-3)))
 
 (define-public ghc-filelock
@@ -16427,20 +16551,22 @@ (define-public ghc-filelock
     (name "ghc-filelock")
     (version "0.1.1.5")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/filelock/filelock-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "06a44i7a956d7xkk2na4090xj2a7b7a228pk4spmccs4x20ymssh"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/filelock/filelock-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "06a44i7a956d7xkk2na4090xj2a7b7a228pk4spmccs4x20ymssh"))))
     (build-system haskell-build-system)
-    (native-inputs `(("ghc-async" ,ghc-async) ("ghc-async" ,ghc-async)))
-    (home-page "http://github.com/takano-akio/filelock")
-    (synopsis "Portable interface to file locking (flock / LockFileEx)")
+    (native-inputs
+     `(("ghc-async" ,ghc-async)
+       ("ghc-async" ,ghc-async)))
+    (home-page "https://github.com/takano-akio/filelock")
+    (synopsis "Portable interface to file locking")
     (description
-      "This package provides an interface to Windows and Unix file locking functionalities.")
+     "This package provides an interface to file locking functionalities.")
     (license license:public-domain)))
 
 (define-public ghc-hsyaml-aeson
@@ -16466,11 +16592,20 @@ (define-public ghc-hsyaml-aeson
     (arguments
      `(#:cabal-revision
        ("3" "0vhdndyj5f07vvvnssn5ybdja5wmaydq0n2lfpihvdg4dkhczrx2")))
-    (home-page "http://hackage.haskell.org/package/HsYAML-aeson")
-    (synopsis "JSON to YAML Adapter")
-    (description
-     "The [YAML 1.2](https://yaml.org/spec/1.2/spec.html) format provides a much richer data-model and feature-set than the [JavaScript Object Notation (JSON)](https://tools.ietf.org/html/rfc7159) format. However, sometimes it's desirable to ignore the extra capabilities and treat YAML as if it was merely a more convenient markup format for humans to write JSON data. To this end this module provides a compatibility layer atop [HsYAML](https://hackage.haskell.org/package/HsYAML) which allows decoding YAML documents in the more limited JSON data-model while also providing convenience by reusing [aeson](https://hackage.haskell.org/package/aeson)'s 'FromJSON' instances for decoding the YAML data into native Haskell data types.")
-    (license #f)))
+    (home-page "https://hackage.haskell.org/package/HsYAML-aeson")
+    (synopsis "JSON to YAML adapter")
+    (description
+     "The @uref{https://yaml.org/spec/1.2/spec.html, YAML 1.2} format provides
+a much richer data-model and feature-set than the
+@uref{https://tools.ietf.org/html/rfc7159, @acronym{JavaScript Object
+Notation, JSON} format.  However, sometimes it's desirable to ignore the extra
+capabilities and treat YAML as if it was merely a more convenient markup
+format for humans to write JSON data.  To this end this module provides a
+compatibility layer atop @code{ghc-hsyaml} ,which allows decoding YAML
+documents in the more limited JSON data-model while also providing convenience
+by reusing @code{ghc-aeson}'s @code{FromJSON instances for decoding the YAML
+data into native Haskell data types.")
+    (license license:gpl2+)))
 
 (define-public ghc-lukko
   (package
@@ -16496,10 +16631,21 @@ (define-public ghc-lukko
     (arguments
      `(#:cabal-revision
        ("1" "0mmq1q82mrbayiij0p8wdnkf0j8drmq1iibg8kn4cak3nrn9pd1d")))
-    (home-page "http://hackage.haskell.org/package/lukko")
+    (home-page "https://hackage.haskell.org/package/lukko")
     (synopsis "File locking")
     (description
-     "This package provides access to platform dependent file locking APIs: . * <https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html Open file descriptor locking> on Linux (\"Lukko.OFD\") * BSD-style @flock(2)@ locks on UNIX platforms (\"Lukko.FLock\") * Windows locking via <https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-lockfilee LockFileEx> (\"Lukko.Windows\") * No-op locking, which throws exceptions (\"Lukko.NoOp\") * \"Lukko\" module exports the best option for the target platform with uniform API. . There are alternative file locking packages: . * \"GHC.IO.Handle.Lock\" in @base >= 4.10@ is good enough for most use cases. However, uses only 'Handle's so these locks cannot be used for intra-process locking. (You should use e.g. 'MVar' in addition). . * <https://hackage.haskell.org/package/filelock filelock> doesn't support OFD locking. . /Lukko/ means lock in Finnish. . Submodules \"Lukko.OFD\", \"Lukko.Windows\" etc are available based on following conditions. . @ if os(windows) \\  cpp-options: -DHAS_WINDOWS_LOCK . elif (os(linux) && flag(ofd-locking)) \\  cpp-options: -DHAS_OFD_LOCKING \\  cpp-options: -DHAS_FLOCK . elif !(os(solaris) || os(aix)) \\  cpp-options: -DHAS_FLOCK @ . \"Lukko.FLock\" is available on not (Windows or Solaris or AIX). \"Lukko.NoOp\" is always available.")
+     "This package provides access to platform dependent file locking APIs.  There
+are alternative file locking packages:
+
+@itemize
+@item @code{GHC.IO.Handle.Lock} in @codebase >= 4.10} is good enough for most
+use cases.  However, uses only @code{Handle}s so these locks cannot be used
+for intra-process locking.
+
+@item @code{ghc-filelock} doesn't support @acronym{OFD, open file descriptor}
+locking.
+@end itemize")
+
     (license (list license:gpl2+ license:bsd-3))))
 
 (define-public ghc-dec
@@ -16507,19 +16653,28 @@ (define-public ghc-dec
     (name "ghc-dec")
     (version "0.0.4")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/dec/dec-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/dec/dec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc"))))
     (build-system haskell-build-system)
     (home-page "https://github.com/phadej/vec")
-    (synopsis "Decidable propositions.")
+    (synopsis "Decidable propositions")
     (description
-      "This package provides a @Dec@ type. . @ type Neg a = a -> Void . data Dec a \\    = Yes a \\    | No (Neg a) @")
+     "This package provides a @code{Dec} type for representing deciable
+relations.
+
+@example
+type Neg a = a -> Void
+
+data Dec a
+    = Yes a
+    | No (Neg a)
+@end example")
     (license license:bsd-3)))
 
 (define-public ghc-singleton-bool
@@ -16527,22 +16682,22 @@ (define-public ghc-singleton-bool
     (name "ghc-singleton-bool")
     (version "0.1.5")
     (source
-      (origin
-        (method url-fetch)
-        (uri (string-append
-               "https://hackage.haskell.org/package/singleton-bool/singleton-bool-"
-               version
-               ".tar.gz"))
-        (sha256
-          (base32 "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0"))))
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/singleton-bool/singleton-bool-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0"))))
     (build-system haskell-build-system)
     (inputs `(("ghc-dec" ,ghc-dec)))
     (arguments
-      `(#:cabal-revision
-        ("3" "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x")))
-    (home-page "https://github.com/phadej/singleton-bool#readme")
-    (synopsis "Type level booleans")
+     `(#:cabal-revision
+       ("3" "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x")))
+    (home-page "https://github.com/phadej/singleton-bool")
+    (synopsis "Type-level booleans")
     (description
-      "Type level booleans. . @singletons@ package provides similar functionality, but it has tight dependency constraints.")
+     "This package provides Type-level booleans.")
     (license license:bsd-3)))
 
diff --git a/gnu/packages/purescript.scm b/gnu/packages/purescript.scm
index 1b24458a8c..ba8cbcd926 100644
--- a/gnu/packages/purescript.scm
+++ b/gnu/packages/purescript.scm
@@ -160,9 +160,10 @@ (define-public ghc-purescript-cst
         ("ghc-serialise" ,ghc-serialise)
         ("ghc-vector" ,ghc-vector)))
     (native-inputs `(("ghc-happy" ,ghc-happy)))
-    (home-page "http://www.purescript.org/")
+    (home-page "https://www.purescript.org/")
     (synopsis "PureScript Programming Language Concrete Syntax Tree")
-    (description "The parser for the PureScript programming language.")
+    (description
+     "This package implements parser for the PureScript programming language.")
     (license license:bsd-3)))
 
 (define-public ghc-optparse-applicative-0.15.1.0

base-commit: c1522b280137df2f670f47fa1e682e610406bb39
-- 
2.33.0

