[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
branch wip-haskell updated: SQUASH: gnu: Fix auto-imported packages’ des
|
From: |
guix-commits |
|
Subject: |
branch wip-haskell updated: SQUASH: gnu: Fix auto-imported packages’ descriptions. |
|
Date: |
Sat, 02 Oct 2021 05:36:30 -0400 |
This is an automated email from the git hooks/post-receive script.
lbraun pushed a commit to branch wip-haskell
in repository guix.
The following commit(s) were added to refs/heads/wip-haskell by this push:
new e9047ca SQUASH: gnu: Fix auto-imported packages’ descriptions.
e9047ca is described below
commit e9047cace8124f63478760680678fe8788ecc7cf
Author: Lars-Dominik Braun <lars@6xq.net>
AuthorDate: Sat Oct 2 11:27:47 2021 +0200
SQUASH: gnu: Fix auto-imported packages’ descriptions.
---
gnu/packages/haskell-check.scm | 18 +-
gnu/packages/haskell-web.scm | 5 +-
gnu/packages/haskell-xyz.scm | 1339 ++++++++++++++++++++++------------------
gnu/packages/purescript.scm | 5 +-
4 files changed, 765 insertions(+), 602 deletions(-)
diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm
index 42ec3e9..c9ba1be 100644
--- a/gnu/packages/haskell-check.scm
+++ b/gnu/packages/haskell-check.scm
@@ -1176,9 +1176,10 @@ these constraints more cleanly.")
("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 @@ these constraints more cleanly.")
`(#: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 @@ these constraints more cleanly.")
`(#: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 76c5e90..ad8713d 100644
--- a/gnu/packages/haskell-web.scm
+++ b/gnu/packages/haskell-web.scm
@@ -2310,8 +2310,9 @@ aims to be compliant with
@url{https://www.w3.org/TR/cors}.";)
(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 3df5320..c0a442a 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -6655,9 +6655,8 @@ example code on the home page for a quick introduction.")
`(("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 @@ supported systems.")
(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 @@ In particular, this library supports working with POSIX
files that have paths
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 @@ Zstandard compression algorithm, a fast lossless
compression algorithm
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 instanc [...]
+ "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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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@ [...]
+ "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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 availab [...]
+ "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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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,20 +16051,23 @@ compression ratios.")
(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.")
+ "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
@@ -15979,28 +16075,29 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
("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 @@ compression ratios.")
(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 @@ compression ratios.")
(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,31 +16273,32 @@ compression ratios.")
(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>.")
+ "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
@@ -16195,44 +16306,48 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 all [...]
- (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 @@ compression ratios.")
(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\" mo [...]
+ "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 @@ compression ratios.")
(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 @@ compression ratios.")
(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 1b24458..ba8cbcd 100644
--- a/gnu/packages/purescript.scm
+++ b/gnu/packages/purescript.scm
@@ -160,9 +160,10 @@ expressive types, inspired by Haskell and compiling to
JavaScript.")
("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
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- branch wip-haskell updated: SQUASH: gnu: Fix auto-imported packages’ descriptions.,
guix-commits <=