From 49a320aaa6fb4c20d6b30c56c35a8c7ffceed822 Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Sun, 15 Jan 2023 10:09:44 +0100 Subject: Upgrade Haskell packages. Script-aided bulk change. --- gnu/packages/haskell-xyz.scm | 9091 +++++++++++++++++++++++------------------- 1 file changed, 4904 insertions(+), 4187 deletions(-) (limited to 'gnu/packages/haskell-xyz.scm') diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm index aa8be12a88..69ff954ce4 100644 --- a/gnu/packages/haskell-xyz.scm +++ b/gnu/packages/haskell-xyz.scm @@ -55,6 +55,7 @@ (define-module (gnu packages haskell-xyz) #:use-module (gnu packages emacs) #:use-module (gnu packages freedesktop) #:use-module (gnu packages gl) + #:use-module (gnu packages glib) #:use-module (gnu packages graphviz) #:use-module (gnu packages gtk) #:use-module (gnu packages haskell) @@ -73,6 +74,7 @@ (define-module (gnu packages haskell-xyz) #:use-module (gnu packages sdl) #:use-module (gnu packages serialization) #:use-module (gnu packages tls) + #:use-module (gnu packages version-control) #:use-module (gnu packages xml) #:use-module (gnu packages xorg) #:use-module (guix build-system haskell) @@ -145,24 +147,25 @@ (define-public ghc-abstract-par (define-public ghc-active (package (name "ghc-active") - (version "0.2.0.15") - (source - (origin - (method url-fetch) - (uri (hackage-uri "active" version)) - (sha256 - (base32 - "019xr66pahsssqr2hybs88mga4qshv1vmd22j7624wqafqm57d74")))) + (version "0.2.0.16") + (source (origin + (method url-fetch) + (uri (hackage-uri "active" version)) + (sha256 + (base32 + "1fz2rsyk41p9f9avlmn9lrdmii5alv88lkw677mw8q6mzyxpw67i")))) (build-system haskell-build-system) (properties '((upstream-name . "active"))) - (inputs - (list ghc-vector ghc-semigroups ghc-semigroupoids ghc-lens - ghc-linear)) - (native-inputs - (list ghc-quickcheck)) - (home-page "https://hackage.haskell.org/package/active") + (inputs (list ghc-vector ghc-semigroups ghc-semigroupoids ghc-lens + ghc-linear)) + (native-inputs (list ghc-quickcheck)) + (arguments + `(#:cabal-revision ("1" + "0cyfwrr5c14f5rgrf8dv7i8qsrnmnzigw0xp6l88kfxd61zhk4n8"))) + (home-page "http://hackage.haskell.org/package/active") (synopsis "Abstractions for animation") - (description "This package defines an @code{Active} abstraction for + (description + "This package defines an @code{Active} abstraction for time-varying values with finite start and end times. It is used for describing animations within the @url{https://archives.haskell.org/projects.haskell.org/diagrams/, @@ -172,38 +175,33 @@ (define-public ghc-active (define-public ghc-adjunctions (package (name "ghc-adjunctions") - (version "4.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "adjunctions" version)) - (sha256 - (base32 - "1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h")))) + (version "4.4.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "adjunctions" version)) + (sha256 + (base32 + "06354xzgf78jl4g1xw11rp74gi7zh94rgvsji7ma1g0hp26myyql")))) (build-system haskell-build-system) (properties '((upstream-name . "adjunctions"))) - (arguments - `(#:cabal-revision - ("2" "1yfsjx7dqikg3hvld7i91xfsg5lawmr5980lvfd794sybmgxsf17"))) - (inputs - (list ghc-profunctors - ghc-comonad - ghc-contravariant - ghc-distributive - ghc-free - ghc-tagged - ghc-semigroupoids - ghc-semigroups - ghc-transformers-compat - ghc-void)) - (native-inputs - (list ghc-generic-deriving ghc-hspec hspec-discover)) - (home-page "https://github.com/ekmett/adjunctions/") + (inputs (list ghc-comonad + ghc-contravariant + ghc-distributive + ghc-free + ghc-profunctors + ghc-tagged + ghc-semigroupoids + ghc-semigroups + ghc-transformers-compat + ghc-void)) + (native-inputs (list ghc-generic-deriving ghc-hspec hspec-discover)) + (home-page "http://github.com/ekmett/adjunctions/") (synopsis "Adjunctions and representable functors") (description "This library provides adjunctions and representable functors for Haskell.") (license license:bsd-3))) +;; Deprecated package. (define-public ghc-aeson-compat (package (name "ghc-aeson-compat") @@ -234,6 +232,9 @@ (define-public ghc-aeson-compat ghc-quickcheck ghc-quickcheck-instances ghc-base-orphans)) + (arguments + `(#:cabal-revision ("4" + "001w7pck3q5k4cnx53npllil5cblkg1ssqza4s9v347dfih3zmss"))) (home-page "https://github.com/phadej/aeson-compat") (synopsis "Compatibility layer for ghc-aeson") (description "This Haskell package provides compatibility layer for @@ -243,14 +244,14 @@ (define-public ghc-aeson-compat (define-public ghc-aeson-diff (package (name "ghc-aeson-diff") - (version "1.1.0.9") + (version "1.1.0.13") (source (origin (method url-fetch) (uri (hackage-uri "aeson-diff" version)) (sha256 (base32 - "18bm4qyjjwgrr6dxc4y0vai0z6qgrh2lcqb4jrr4xqs4cxrlwr92")))) + "0sd13q0nj0k1sam5xfj6dcjcki18f375sa69hm6i4xc6snfhn3cb")))) (build-system haskell-build-system) (properties '((upstream-name . "aeson-diff"))) (inputs @@ -271,7 +272,20 @@ (define-public ghc-aeson-diff ghc-quickcheck ghc-doctest hlint)) - (home-page "https://github.com/thsutton/aeson-diff") + (arguments + `(#:cabal-revision ("1" + "1028adallw7bm72948lj322bb5a99gfs0qc1j0pnm8hryp6n7ma5") + #:tests? #f ; Needs doctest Setup.hs + #:phases + (modify-phases %standard-phases + ;; Tries to use non-existent doctest API. + (add-after 'unpack 'disable-doctest + (lambda _ + (with-output-to-file "Setup.hs" + (lambda _ + (display + "import Distribution.Simple\nmain = defaultMain\n")))))))) + (home-page "https://github.com/thsutton/aeson-diff") (synopsis "Extract and apply patches to JSON documents") (description "This is a small library for working with changes to JSON documents. It includes a library and two command-line executables in the @@ -282,30 +296,17 @@ (define-public ghc-aeson-diff (define-public ghc-alex (package (name "ghc-alex") - (version "3.2.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "alex" version)) - (sha256 - (base32 - "042lrkn0dbpjn5ivj6j26jzb1fwrj8c1aj18ykxja89isg0hiali")))) + (version "3.2.7.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "alex" version)) + (sha256 + (base32 + "1v0vm1l4xvybzwj1p6j5j58yiw5nhbnx7yxjnpyjy6wggsig3llv")))) (build-system haskell-build-system) (properties '((upstream-name . "alex"))) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-before 'check 'set-check-variables - (lambda _ - (setenv "PATH" (string-append (getcwd) "/dist/build/alex:" - (getenv "PATH"))) - (setenv "alex_datadir" (string-append (getcwd) "/data"))))))) - (inputs (list ghc-quickcheck)) - (native-inputs - (list which)) - (home-page "https://www.haskell.org/alex/") - (synopsis - "Tool for generating lexical analysers in Haskell") + (home-page "http://www.haskell.org/alex/") + (synopsis "Tool for generating lexical analysers in Haskell") (description "Alex is a tool for generating lexical analysers in Haskell. It takes a description of tokens based on regular expressions and generates a Haskell @@ -386,21 +387,20 @@ (define-public ghc-annotated-wl-pprint (define-public ghc-ansi-terminal (package (name "ghc-ansi-terminal") - (version "0.11") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ansi-terminal" version)) - (sha256 - (base32 - "14rp62c7y79n9dmmi7m0l9n3mcq6dh331b4yyyrivm5da6g1nqf6")))) + (version "0.11.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "ansi-terminal" version)) + (sha256 + (base32 + "098f8bdxqmgxaz8y87s6b6bshsq950zq0b75rmbihp2k1a7y963q")))) (build-system haskell-build-system) (properties '((upstream-name . "ansi-terminal"))) - (inputs - (list ghc-colour)) - (home-page "https://github.com/feuerbach/ansi-terminal") + (inputs (list ghc-colour)) + (home-page "https://github.com/UnkindPartition/ansi-terminal") (synopsis "ANSI terminal support for Haskell") - (description "This package provides ANSI terminal support for Haskell. It + (description + "This package provides ANSI terminal support for Haskell. It allows cursor movement, screen clearing, color output showing or hiding the cursor, and changing the title.") (license license:bsd-3))) @@ -465,6 +465,9 @@ (define-public ghc-assoc (properties '((upstream-name . "assoc"))) (inputs (list ghc-bifunctors ghc-tagged)) + (arguments + `(#:cabal-revision ("3" + "0mrb12dx316q4gxyn68x2rl8jq0gd77zffd12r8j1r41l0xd9f4k"))) (home-page "https://hackage.haskell.org/package/assoc") (synopsis @@ -492,6 +495,9 @@ (define-public ghc-async (list ghc-hashable)) (native-inputs (list ghc-hunit ghc-test-framework ghc-test-framework-hunit)) + (arguments + `(#:cabal-revision ("2" + "1j93w1krkadqijn59yjiws1366yhcn2mad1irqrk50in6l10k51b"))) (home-page "https://github.com/simonmar/async") (synopsis "Library to run IO operations asynchronously") (description "Async provides a library to run IO operations @@ -525,17 +531,14 @@ (define-public ghc-atomic-primops (define-public ghc-atomic-write (package (name "ghc-atomic-write") - (version "0.2.0.6") + (version "0.2.0.7") (source (origin (method url-fetch) - (uri (string-append - "https://hackage.haskell.org/package/atomic-write/atomic-write-" - version - ".tar.gz")) + (uri (hackage-uri "atomic-write" version)) (sha256 (base32 - "1xs3shwnlj8hmnm3q6jc8nv78z0481i5n4hrqqdmbpx8grvlnqyl")))) + "03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm")))) (build-system haskell-build-system) (properties `((upstream-name . "atomic-write"))) (inputs @@ -552,52 +555,28 @@ (define-public ghc-atomic-write permissions while atomically writing to a file.") (license license:expat))) -(define-public ghc-atomic-write-0.2.0.7 - (package - (inherit ghc-atomic-write) - (version "0.2.0.7") - (source - (origin - (inherit (package-source ghc-atomic-write)) - (uri (hackage-uri "atomic-write" version)) - (sha256 - (base32 - "03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm")))))) - (define-public ghc-attoparsec (package (name "ghc-attoparsec") - (version "0.13.2.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "attoparsec" version)) - (sha256 - (base32 - "0vv88m5m7ynjrg114psp4j4s69f1a5va3bvn293vymqrma7g7q11")))) + (version "0.14.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "attoparsec" version)) + (sha256 + (base32 + "0v4yjz4qi8bwhbyavqxlhsfb1iv07v10gxi64khmsmi4hvjpycrz")))) (build-system haskell-build-system) (properties '((upstream-name . "attoparsec"))) + (inputs (list ghc-scientific)) + (native-inputs (list ghc-quickcheck ghc-quickcheck-unicode ghc-tasty + ghc-tasty-quickcheck ghc-vector)) (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'patch-for-newer-quickcheck - (lambda _ - (substitute* "attoparsec.cabal" - (("QuickCheck >= 2\\.7 && < 2\\.10") - "QuickCheck >= 2.7 && < 2.12")) - ;; This test fails because of the newer QuickCheck: - ;; . - (substitute* "tests/QC/ByteString.hs" - ((", testProperty \"satisfyWith\" satisfyWith") - ""))))))) - (inputs - (list ghc-scientific)) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck - ghc-quickcheck-unicode ghc-vector)) - (home-page "https://github.com/bos/attoparsec") + `(#:cabal-revision ("2" + "00jyrn2asz1kp698l3fyh19xxxz4npf1993y041x9b9cq239smn0"))) + (home-page "https://github.com/bgamari/attoparsec") (synopsis "Fast combinator parsing for bytestrings and text") - (description "This library provides a fast parser combinator library, + (description + "This library provides a fast parser combinator library, aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats.") (license license:bsd-3))) @@ -615,21 +594,17 @@ (define-public ghc-attoparsec-bootstrap (define-public ghc-attoparsec-iso8601 (package (name "ghc-attoparsec-iso8601") - (version "1.0.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "attoparsec-iso8601" version)) - (sha256 - (base32 - "162gc101mwhmjbfhhv1wm3yvk2h4ra34wpw5x87735cfqxvjv582")))) + (version "1.0.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "attoparsec-iso8601" version)) + (sha256 + (base32 + "1zmj6v63xjj20ja50ffbi222yg513cnnqyxl76ybb4x98z9jld0k")))) (build-system haskell-build-system) (properties '((upstream-name . "attoparsec-iso8601"))) - (arguments - `(#:cabal-revision - ("2" "18557xy5gvkhj0sb35wwxmhqirkiqrkwm0y0pqygsr0aimccs5zm"))) (inputs (list ghc-attoparsec ghc-base-compat-batteries ghc-time-compat)) - (home-page "https://github.com/bos/aeson") + (home-page "https://github.com/haskell/aeson") (synopsis "Parse ISO 8601 dates") (description "Haskell library for parsing of ISO 8601 dates, originally from aeson.") @@ -659,27 +634,18 @@ (define-public ghc-auto-update (define-public ghc-aws (package (name "ghc-aws") - (version "0.22") + (version "0.23") (source (origin (method url-fetch) (uri (hackage-uri "aws" version)) (sha256 (base32 - "1l3f94mpih7slz37ikyjkyrwvlf110w87997d8sbnbd8glwlcb8r")))) + "0kfdj9hxjvziq1y74xj9mm17zcgwywpvp9c0i6gfd5malf4qxgg0")))) (build-system haskell-build-system) (properties '((upstream-name . "aws"))) (arguments `(#:tests? #f ; Tests require AWS credentials. - #:configure-flags (list "-fNetworkBSD") ; Use network-bsd. - #:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "aws.cabal" - (("(base16-bytestring)\\s+==\\s+0\\.1\\.\\*" all dep) - dep) - (("(base64-bytestring)\\s+==\\s+1\\.0\\.\\*" all dep) - dep))))))) + #:configure-flags (list "-fNetworkBSD"))) ; Use network-bsd. (inputs (list ghc-aeson ghc-attoparsec @@ -728,20 +694,19 @@ (define-public ghc-aws (define-public ghc-base16-bytestring (package (name "ghc-base16-bytestring") - (version "1.0.1.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "base16-bytestring" version)) - (sha256 - (base32 - "1ynnplw8iz3v5ld0xxgpxgasb0hg62x62wxxf5lx6lxyb15hmiy0")))) + (version "1.0.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "base16-bytestring" version)) + (sha256 + (base32 + "1167f9jaivnabn6kg2gc421ac9njb67fr4v0adbj3qph7qa92nhx")))) (build-system haskell-build-system) (properties '((upstream-name . "base16-bytestring"))) - (native-inputs - (list ghc-hunit ghc-quickcheck ghc-test-framework - ghc-test-framework-hunit ghc-test-framework-quickcheck2)) - (home-page "https://github.com/bos/base16-bytestring") + (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) + (home-page "http://github.com/haskell/base16-bytestring") (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings") (description "This package provides a Haskell library for working with base16-encoded @@ -751,17 +716,19 @@ (define-public ghc-base16-bytestring (define-public ghc-base64-bytestring (package (name "ghc-base64-bytestring") - (version "1.1.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "base64-bytestring" version)) - (sha256 - (base32 "1adcnkcx4nh3d59k94bkndj0wkgbvchz576qwlpaa7148a86q391")))) + (version "1.2.1.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "base64-bytestring" version)) + (sha256 + (base32 + "1ja9vkgnpkzaw8gz6sm5jmgha6wg3m1j281m0nv1w9yyxlqfvy7v")))) (build-system haskell-build-system) (properties '((upstream-name . "base64-bytestring"))) - (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. - (home-page "https://github.com/bos/base64-bytestring") + (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) + (home-page "https://github.com/haskell/base64-bytestring") (synopsis "Base64 encoding and decoding for ByteStrings") (description "This library provides fast base64 encoding and decoding for Haskell @code{ByteString}s.") @@ -770,46 +737,41 @@ (define-public ghc-base64-bytestring (define-public ghc-base-compat (package (name "ghc-base-compat") - (version "0.11.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "base-compat" version)) - (sha256 - (base32 - "1nyvkaij4m01jndw72xl8931czz1xp6jpnynpajabys2ahabb9jk")))) + (version "0.12.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "base-compat" version)) + (sha256 + (base32 + "1gah466nd6hkj716gwljfh0g270iaqy2rq2a1vw3di2s7a4dqam6")))) (build-system haskell-build-system) (properties '((upstream-name . "base-compat"))) - (outputs '("out" "static" "doc")) - (native-inputs - (list ghc-quickcheck ghc-hspec hspec-discover)) - (home-page "https://hackage.haskell.org/package/base-compat") + (home-page "http://hackage.haskell.org/package/base-compat") (synopsis "Haskell compiler compatibility library") - (description "This library provides functions available in later versions + (description + "This library provides functions available in later versions of base to a wider range of compilers, without requiring the use of CPP pragmas in your code.") - (license license:bsd-3))) + (license license:expat))) (define-public ghc-base-compat-batteries (package (name "ghc-base-compat-batteries") - (version "0.11.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "base-compat-batteries" version)) - (sha256 - (base32 - "08rh9nlm9ir28fm42xim06ga8qwdqdcvkbb5ckz99bwnmajndq1i")))) + (version "0.12.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "base-compat-batteries" version)) + (sha256 + (base32 + "16gbqng8556wqcvrmj3dmqxh9sxp7z6ixgv0j5sy017r0wp0ksgd")))) (build-system haskell-build-system) (properties '((upstream-name . "base-compat-batteries"))) - (inputs - (list ghc-base-compat)) - (native-inputs - (list ghc-hspec ghc-quickcheck hspec-discover)) - (home-page "https://hackage.haskell.org/package/base-compat-batteries") + (inputs (list ghc-base-compat)) + (native-inputs (list ghc-hspec ghc-quickcheck hspec-discover)) + (home-page "http://hackage.haskell.org/package/base-compat-batteries") (synopsis "base-compat with extra batteries") - (description "This library provides functions available in later + (description + "This library provides functions available in later versions of @code{base} to a wider range of compilers, without requiring you to use CPP pragmas in your code. This package provides the same API as the @code{base-compat} library, but depends on compatibility @@ -820,18 +782,16 @@ (define-public ghc-base-compat-batteries (define-public ghc-basement (package (name "ghc-basement") - (version "0.0.12") - (source - (origin - (method url-fetch) - (uri (hackage-uri "basement" version)) - (sha256 - (base32 - "12zsnxkgv86im2prslk6ddhy0zwpawwjc1h4ff63kpxp2xdl7i2k")))) + (version "0.0.15") + (source (origin + (method url-fetch) + (uri (hackage-uri "basement" version)) + (sha256 + (base32 + "1d2xj5dmjps7nc7rwp5s0kyjcg9v8xfql6ik4yk1d3affnvazhjn")))) (build-system haskell-build-system) (properties '((upstream-name . "basement"))) - (outputs '("out" "static" "doc")) - (home-page "https://github.com/haskell-foundation/foundation") + (home-page "https://github.com/haskell-foundation/foundation#readme") (synopsis "Basic primitives for Foundation starter pack") (description "This package contains basic primitives for the Foundation set of @@ -841,42 +801,48 @@ (define-public ghc-basement (define-public ghc-base-orphans (package (name "ghc-base-orphans") - (version "0.8.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "base-orphans" version)) - (sha256 - (base32 - "1lw1jhrrsdq7x9wr2bwkxq9mscidcad0n30kh9gfk8kgifl5xh9k")))) + (version "0.8.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "base-orphans" version)) + (sha256 + (base32 + "0iz4v4h2ydncdwfqzs8fd2qwl38dx0n94w5iymw2g4xy1mzxd3w8")))) (build-system haskell-build-system) (properties '((upstream-name . "base-orphans"))) - (native-inputs - (list ghc-quickcheck ghc-hspec hspec-discover)) - (home-page "https://hackage.haskell.org/package/base-orphans") + (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover)) + (home-page "https://github.com/haskell-compat/base-orphans#readme") (synopsis "Orphan instances for backwards compatibility") - (description "This package defines orphan instances that mimic instances + (description + "This package defines orphan instances that mimic instances available in later versions of base to a wider (older) range of compilers.") - (license license:bsd-3))) + (license license:expat))) + +(define-public ghc-base-orphans-bootstrap + (package + (inherit ghc-base-orphans) + (name "ghc-base-orphans-bootstrap") + (arguments '(#:tests? #f)) + (native-inputs '()) + (properties '((hidden? #t))))) (define-public ghc-base-prelude (package (name "ghc-base-prelude") - (version "1.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "base-prelude" version)) - (sha256 - (base32 - "0nn5v2y9kl7i3n21250m7cvn55lvkmzj22wx6q4kaag5ycwwczrs")))) + (version "1.6.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "base-prelude" version)) + (sha256 + (base32 + "0rbx6k85svqrkw5ixp2xal8bg6xrz729g7rrhkgsr3ixv38k943j")))) (build-system haskell-build-system) (properties '((upstream-name . "base-prelude"))) - (outputs '("out" "static" "doc")) (home-page "https://github.com/nikita-volkov/base-prelude") (synopsis "The most complete prelude formed solely from the Haskell's base package") - (description "This Haskell package aims to reexport all the non-conflicting + (description + "This Haskell package aims to reexport all the non-conflicting and most general definitions from the \"base\" package. This includes APIs for applicatives, arrows, monoids, foldables, traversables, @@ -980,26 +946,18 @@ (define-public ghc-bencode (define-public ghc-bifunctors (package (name "ghc-bifunctors") - (version "5.5.11") - (source - (origin - (method url-fetch) - (uri (hackage-uri "bifunctors" version)) - (sha256 - (base32 - "070964w7gz578379lyj6xvdbcf367csmz22cryarjr5bz9r9csrb")))) + (version "5.5.14") + (source (origin + (method url-fetch) + (uri (hackage-uri "bifunctors" version)) + (sha256 + (base32 + "0r4jd4s66xvnx0bk75rz0cwnf6cr0lgx3dxrqdv3ppkwqk81c0ak")))) (build-system haskell-build-system) (properties '((upstream-name . "bifunctors"))) - (inputs - (list ghc-base-orphans - ghc-comonad - ghc-th-abstraction - ghc-transformers-compat - ghc-tagged - ghc-semigroups)) - (native-inputs - (list ghc-hspec hspec-discover ghc-quickcheck)) - (home-page "https://github.com/ekmett/bifunctors/") + (inputs (list ghc-base-orphans ghc-comonad ghc-th-abstraction ghc-tagged)) + (native-inputs (list ghc-hspec ghc-quickcheck ghc-transformers-compat hspec-discover)) + (home-page "http://github.com/ekmett/bifunctors/") (synopsis "Bifunctors for Haskell") (description "This package provides bifunctors for Haskell.") (license license:bsd-3))) @@ -1094,19 +1052,14 @@ (define-public ghc-blaze-markup "0jd30wg5yz0a97b36zwqg4hv8faifza1n2gys3l1p3fwf9l3zz23")))) (build-system haskell-build-system) (properties '((upstream-name . "blaze-markup"))) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "blaze-markup.cabal" - (("tasty >= 1\\.0 && < 1\\.1") - "tasty >= 1.0 && < 1.2"))))))) (inputs (list ghc-blaze-builder)) (native-inputs (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck)) + (arguments + `(#:cabal-revision ("3" + "1hn694kk615prqdn7bfzl0wvbw8bksxk4cxwmx8yhwpl0cq3fiwa"))) (home-page "https://jaspervdj.be/blaze") (synopsis "Fast markup combinator library for Haskell") (description "This library provides core modules of a markup combinator @@ -1123,12 +1076,23 @@ (define-public ghc-bloomfilter (uri (hackage-uri "bloomfilter" version)) (sha256 (base32 - "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc")))) + "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc")) + (patches (search-patches "ghc-bloomfilter-ghc9.2.patch")))) (build-system haskell-build-system) (properties '((upstream-name . "bloomfilter"))) (native-inputs (list ghc-quickcheck ghc-random ghc-test-framework ghc-test-framework-quickcheck2)) + (arguments + `(#:cabal-revision ("2" + "1hi6hwvhv7lxqv0l6hv2854g1rvc52zcmr3ldvnaan1l1b666867") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "bloomfilter.cabal" + (("\\b(base)\\s+[^,]+" all dep) + dep))))))) (home-page "https://github.com/bos/bloomfilter") (synopsis "Pure and impure Bloom filter implementations") (description "This package provides both mutable and immutable Bloom @@ -1201,37 +1165,38 @@ (define-public ghc-byteorder (define-public ghc-bytes (package - (name "ghc-bytes") - (version "0.17.1") - (source - (origin - (method url-fetch) - (uri - (hackage-uri "bytes" version)) - (file-name (string-append name "-" version ".tar.gz")) - (sha256 - (base32 - "1qmps8vvg98wfm9xm734hwzi56bsk8r1zc6vx20rlhc79krv5s9s")))) - (build-system haskell-build-system) - (properties '((upstream-name . "bytes"))) - (inputs (list ghc-binary-orphans - ghc-cereal - ghc-hashable - ghc-scientific - ghc-transformers-compat - ghc-unordered-containers - ghc-void)) - (synopsis "Serialization between @code{binary} and @code{cereal}") - (description "This package provides a simple compatibility shim that lets -you work with both @code{binary} and @code{cereal} with one chunk of -serialization code.") - (home-page "https://hackage.haskell.org/package/bytes") - (license license:bsd-3))) - -(define-public ghc-bytestring-builder - (package - (name "ghc-bytestring-builder") - (version "0.10.8.2.0") + (name "ghc-bytes") + (version "0.17.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "bytes" version)) + (sha256 + (base32 + "06kqqk19qjhrwdqi6pyd1lwqfnj2sw3b3s49lc5vr2fmv8gg8mdw")))) + (build-system haskell-build-system) + (properties '((upstream-name . "bytes"))) + (inputs (list ghc-binary-orphans + ghc-cereal + ghc-hashable + ghc-transformers-compat + ghc-unordered-containers + ghc-scientific + ghc-void)) + (arguments + `(#:cabal-revision ("1" + "0frs6ag93kmg2fw3vd686czx8g7h9qmdn1ip6wdk96d94ap0fz9i"))) + (home-page "https://github.com/ekmett/bytes") + (synopsis "Serialization between @code{binary} and @code{cereal}") + (description + "This package provides a simple compatibility shim that lets +you work with both @code{binary} and @code{cereal} with one chunk of +serialization code.") + (license license:bsd-3))) + +(define-public ghc-bytestring-builder + (package + (name "ghc-bytestring-builder") + (version "0.10.8.2.0") (source (origin (method url-fetch) @@ -1249,6 +1214,7 @@ (define-public ghc-bytestring-builder Compatibility package for older packages.") (license license:bsd-3))) +;; XXX: Incompatible with base (define-public ghc-bytestring-handle (package (name "ghc-bytestring-handle") @@ -1259,12 +1225,19 @@ (define-public ghc-bytestring-handle (uri (hackage-uri "bytestring-handle" version)) (sha256 (base32 - "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y")))) + "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y")) + (patches (search-patches "ghc-bytestring-handle-ghc9.patch")))) (build-system haskell-build-system) (properties '((upstream-name . "bytestring-handle"))) (arguments `(#:cabal-revision - ("2" "1x1sy3dz2ph9v6jk22wmcv5gk2bka5fv4s68i8q0j9m9pk085w37"))) + ("2" "1x1sy3dz2ph9v6jk22wmcv5gk2bka5fv4s68i8q0j9m9pk085w37") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "bytestring-handle.cabal" + (("base >= 4\\.2 && < 4\\.15") "base"))))))) (inputs (list ghc-hunit ghc-quickcheck ghc-test-framework ghc-test-framework-hunit ghc-test-framework-quickcheck2)) @@ -1276,24 +1249,22 @@ (define-public ghc-bytestring-handle (define-public ghc-bytestring-lexing (package (name "ghc-bytestring-lexing") - (version "0.5.0.7") - (source - (origin - (method url-fetch) - (uri (hackage-uri "bytestring-lexing" version)) - (sha256 - (base32 - "1p7i2haix4m11an3djaq65cnd293hzwqy4cd2i8jxzcl248pk6iy")))) + (version "0.5.0.9") + (source (origin + (method url-fetch) + (uri (hackage-uri "bytestring-lexing" version)) + (sha256 + (base32 + "14nx7sfs75g57mlfiwgzm5sc3wm4va58zryjp27m5lmfdp30873c")))) (build-system haskell-build-system) (properties '((upstream-name . "bytestring-lexing"))) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-smallcheck)) - (home-page "http://code.haskell.org/~wren/") + (native-inputs (list ghc-tasty ghc-tasty-smallcheck ghc-tasty-quickcheck)) + (home-page "https://wrengr.org/software/hackage.html") (synopsis "Parse and produce literals from strict or lazy bytestrings") (description "This package provides tools to parse and produce literals efficiently from strict or lazy bytestrings.") - (license license:bsd-2))) + (license license:bsd-3))) (define-public ghc-bzlib-conduit (package @@ -1339,7 +1310,9 @@ (define-public ghc-c2hs (list ghc-test-framework ghc-test-framework-hunit ghc-hunit ghc-shelly)) (arguments - `(#:phases + `(#:cabal-revision + ("1" "0hbv1j9b04gm617c5xqndr4iqidabwdpcn2dcrnaacc04ylchvl2") + #:phases (modify-phases %standard-phases ;; The tarball on Hackage does not ship these tests. See ;; https://github.com/haskell/c2hs/issues/269 @@ -1378,20 +1351,19 @@ (define-public ghc-c2hs (define-public ghc-cairo (package (name "ghc-cairo") - (version "0.13.8.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "cairo" version)) - (sha256 - (base32 - "1hpkyhrlg1d24s34kq6d379z8l8fvznm98wpq37haqjma4nl25hk")))) + (version "0.13.8.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "cairo" version)) + (sha256 + (base32 + "1sq2imy359vnbny610n7655a4z5a8fgdxanys4f5nw84246hc2yl")))) (build-system haskell-build-system) (properties '((upstream-name . "cairo"))) - (inputs - (list ghc-utf8-string cairo)) - (native-inputs - (list ghc-gtk2hs-buildtools pkg-config)) + (inputs (list ghc-utf8-string cairo)) + (native-inputs (list ghc-gtk2hs-buildtools pkg-config)) + (arguments + `(#:extra-directories ("cairo"))) (home-page "https://projects.haskell.org/gtk2hs/") (synopsis "Haskell bindings to the Cairo vector graphics library") (description @@ -1403,17 +1375,17 @@ (define-public ghc-cairo (define-public ghc-call-stack (package (name "ghc-call-stack") - (version "0.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "call-stack" version)) - (sha256 - (base32 - "0ski7ihdxah7x4x07qgkjljg8hzqs9d6aa5k4cmr40bzp3i8s3mq")))) + (version "0.4.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "call-stack" version)) + (sha256 + (base32 + "0yxq6v37kcmgv6rrna4g1ipr8mhkgf00ng2p359ybxq46j5cy2s3")))) (build-system haskell-build-system) (properties '((upstream-name . "call-stack"))) - (native-inputs (list ghc-nanospec)) + ;(arguments (list #:tests? #f)) + (native-inputs (list ghc-nanospec-bootstrap)) (home-page "https://github.com/sol/call-stack#readme") (synopsis "Use GHC call-stacks in a backward compatible way") (description "This package provides a compatibility layer for using GHC @@ -1461,37 +1433,29 @@ (define-public ghc-case-insensitive (define-public ghc-cassava (package (name "ghc-cassava") - (version "0.5.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "cassava" version)) - (sha256 - (base32 - "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk")))) + (version "0.5.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "cassava" version)) + (sha256 + (base32 + "1gp954w05bj83z4i6isq2qxi1flqwppsgxxrp1f75mrs8cglbj5l")))) (build-system haskell-build-system) (properties '((upstream-name . "cassava"))) - (inputs - (list ghc-attoparsec - ghc-hashable - ghc-scientific - ghc-unordered-containers - ghc-vector - ghc-only - ghc-text-short - ghc-bytestring-builder)) - (native-inputs - (list ghc-hunit - ghc-quickcheck - ghc-quickcheck-instances - ghc-test-framework - ghc-test-framework-hunit - ghc-test-framework-quickcheck2)) - (arguments - `(#:cabal-revision - ("4" - "19rkq41r5vj8drnj850b1wqnc54mxpw0x5z54brq0nvyww5f8ai8") - #:configure-flags '("--flags=-bytestring--lt-0_10_4"))) + (inputs (list ghc-attoparsec + ghc-hashable + ghc-scientific + ghc-unordered-containers + ghc-vector + ghc-only + ghc-bytestring-builder + ghc-nats)) + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-quickcheck-instances + ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) (home-page "https://github.com/haskell-hvr/cassava") (synopsis "CSV parsing and encoding library") (description @@ -1532,7 +1496,9 @@ (define-public ghc-cassava @verbatim >>> Data.Csv.encode [(\"John\",27),(\"Jane\",28)] -\"John,27\r\nJane,28\r\n\" +\"John,27 +Jane,28 +\" @end verbatim ") (license license:bsd-3))) @@ -1564,29 +1530,30 @@ (define-public ghc-cassava-megaparsec (define-public ghc-cborg (package (name "ghc-cborg") - (version "0.2.5.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "cborg" version)) - (sha256 - (base32 - "08da498bpbnl5c919m45mjm7sr78nn6qs7xyl0smfgd06wwm65xf")))) + (version "0.2.8.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "cborg" version)) + (sha256 + (base32 + "07mh5bk61k5dz2x5g7fqw2cv7bjzs7v65yxvzkq7mdbkq8kwhn9f")))) (build-system haskell-build-system) (properties '((upstream-name . "cborg"))) - (inputs - (list ghc-half ghc-primitive)) - (native-inputs - (list ghc-aeson - ghc-base64-bytestring - ghc-base16-bytestring - ghc-fail - ghc-quickcheck - ghc-scientific - ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck - ghc-vector)) + (inputs (list ghc-half ghc-primitive)) + (native-inputs (list ghc-base-orphans + ghc-aeson + ghc-base64-bytestring + ghc-base16-bytestring + ghc-quickcheck + ghc-random + ghc-scientific + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-vector)) + (arguments + `(#:cabal-revision ("1" + "13m2shrlpvg5s9d40a2463mmckzg50y8jb47zfd6i1rg6q3q6xx6"))) (home-page "https://hackage.haskell.org/package/cborg") (synopsis "Concise Binary Object Representation") (description @@ -1609,51 +1576,48 @@ (define-public ghc-cborg (define-public ghc-cborg-json (package (name "ghc-cborg-json") - (version "0.2.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "cborg-json" version)) - (sha256 - (base32 "0ysilz7rrjk94sqr3a61s98hr9qfi1xg13bskmlpc6mpgi2s4s5b")))) + (version "0.2.5.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "cborg-json" version)) + (sha256 + (base32 + "1m3w0yyp6xb07fx04g5c52pb0b46vpkgpi32w1c8bz867x2p7hsq")))) (build-system haskell-build-system) (properties '((upstream-name . "cborg-json"))) + (inputs (list ghc-aeson + ghc-aeson-pretty + ghc-unordered-containers + ghc-scientific + ghc-vector + ghc-cborg)) (arguments - `(#:cabal-revision - ("3" "1sn2f9nfjcbr0n62n4kklbdi3pzpwrcy7ilg7m3v41nwrk53ifwy"))) - (inputs - (list ghc-aeson - ghc-aeson-pretty - ghc-unordered-containers - ghc-scientific - ghc-vector - ghc-cborg)) + `(#:cabal-revision ("1" + "0zzn2p6yl9mqw7agm5w7iiz105078gv66vxr8bqazilgssqk5wyg"))) (home-page "https://github.com/well-typed/cborg") (synopsis "Library for encoding JSON as CBOR") - (description - "This package implements the bijection between JSON and CBOR + (description "This package implements the bijection between JSON and CBOR defined in the CBOR specification, RFC 7049.") (license license:bsd-3))) (define-public ghc-cereal (package (name "ghc-cereal") - (version "0.5.8.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "cereal" version)) - (sha256 - (base32 - "1mqvd1iwzr50az4y24332x3g3wsrzw8j1iwph02vr7jbjfn8i7id")))) + (version "0.5.8.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "cereal" version)) + (sha256 + (base32 + "0shg3q933cvf18j1gmxill48d4sl4mvxj2qkj6yya9hvcqh5544r")))) (build-system haskell-build-system) (properties '((upstream-name . "cereal"))) - (native-inputs - (list ghc-quickcheck ghc-fail ghc-test-framework - ghc-test-framework-quickcheck2)) - (home-page "https://hackage.haskell.org/package/cereal") + (native-inputs (list ghc-quickcheck ghc-test-framework + ghc-test-framework-quickcheck2)) + (home-page "https://github.com/GaloisInc/cereal") (synopsis "Binary serialization library") - (description "This package provides a binary serialization library, + (description + "This package provides a binary serialization library, similar to @code{binary}, that introduces an @code{isolate} primitive for parser isolation, and labeled blocks for better error messages.") (license license:bsd-3))) @@ -1682,6 +1646,7 @@ (define-public ghc-cereal-conduit @code{Sources}, @code{Sinks}, and @code{Conduits}.") (license license:bsd-3))) +;; XXX: bytestring <0.11, time >=1.5 && <1.10 (define-public ghc-cgi (package (name "ghc-cgi") @@ -1699,6 +1664,14 @@ (define-public ghc-cgi (list ghc-exceptions ghc-multipart ghc-network-uri ghc-network)) (native-inputs (list ghc-doctest ghc-quickcheck)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "cgi.cabal" + (("\\b(bytestring|time)\\s+[^,]+" all dep) + dep))))))) (home-page "https://github.com/cheecheeo/haskell-cgi") (synopsis "Library for writing CGI programs") @@ -1709,19 +1682,17 @@ (define-public ghc-cgi (define-public ghc-charset (package (name "ghc-charset") - (version "0.3.8") - (source - (origin - (method url-fetch) - (uri (hackage-uri "charset" version)) - (sha256 - (base32 - "1rw6y2insgljbi5l1nwqwv9v865sswjly9rvwipd8zajkgks7aks")))) + (version "0.3.9") + (source (origin + (method url-fetch) + (uri (hackage-uri "charset" version)) + (sha256 + (base32 + "12wrphd5j1asb3n6awbph4n695mfmnzk6yzggrp387hx960qfkyb")))) (build-system haskell-build-system) (properties '((upstream-name . "charset"))) - (inputs - (list ghc-semigroups ghc-unordered-containers)) - (home-page "https://github.com/ekmett/charset") + (inputs (list ghc-unordered-containers ghc-semigroups)) + (home-page "http://github.com/ekmett/charset") (synopsis "Fast unicode character sets for Haskell") (description "This package provides fast unicode character sets for Haskell, based on complemented PATRICIA tries.") @@ -1730,26 +1701,21 @@ (define-public ghc-charset (define-public ghc-chart (package (name "ghc-chart") - (version "1.9.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "Chart" version)) - (sha256 - (base32 - "0p69kq5kh40gd4y8wqabypmw67pqh42vaaw64zv9sf8j075g85ry")))) + (version "1.9.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "Chart" version)) + (sha256 + (base32 + "0ylxin419s35xq1j4hcnylrch3m252wqdkfjp5b323qhv4a8y1im")))) (build-system haskell-build-system) (properties '((upstream-name . "Chart"))) - (arguments - `(#:cabal-revision - ("2" "04mmsm54mdqcrypvgawhhbwjscmky3j7g5841bc71c0q6d33h2k4"))) - (inputs - (list ghc-old-locale - ghc-lens - ghc-colour - ghc-data-default-class - ghc-operational - ghc-vector)) + (inputs (list ghc-old-locale + ghc-lens + ghc-colour + ghc-data-default-class + ghc-operational + ghc-vector)) (home-page "https://github.com/timbod7/haskell-chart/wiki") (synopsis "Library for generating 2D charts and plots") (description @@ -1771,8 +1737,8 @@ (define-public ghc-chart-cairo (build-system haskell-build-system) (properties '((upstream-name . "Chart-cairo"))) (arguments - `(#:cabal-revision - ("2" "0z93znn3dpgj80iiz3a67m90x0j9ljr0jd1ws9jkzj7rk88014gp"))) + `(#:cabal-revision ("3" + "1d48i6y0lzj066swdb3x56jipxwlx1szwn7j43d50hxmcfjrsgc9"))) (inputs (list ghc-old-locale ghc-cairo @@ -1791,23 +1757,19 @@ (define-public ghc-chart-cairo (define-public ghc-chasingbottoms (package (name "ghc-chasingbottoms") - (version "1.3.1.10") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ChasingBottoms" version)) - (sha256 - (base32 - "1flr56hd8ny0ddlv1agi0ikdjv5wgx0aba6xqdsn3nv6dyw9nbf3")))) + (version "1.3.1.12") + (source (origin + (method url-fetch) + (uri (hackage-uri "ChasingBottoms" version)) + (sha256 + (base32 + "1vy9yq07p95qiap1pcp2bbbn1mqvp3spyrswpdz0qfcn06656650")))) (build-system haskell-build-system) (properties '((upstream-name . "ChasingBottoms"))) - (inputs - (list ghc-quickcheck ghc-random ghc-syb)) - (home-page "https://hackage.haskell.org/package/ChasingBottoms") + (inputs (list ghc-quickcheck ghc-random ghc-syb)) + (home-page "http://hackage.haskell.org/package/ChasingBottoms") (synopsis "Testing of partial and infinite values in Haskell") (description - ;; FIXME: There should be a @comma{} in the uref text, but it is not - ;; rendered properly. "This is a library for testing code involving bottoms or infinite values. For the underlying theory and a larger example involving use of QuickCheck, see the article @@ -1954,20 +1916,20 @@ (define-public ghc-chunked-data (define-public ghc-clock (package (name "ghc-clock") - (version "0.8.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "clock" version)) - (sha256 - (base32 "0qg4ljwmw28vvxjzr4sknh8220abjcx2b0sq3ljqprh3qw8b2p8b")))) + (version "0.8.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "clock" version)) + (sha256 + (base32 + "1l850pf1dxjf3i15wc47d64gzkpzgvw0bq13fd8zvklq9kdyap44")))) (build-system haskell-build-system) (properties '((upstream-name . "clock"))) - (inputs - (list ghc-tasty ghc-tasty-quickcheck)) - (home-page "https://hackage.haskell.org/package/clock") + (native-inputs (list ghc-tasty ghc-tasty-quickcheck)) + (home-page "https://github.com/corsis/clock") (synopsis "High-resolution clock for Haskell") - (description "A package for convenient access to high-resolution clock and + (description + "A package for convenient access to high-resolution clock and timer functions of different operating systems via a unified API.") (license license:bsd-3))) @@ -2009,21 +1971,18 @@ (define-public ghc-cmark (define-public ghc-cmark-gfm (package (name "ghc-cmark-gfm") - (version "0.2.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "cmark-gfm" version)) - (sha256 - (base32 - "1skzdg1icmhn0zrkhbnba4200ymah8sd5msk4qfgawrk77zilw7f")))) + (version "0.2.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "cmark-gfm" version)) + (sha256 + (base32 + "0la4sd0cmv3zmn0kygbd77dknyh55h0b0qx5jg883hqnvnhaq721")))) (build-system haskell-build-system) (properties '((upstream-name . "cmark-gfm"))) - (native-inputs - (list ghc-hunit)) + (native-inputs (list ghc-hunit)) (home-page "https://github.com/kivikakk/cmark-gfm-hs") - (synopsis - "Fast, accurate GitHub Flavored Markdown parser and renderer") + (synopsis "Fast, accurate GitHub Flavored Markdown parser and renderer") (description "This package provides Haskell bindings for libcmark-gfm, the reference parser for GitHub Flavored Markdown, a fully specified variant of Markdown. @@ -2189,22 +2148,18 @@ (define-public ghc-concurrent-extra (define-public ghc-concurrent-output (package (name "ghc-concurrent-output") - (version "1.10.12") - (source - (origin - (method url-fetch) - (uri (hackage-uri "concurrent-output" version)) - (sha256 - (base32 - "081wpag1d5znr0ynrjvkc14xl816m88vz9hgfm3g3sp6ak7s3y47")))) + (version "1.10.16") + (source (origin + (method url-fetch) + (uri (hackage-uri "concurrent-output" version)) + (sha256 + (base32 + "0l4k0bkq5bddqraf14g3ngyzwff17f3ngg4axlilcl3zf3c4bamh")))) (build-system haskell-build-system) (properties '((upstream-name . "concurrent-output"))) - (inputs - (list ghc-async ghc-exceptions ghc-ansi-terminal ghc-terminal-size)) - (home-page - "https://hackage.haskell.org/package/concurrent-output") - (synopsis - "Ungarble output from several threads or commands") + (inputs (list ghc-async ghc-ansi-terminal ghc-terminal-size)) + (home-page "http://hackage.haskell.org/package/concurrent-output") + (synopsis "Ungarble output from several threads or commands") (description "Lets multiple threads and external processes concurrently output to the console, without it getting all garbled up. @@ -2254,35 +2209,35 @@ (define-public ghc-conduit (define-public ghc-conduit-algorithms (package (name "ghc-conduit-algorithms") - (version "0.0.11.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "conduit-algorithms" version)) - (sha256 - (base32 - "0c1jwz30kkvimx7lb61782yk0kyfamrf5bqc3g1h7g51lk8bbv9i")))) + (version "0.0.13.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "conduit-algorithms" version)) + (sha256 + (base32 + "1i5jq66xylcnk3yhv2m6lhyqfdrwr94w8v67jzwlvja15jv7mj9v")))) (build-system haskell-build-system) (properties '((upstream-name . "conduit-algorithms"))) - (inputs - (list ghc-async - ghc-bzlib-conduit - ghc-conduit - ghc-conduit-combinators - ghc-conduit-extra - ghc-conduit-zstd - ghc-exceptions - ghc-lzma-conduit - ghc-monad-control - ghc-pqueue - ghc-resourcet - ghc-stm-conduit - ghc-streaming-commons - ghc-unliftio-core - ghc-vector)) - (native-inputs - (list ghc-hunit ghc-test-framework ghc-test-framework-hunit - ghc-test-framework-th)) + (inputs (list ghc-async + ghc-bzlib-conduit + ghc-conduit + ghc-conduit-combinators + ghc-conduit-extra + ghc-conduit-zstd + ghc-fingertree + ghc-lzma-conduit + ghc-monad-control + ghc-resourcet + ghc-stm-conduit + ghc-streaming-commons + ghc-unliftio-core + ghc-vector)) + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-tasty-th)) (home-page "https://github.com/luispedro/conduit-algorithms#readme") (synopsis "Conduit-based algorithms") (description @@ -2328,35 +2283,27 @@ (define-public ghc-conduit-combinators (define-public ghc-conduit-extra (package (name "ghc-conduit-extra") - (version "1.3.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "conduit-extra" version)) - (sha256 - (base32 - "1n8js1y1rdswvp0bkjmmz19fag19bdxgwsrqz93yc09w43p8sr4a")))) + (version "1.3.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "conduit-extra" version)) + (sha256 + (base32 + "0lzip3af77wxf3a3vilfymqhd26gkvabx2fkj22w74nq960c6l49")))) (build-system haskell-build-system) (properties '((upstream-name . "conduit-extra"))) - (inputs - (list ghc-conduit - ghc-exceptions - ghc-monad-control - ghc-transformers-base - ghc-typed-process - ghc-async - ghc-attoparsec - ghc-blaze-builder - ghc-network - ghc-primitive - ghc-resourcet - ghc-streaming-commons - ghc-hspec - ghc-bytestring-builder - ghc-quickcheck)) - (native-inputs - (list hspec-discover)) - (home-page "https://github.com/snoyberg/conduit") + (inputs (list ghc-conduit + ghc-async + ghc-attoparsec + ghc-network + ghc-primitive + ghc-resourcet + ghc-streaming-commons + ghc-unliftio-core + ghc-typed-process + hspec-discover)) + (native-inputs (list ghc-hspec ghc-quickcheck ghc-transformers-base)) + (home-page "http://github.com/snoyberg/conduit") (synopsis "Conduit adapters for common libraries") (description "The @code{conduit} package itself maintains relative small dependencies. @@ -2395,25 +2342,17 @@ (define-public ghc-conduit-zstd (define-public ghc-config-ini (package (name "ghc-config-ini") - (version "0.2.4.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "config-ini" version)) - (sha256 - (base32 "0dfm4xb1sd713rcqzplzdgw68fyhj24i6lj8j3q8kldpmkl98lbf")))) + (version "0.2.5.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "config-ini" version)) + (sha256 + (base32 + "07vgpydzd44ayhq9c3q1335vphw384z8baf0wd0mnarr48yfaz3g")))) (build-system haskell-build-system) (properties '((upstream-name . "config-ini"))) - (arguments - ;; XXX The tests fail to compile: “The constructor ‘I1.Ini’ should have 2 - ;; arguments, but has been given 1”. - `(#:tests? #f - #:cabal-revision - ("2" "0iwraaa0y1b3xdsg760j1wpylkqshky0k2djcg0k4s97lrwqpbcz"))) - (native-inputs - (list ghc-doctest ghc-hedgehog ghc-ini ghc-microlens)) - (inputs - (list ghc-megaparsec ghc-unordered-containers)) + (inputs (list ghc-unordered-containers ghc-megaparsec)) + (native-inputs (list ghc-ini ghc-hedgehog ghc-doctest ghc-microlens)) (home-page "https://github.com/aisamanra/config-ini") (synopsis "Monadic Haskell DSL for parsing simple INI configuration files") (description @@ -2496,28 +2435,25 @@ (define-public ghc-connection (define-public ghc-constraints (package (name "ghc-constraints") - (version "0.13") - (source - (origin - (method url-fetch) - (uri (hackage-uri "constraints" version)) - (sha256 - (base32 - "143558jykvya7y8134dx30g6nh27q5s61nbq369p69igd1aayncj")))) + (version "0.13.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "constraints" version)) + (sha256 + (base32 + "0d248szyp70k1qlivsimk0j5vz9hdx1alhismry5v35qyinr91j1")))) (build-system haskell-build-system) (properties '((upstream-name . "constraints"))) - (inputs - (list ghc-hashable ghc-semigroups ghc-transformers-compat - ghc-type-equality)) - (native-inputs - (list ghc-hspec hspec-discover)) - (home-page "https://github.com/ekmett/constraints/") + (inputs (list ghc-hashable ghc-transformers-compat ghc-type-equality + ghc-semigroups-bootstrap)) + (native-inputs (list ghc-hspec hspec-discover)) + (home-page "http://github.com/ekmett/constraints/") (synopsis "Constraint manipulation") (description "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}. They stopped crashing the compiler in GHC 7.6. This package provides a vocabulary for working with them.") - (license license:bsd-3))) + (license license:bsd-2))) (define-public ghc-contravariant (package @@ -2543,18 +2479,16 @@ (define-public ghc-contravariant (define-public ghc-contravariant-extras (package (name "ghc-contravariant-extras") - (version "0.3.5.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "contravariant-extras" version)) - (sha256 - (base32 - "0ikwzg0992j870yp0x2ssf4mv2hw2nml979apg493m72xnvr1jz9")))) + (version "0.3.5.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "contravariant-extras" version)) + (sha256 + (base32 + "0r4bnl4gi6zd46h6fjkr33hw37rjxwwr00m08vgbzgkdp853g1ba")))) (build-system haskell-build-system) (properties '((upstream-name . "contravariant-extras"))) - (inputs - (list ghc-contravariant ghc-template-haskell-compat-v0208)) + (inputs (list ghc-contravariant ghc-template-haskell-compat-v0208)) (home-page "https://github.com/nikita-volkov/contravariant-extras") (synopsis "Extras for the @code{ghc-contravariant} Haskell package") (description "This Haskell package provides extras for the @@ -2591,19 +2525,18 @@ (define-public ghc-control-monad-free (define-public ghc-convertible (package (name "ghc-convertible") - (version "1.1.1.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "convertible" version)) - (sha256 - (base32 - "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9")))) + (version "1.1.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "convertible" version)) + (sha256 + (base32 + "1vwc6h1z88xkw4bq3js8x9x86jnk3amdskyksca77p0kwiqbs7lr")))) (build-system haskell-build-system) (properties '((upstream-name . "convertible"))) - (inputs - (list ghc-old-time ghc-old-locale)) - (home-page "https://hackage.haskell.org/package/convertible") + (inputs (list ghc-old-time)) + (native-inputs (list ghc-quickcheck)) + (home-page "http://hackage.haskell.org/package/convertible") (synopsis "Typeclasses and instances for converting between types") (description "This package provides a typeclass with a single function that is @@ -2684,20 +2617,16 @@ (define-public ghc-data-accessor-transformers (define-public ghc-data-clist (package (name "ghc-data-clist") - (version "0.1.2.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "data-clist" version)) - (sha256 - (base32 "1mwfhnmvi3vicyjzl33m6pcipi2v887zazyqxygq258ndd010s9m")))) + (version "0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "data-clist" version)) + (sha256 + (base32 + "04mj0d1yp0l27v2my51w9q5zpdrdhp29fdyvmwqgxxp8f6yiwfhw")))) (build-system haskell-build-system) (properties '((upstream-name . "data-clist"))) - (native-inputs - (list ghc-quickcheck)) - (arguments - `(#:cabal-revision - ("1" "13hg7a3d4ky8b765dl03ryxg28lq8iaqj5ky3j51r0i1i4f2a9hy"))) + (native-inputs (list ghc-quickcheck)) (home-page "https://github.com/sw17ch/data-clist") (synopsis "Simple, functional, bidirectional circular list type") (description @@ -2845,6 +2774,9 @@ (define-public ghc-data-fix (build-system haskell-build-system) (properties '((upstream-name . "data-fix"))) (inputs (list ghc-hashable)) + (arguments + `(#:cabal-revision ("3" + "0z77i9y86wlc13396akl8qxq39rwpkhhcs5fadzk47bwn7v1gsmx"))) (home-page "https://github.com/spell-music/data-fix") (synopsis "Fixpoint data types") (description @@ -2898,42 +2830,38 @@ (define-public ghc-data-ordlist (define-public ghc-dbus (package (name "ghc-dbus") - (version "1.2.17") - (source - (origin - (method url-fetch) - (uri - (hackage-uri "dbus" version)) - (sha256 - (base32 - "0iyfnkxcnm1vl379ry88fqxgn2y8q6ilsvpic6ciassnyv5pcbrv")))) + (version "1.2.27") + (source (origin + (method url-fetch) + (uri (hackage-uri "dbus" version)) + (sha256 + (base32 + "0lkk9hd78h2ilvi0bj5jqq5q5lwyxzdlknwvckhwyxnlf3y6dz8z")))) (build-system haskell-build-system) (properties '((upstream-name . "dbus"))) - (inputs - (list ghc-cereal - ghc-conduit - ghc-exceptions - ghc-lens - ghc-network - ghc-random - ghc-split - ghc-th-lift - ghc-vector - ghc-xml-conduit - ghc-xml-types)) - (native-inputs - (list ghc-extra - ghc-quickcheck - ghc-resourcet - ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck)) - ;; FIXME - Some tests try to talk to network. - (arguments `(#:tests? #f)) - (home-page "https://github.com/rblaze/haskell-dbus") + (inputs (list ghc-cereal + ghc-conduit + ghc-lens + ghc-network + ghc-random + ghc-split + ghc-th-lift + ghc-vector + ghc-xml-conduit + ghc-xml-types)) + (native-inputs (list ghc-extra + ghc-quickcheck + ghc-resourcet + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ;; dbus-daemon spawned by testsuite. + dbus)) + (arguments (list #:tests? #f)) ; Network tests fail to connect. + (home-page "https://github.com/rblaze/haskell-dbus#readme") (synopsis "Client library for the D-Bus IPC system") (description - "D-Bus is a simple, message-based protocol for inter-process + "D-Bus is a simple, message-based protocol for inter-process communication, which allows applications to interact with other parts of the machine and the user's session using remote procedure calls. D-Bus is a essential part of the modern Linux desktop, where @@ -2980,8 +2908,8 @@ (define-public ghc-deepseq-generics (build-system haskell-build-system) (properties '((upstream-name . "deepseq-generics"))) (arguments - `(#:cabal-revision - ("6" "1qwnpdjsrqzn18pjmvv9aqz3l12fbdcimf62wkj33yfh69rx4s42"))) + `(#:cabal-revision ("8" + "0dcv4kf2g4xyacjpci9kql1gm706lkzhcyz9ks9jkbdvyvs8lf90"))) (native-inputs (list ghc-hunit ghc-test-framework ghc-test-framework-hunit)) (home-page "https://github.com/hvr/deepseq-generics") @@ -3020,58 +2948,34 @@ (define-public ghc-dense-linear-algebra related modules split from the statistics library.") (license license:bsd-2))) -(define-public ghc-descriptive - (package - (name "ghc-descriptive") - (version "0.9.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "descriptive" version)) - (sha256 - (base32 - "0y5693zm2kvqjilybbmrcv1g6n6x2p6zjgi0k0axjw1sdhh1g237")))) - (build-system haskell-build-system) - (properties '((upstream-name . "descriptive"))) - (inputs - (list ghc-aeson ghc-bifunctors ghc-scientific ghc-vector)) - (native-inputs - (list ghc-hunit ghc-hspec)) - (home-page - "https://github.com/chrisdone/descriptive") - (synopsis - "Self-describing consumers/parsers: forms, cmd-line args, JSON, etc.") - (description - "This package provides datatypes and functions for creating consumers -and parsers with useful semantics.") - (license license:bsd-3))) - (define-public ghc-diagrams-core (package (name "ghc-diagrams-core") - (version "1.5.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "diagrams-core" version)) - (sha256 - (base32 - "0y3smp3hiyfdirdak3j4048cgqv7a5q9p2jb6z8na2llys5mrmdn")))) + (version "1.5.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "diagrams-core" version)) + (sha256 + (base32 + "1gv1p5hrxi3hks0nb4l38gdgfq9bh9d86b6dxcyzqxrwxbxk1khn")))) (build-system haskell-build-system) (properties '((upstream-name . "diagrams-core"))) - (inputs - (list ghc-unordered-containers - ghc-semigroups - ghc-monoid-extras - ghc-dual-tree - ghc-lens - ghc-linear - ghc-adjunctions - ghc-distributive - ghc-profunctors)) - (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + (inputs (list ghc-unordered-containers + ghc-semigroups + ghc-monoid-extras + ghc-dual-tree + ghc-lens + ghc-linear + ghc-adjunctions + ghc-distributive + ghc-profunctors)) + (arguments + `(#:cabal-revision ("1" + "1gahbyv00xyr4pcmpq4g95jyh7844fp8z0g9l2ybifv4s73vdrym"))) + (home-page "https://diagrams.github.io") (synopsis "Core libraries for diagrams embedded domain-specific language") - (description "This package provides the core modules underlying + (description + "This package provides the core modules underlying diagrams, an embedded domain-specific language for compositional, declarative drawing.") (license license:bsd-3))) @@ -3079,49 +2983,46 @@ (define-public ghc-diagrams-core (define-public ghc-diagrams-lib (package (name "ghc-diagrams-lib") - (version "1.4.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "diagrams-lib" version)) - (sha256 - (base32 - "09np7kj8si8kcb854f95a0cq392mgbxif8lnazbpfsa1k87d9vzy")))) + (version "1.4.5.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "diagrams-lib" version)) + (sha256 + (base32 + "1vx51g9znb4a9bf20pjd9zr98wmh39avk2i06217p0iidcw8whz6")))) (build-system haskell-build-system) (properties '((upstream-name . "diagrams-lib"))) - (inputs - (list ghc-semigroups - ghc-monoid-extras - ghc-dual-tree - ghc-diagrams-core - ghc-diagrams-solve - ghc-active - ghc-colour - ghc-data-default-class - ghc-fingertree - ghc-intervals - ghc-lens - ghc-tagged - ghc-optparse-applicative - ghc-juicypixels - ghc-hashable - ghc-linear - ghc-adjunctions - ghc-distributive - ghc-fsnotify - ghc-unordered-containers - ghc-profunctors - ghc-exceptions - ghc-cereal)) - (native-inputs - (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck - ghc-numeric-extras)) + (inputs (list ghc-semigroups + ghc-monoid-extras + ghc-dual-tree + ghc-diagrams-core + ghc-diagrams-solve + ghc-active + ghc-colour + ghc-data-default-class + ghc-fingertree + ghc-intervals + ghc-lens + ghc-tagged + ghc-optparse-applicative + ghc-juicypixels + ghc-hashable + ghc-linear + ghc-adjunctions + ghc-distributive + ghc-fsnotify + ghc-unordered-containers + ghc-profunctors + ghc-cereal)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck + ghc-quickcheck ghc-numeric-extras)) (arguments - `(#:cabal-revision - ("1" "1c7kpnbvxwdcmk5znqyig3l6s986ppj168ck5v72dfbp8cjvwa8i"))) - (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + `(#:cabal-revision ("1" + "14lxvlxdzkrhdgblgglr5k0rwak0yl4gzawqkfla04mkg6hkh5bb"))) + (home-page "http://diagrams.github.io") (synopsis "Embedded domain-specific language for declarative graphics") - (description "Diagrams is a flexible, extensible embedded + (description + "Diagrams is a flexible, extensible embedded domain-specific language (EDSL) for creating graphics of many types. Graphics can be created in arbitrary vector spaces and rendered with multiple backends. This package provides a standard library of @@ -3159,33 +3060,31 @@ (define-public ghc-diagrams-solve (define-public ghc-diagrams-svg (package (name "ghc-diagrams-svg") - (version "1.4.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "diagrams-svg" version)) - (sha256 - (base32 - "1ysv6cz0fngrndl4wjmw4hrdj2rik5fxa1dkxzwnlgf1xwpvxgk8")))) + (version "1.4.3.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "diagrams-svg" version)) + (sha256 + (base32 + "002lgmq78c6rsvds9bgm6m4w8j6qpg260mc52hf97wj6m050l237")))) (build-system haskell-build-system) (properties '((upstream-name . "diagrams-svg"))) - (inputs - (list ghc-base64-bytestring - ghc-colour - ghc-diagrams-core - ghc-diagrams-lib - ghc-monoid-extras - ghc-svg-builder - ghc-juicypixels - ghc-split - ghc-lens - ghc-hashable - ghc-optparse-applicative - ghc-semigroups)) + (inputs (list ghc-base64-bytestring + ghc-colour + ghc-diagrams-core + ghc-diagrams-lib + ghc-monoid-extras + ghc-svg-builder + ghc-juicypixels + ghc-split + ghc-lens + ghc-hashable + ghc-optparse-applicative + ghc-semigroups)) (arguments - `(#:cabal-revision - ("4" "0irjf0g1barr06fy409r0ld2hypihrhh6n80ig3487xxny6gfzs0"))) - (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + `(#:cabal-revision ("4" + "026mkj9fz64rdrap25mp8cwdrzwj90h35qg9kkn078fac93aaq10"))) + (home-page "https://diagrams.github.io/") (synopsis "Scalable Vector Grpahics backend for the diagrams framework") (description "This package provides a modular backend for rendering diagrams created with the diagrams embedded domain-specific @@ -3217,19 +3116,18 @@ (define-public ghc-dictionary-sharing (define-public ghc-diff (package (name "ghc-diff") - (version "0.4.0") + (version "0.4.1") (source (origin (method url-fetch) (uri (hackage-uri "Diff" version)) (sha256 (base32 - "1is9y5rlqyxacnj6kbi6h9laym5shp699r0hkj5p9d6qi84sr43j")))) + "0w166w5jksiqad7xf2ldjl2ykap0xf08byrl92qwp6r1qym4lppx")))) (build-system haskell-build-system) (properties '((upstream-name . "Diff"))) - (native-inputs - (list ghc-quickcheck ghc-test-framework - ghc-test-framework-quickcheck2)) - (home-page "https://hub.darcs.net/sterlingclover/Diff") + (native-inputs (list ghc-quickcheck ghc-test-framework + ghc-test-framework-quickcheck2)) + (home-page "http://hackage.haskell.org/package/Diff") (synopsis "O(ND) diff algorithm in Haskell") (description "This package provides an implementation of the standard diff algorithm, @@ -3272,7 +3170,7 @@ (define-public ghc-distributive (list ghc-tagged ghc-base-orphans ghc-transformers-compat ghc-semigroups ghc-generic-deriving)) (native-inputs - (list cabal-doctest ghc-doctest ghc-hspec hspec-discover)) + (list ghc-doctest ghc-hspec hspec-discover)) (home-page "https://github.com/ekmett/distributive/") (synopsis "Distributive functors for Haskell") (description "This package provides distributive functors for Haskell. @@ -3304,28 +3202,27 @@ (define-public ghc-dlist (define-public ghc-doctemplates (package (name "ghc-doctemplates") - (version "0.9") - (source - (origin - (method url-fetch) - (uri (hackage-uri "doctemplates" version)) - (sha256 - (base32 - "048h8ka849h1f0xxwkasjbrrwq03rfz2m7aqg5xc5286kp02w9ns")))) + (version "0.10.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "doctemplates" version)) + (sha256 + (base32 + "0as0sc4x4ch5z233dqlb8xqg97xbfbzw2dqsz9rfq8rw10v9yx57")))) (build-system haskell-build-system) (properties '((upstream-name . "doctemplates"))) - (inputs - (list ghc-aeson - ghc-doclayout - ghc-hsyaml - ghc-safe - ghc-scientific - ghc-text-conversions - ghc-unordered-containers - ghc-vector)) - (native-inputs - (list ghc-glob ghc-tasty ghc-tasty-golden ghc-tasty-hunit - ghc-temporary)) + (inputs (list ghc-safe + ghc-text-conversions + ghc-aeson + ghc-hsyaml + ghc-doclayout + ghc-vector + ghc-scientific)) + (native-inputs (list ghc-glob ghc-tasty ghc-tasty-golden ghc-tasty-hunit + ghc-temporary)) + (arguments + `(#:cabal-revision ("1" + "17r6ig72bzqd59p11sjaf9y27pm4yig1a1s1igs57s88cy47qz05"))) (home-page "https://github.com/jgm/doctemplates#readme") (synopsis "Pandoc-style document templates") (description @@ -3335,31 +3232,29 @@ (define-public ghc-doctemplates (define-public ghc-doctest (package (name "ghc-doctest") - (version "0.17") - (source - (origin - (method url-fetch) - (uri (hackage-uri "doctest" version)) - (sha256 - (base32 - "0f0knggq6yjcznyri35fll619q5jr8vcsbiyvdiz4prkawhaa4pz")))) + (version "0.20.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "doctest" version)) + (sha256 + (base32 + "00jbpqvcqxx1nmf41li947d9d3ifwchzzp37mlag68hgnza6z9a4")))) (build-system haskell-build-system) (properties '((upstream-name . "doctest"))) - (arguments `(#:tests? #f)) ; FIXME: missing test framework - (inputs - (list ghc-base-compat ghc-code-page ghc-paths ghc-syb)) - (native-inputs - (list ghc-hunit - ghc-quickcheck - ghc-hspec - ghc-mockery - ghc-setenv - ghc-silently - ghc-stringbuilder)) - (home-page - "https://github.com/sol/doctest#readme") + (inputs (list ghc-base-compat ghc-code-page ghc-paths ghc-syb)) + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-hspec + ghc-hspec-core + ghc-mockery + ghc-setenv + ghc-silently + ghc-stringbuilder + hspec-discover)) + (home-page "https://github.com/sol/doctest#readme") (synopsis "Test interactive Haskell examples") - (description "The doctest program checks examples in source code comments. + (description + "The doctest program checks examples in source code comments. It is modeled after doctest for Python, see @uref{https://docs.python.org/library/doctest.html, the Doctest website}.") (license license:expat))) @@ -3389,21 +3284,23 @@ (define-public ghc-dotgen (define-public ghc-double-conversion (package (name "ghc-double-conversion") - (version "2.0.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "double-conversion" version)) - (sha256 - (base32 - "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4")))) - (build-system haskell-build-system) - (properties '((upstream-name . "double-conversion"))) - (native-inputs - (list ghc-hunit ghc-test-framework ghc-test-framework-hunit - ghc-test-framework-quickcheck2)) - (home-page "https://github.com/bos/double-conversion") - (synopsis "Fast conversion between double precision floating point and text") + (version "2.0.4.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "double-conversion" version)) + (sha256 + (base32 + "0r7c1801gzdm5x1flmpx8ajxygbc9dl7sgdj0xn3bpm71wgvrf4s")))) + (build-system haskell-build-system) + (properties '((upstream-name . "double-conversion"))) + (native-inputs (list ghc-hunit ghc-test-framework ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) + (arguments + `(#:cabal-revision ("2" + "1mpnx4m2pg5crfz9k8wamh5mgsha0np3ynnllrmglmwh54gvfjj3"))) + (home-page "https://github.com/haskell/double-conversion") + (synopsis + "Fast conversion between double precision floating point and text") (description "This package provides a library that performs fast, accurate conversion between double precision floating point and text.") @@ -3412,28 +3309,21 @@ (define-public ghc-double-conversion (define-public ghc-dual-tree (package (name "ghc-dual-tree") - (version "0.2.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "dual-tree" version)) - (sha256 - (base32 - "0qyn7kb42wvlcvb1wbf1qx3isc2y6k3hzp5iq6ab0r0llw9g6qlg")))) + (version "0.2.3.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "dual-tree" version)) + (sha256 + (base32 + "19nm34d166fhlkk7npx0iq9kbx7300a82bg75q1sx98jqfa4nffh")))) (build-system haskell-build-system) (properties '((upstream-name . "dual-tree"))) - (arguments - `(#:tests? #f ; TODO: ghc-testing-feat does not build. - #:cabal-revision - ("1" "1babd7ybsgk73x57yl35q0n1i7mbbqmv4am710kq1hzg3in4g9dv"))) - (inputs - (list ghc-semigroups ghc-newtype-generics ghc-monoid-extras)) -; (native-inputs -; `(("ghc-quickcheck" ,ghc-quickcheck) -; ("ghc-testing-feat" ,ghc-testing-feat))) - (home-page "https://hackage.haskell.org/package/dual-tree") + (inputs (list ghc-semigroups ghc-monoid-extras)) + (native-inputs (list ghc-quickcheck ghc-testing-feat)) + (home-page "http://hackage.haskell.org/package/dual-tree") (synopsis "Rose trees with cached and accumulating monoidal annotations") - (description "Rose (@math{n}-ary) trees with both upwards- (i.e. + (description + "Rose (@math{n}-ary) trees with both upwards- (i.e. cached) and downwards-traveling (i.e. accumulating) monoidal annotations. This is used as the core data structure underlying the @url{https://archives.haskell.org/projects.haskell.org/diagrams/, @@ -3568,33 +3458,19 @@ (define-public ghc-edit-distance-vector (define-public ghc-either (package (name "ghc-either") - (version "5.0.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "either" version)) - (sha256 - (base32 - "09yzki8ss56xhy9vggdw1rls86b2kf55hjl5wi0vbv02d8fxahq2")))) + (version "5.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "either" version)) + (sha256 + (base32 + "1gl748ia68bldbqb2fl7vjv44g0y8ivn659fjmy1qyypgyb5p95z")))) (build-system haskell-build-system) (properties '((upstream-name . "either"))) - (arguments - `(#:cabal-revision - ("1" "03bgnq55lc6f1nx4p662gidfsyyfm3xm4fi84h77wnsppxrpa5j1"))) - (inputs `(("ghc-bifunctors" ,ghc-bifunctors) - ("ghc-exceptions" ,ghc-exceptions) - ("ghc-free" ,ghc-free) - ("ghc-monad-control" ,ghc-monad-control) - ("ghc-manodrandom" ,ghc-monadrandom) - ("ghc-mmorph" ,ghc-mmorph) - ("ghc-profunctors" ,ghc-profunctors) - ("ghc-semigroups" ,ghc-semigroups) - ("ghc-semigroupoids" ,ghc-semigroupoids) - ("ghc-transformers-base" ,ghc-transformers-base))) - (native-inputs - (list ghc-quickcheck ghc-test-framework - ghc-test-framework-quickcheck2)) - (home-page "https://github.com/ekmett/either") + (inputs (list ghc-bifunctors ghc-profunctors ghc-semigroupoids)) + (native-inputs (list ghc-test-framework ghc-test-framework-quickcheck2 + ghc-quickcheck)) + (home-page "http://github.com/ekmett/either/") (synopsis "Provides an either monad transformer for Haskell") (description "This Haskell package provides an either monad transformer.") (license license:bsd-3))) @@ -3602,20 +3478,18 @@ (define-public ghc-either (define-public ghc-email-validate (package (name "ghc-email-validate") - (version "2.3.2.15") - (source - (origin - (method url-fetch) - (uri (hackage-uri "email-validate" version)) - (sha256 - (base32 - "0n67wss6k8lhwfkybkhsa04bbdfdv541sacbxlylkx2hqpj5r5gh")))) + (version "2.3.2.18") + (source (origin + (method url-fetch) + (uri (hackage-uri "email-validate" version)) + (sha256 + (base32 + "11bi5y5qmri62nl34nl5pv4zs59bjpjknw560yw5ds62gsi2sjcp")))) (build-system haskell-build-system) (properties '((upstream-name . "email-validate"))) - (inputs - (list ghc-attoparsec ghc-hspec ghc-quickcheck ghc-doctest)) - (home-page - "https://github.com/Porges/email-validate-hs") + (inputs (list ghc-attoparsec)) + (native-inputs (list ghc-hspec ghc-quickcheck ghc-doctest)) + (home-page "https://github.com/Porges/email-validate-hs") (synopsis "Email address validator for Haskell") (description "This Haskell package provides a validator that can validate an email @@ -3653,18 +3527,17 @@ (define-public ghc-enclosed-exceptions (define-public ghc-equivalence (package (name "ghc-equivalence") - (version "0.3.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "equivalence" version)) - (sha256 - (base32 "167njzd1cf32aa7br90rjafrxy6hw3fxkk8awifqbxjrcwm5maqp")))) + (version "0.4.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "equivalence" version)) + (sha256 + (base32 + "13q0lklm58n0l7bx0d4k1cw1i2il8hpdjp76lb79ix8lv7cxd2jr")))) (build-system haskell-build-system) (properties '((upstream-name . "equivalence"))) - (inputs - (list ghc-stmonadtrans ghc-transformers-compat ghc-fail - ghc-quickcheck)) + (inputs (list ghc-stmonadtrans ghc-transformers-compat ghc-fail)) + (native-inputs (list ghc-quickcheck)) (home-page "https://github.com/pa-ba/equivalence") (synopsis "Maintaining an equivalence relation implemented as union-find") (description @@ -3735,6 +3608,9 @@ (define-public ghc-errors (inputs (list ghc-exceptions ghc-transformers-compat ghc-unexceptionalio ghc-safe)) + (arguments + `(#:cabal-revision ("4" + "0sji6ny86f4j9ch1cyf2p1mcr5b2ighvw4bb9rssvypxb6k2r68f"))) (home-page "https://github.com/gabriel439/haskell-errors-library") (synopsis "Error handling library for Haskell") (description "This library encourages an error-handling style that @@ -3744,44 +3620,41 @@ (define-public ghc-errors (define-public ghc-esqueleto (package (name "ghc-esqueleto") - (version "3.5.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "esqueleto" version)) - (sha256 - (base32 - "0z3cf49sha6q965qw2m08jfmb91ki2rsdpnr7l39lka5b4ffxjlz")))) + (version "3.5.8.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "esqueleto" version)) + (sha256 + (base32 + "0k7h2hbxv14x0kq9w2wi83h0swzlri99ic9rj76540l39yqwjc5v")))) (build-system haskell-build-system) (properties '((upstream-name . "esqueleto"))) - (arguments - `(#:tests? #f)) ; TODO: Cannot connect to mysql server. - (inputs - (list ghc-aeson - ghc-attoparsec - ghc-blaze-html - ghc-conduit - ghc-monad-logger - ghc-persistent - ghc-resourcet - ghc-tagged - ghc-unliftio - ghc-unordered-containers - openssl - zlib)) - (native-inputs - (list ghc-hspec-core - ghc-hspec - ghc-mysql - ghc-mysql-simple - ghc-persistent-mysql - ghc-persistent-postgresql - ghc-persistent-sqlite - ghc-postgresql-simple - ghc-quickcheck)) + (inputs (list ghc-aeson + ghc-attoparsec + ghc-blaze-html + ghc-conduit + ghc-monad-logger + ghc-persistent + ghc-resourcet + ghc-tagged + ghc-unliftio + ghc-unordered-containers + openssl + zlib)) + (native-inputs (list ghc-hspec + ghc-hspec-core + ghc-mysql + ghc-mysql-simple + ghc-persistent-mysql + ghc-persistent-postgresql + ghc-persistent-sqlite + ghc-postgresql-simple + ghc-quickcheck)) + (arguments (list #:tests? #f)) ; Needs a running MySQLd. (home-page "https://github.com/bitemyapp/esqueleto") (synopsis "Type-safe embedded domain specific language for SQL queries") - (description "This library provides a type-safe embedded domain specific + (description + "This library provides a type-safe embedded domain specific language (EDSL) for SQL queries that works with SQL backends as provided by @code{ghc-persistent}. Its language closely resembles SQL, so you don't have to learn new concepts, just new syntax, and it's fairly easy to predict the @@ -3791,22 +3664,26 @@ (define-public ghc-esqueleto (define-public ghc-exactprint (package (name "ghc-exactprint") - (version "0.6.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ghc-exactprint" version)) - (sha256 - (base32 - "0a6baza962d4pz2m02hxmh8234i47zkizmwhsy68namr05dmlgpw")))) + (version "1.5.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "ghc-exactprint" version)) + (sha256 + (base32 + "07m4cg47knrrvpyimnbc0nq9176vkzwwa64b2iqfj6azn6q2hagp")))) (build-system haskell-build-system) (properties '((upstream-name . "ghc-exactprint"))) - (inputs - (list ghc-paths ghc-syb ghc-free)) - (native-inputs - (list ghc-hunit ghc-diff ghc-silently ghc-filemanip)) - (home-page - "https://hackage.haskell.org/package/ghc-exactprint") + (inputs (list ghc-ordered-containers + ghc-data-default + ghc-paths + ghc-syb + ghc-free + ghc-fail)) + (native-inputs (list ghc-hunit ghc-diff ghc-silently ghc-filemanip)) + (arguments + `(#:cabal-revision ("1" + "1v6my8bnhjhw7k3v2q9iwjpz9lj5g6ilvlzdq6svcabxahmzbr2c"))) + (home-page "http://hackage.haskell.org/package/ghc-exactprint") (synopsis "ExactPrint for GHC") (description "Using the API Annotations available from GHC 7.10.2, this library @@ -3884,22 +3761,21 @@ (define-public ghc-extensible-exceptions (define-public ghc-extra (package (name "ghc-extra") - (version "1.7.9") - (source - (origin - (method url-fetch) - (uri (hackage-uri "extra" version)) - (sha256 - (base32 - "17fzmxwrv0w7inhq7kia36prc2nsx845r9v56sihqvr17fk2cvpn")))) + (version "1.7.12") + (source (origin + (method url-fetch) + (uri (hackage-uri "extra" version)) + (sha256 + (base32 + "0g5h8fp0nq4k9asiknw0bhvb10zpfnsixfp0n3xz0rc83pnajwg5")))) (build-system haskell-build-system) (properties '((upstream-name . "extra"))) - (inputs - (list ghc-clock ghc-semigroups ghc-quickcheck - ghc-quickcheck-instances)) - (home-page "https://github.com/ndmitchell/extra") + (inputs (list ghc-clock)) + (native-inputs (list ghc-quickcheck ghc-quickcheck-instances)) + (home-page "https://github.com/ndmitchell/extra#readme") (synopsis "Extra Haskell functions") - (description "This library provides extra functions for the standard + (description + "This library provides extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.") @@ -3933,21 +3809,19 @@ (define-public ghc-fail (define-public ghc-fast-logger (package (name "ghc-fast-logger") - (version "3.0.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "fast-logger" version)) - (sha256 - (base32 - "1mbnah6n8lig494523czcd95dfn01f438qai9pf20wpa2gdbz4x6")))) + (version "3.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "fast-logger" version)) + (sha256 + (base32 + "1rx866swvqq7lzngv4bx7qinnwmm3aa2la8caljvbfbi0xz6wps3")))) (build-system haskell-build-system) (properties '((upstream-name . "fast-logger"))) - (inputs - (list ghc-auto-update ghc-easy-file ghc-unix-time ghc-unix-compat)) - (native-inputs - (list hspec-discover ghc-hspec)) - (home-page "https://hackage.haskell.org/package/fast-logger") + (inputs (list ghc-auto-update ghc-easy-file ghc-unix-time ghc-unix-compat + ghc-bytestring-builder hspec-discover)) + (native-inputs (list ghc-hspec)) + (home-page "https://github.com/kazu-yamamoto/logger") (synopsis "Fast logging system") (description "This library provides a fast logging system for Haskell.") (license license:bsd-3))) @@ -3955,37 +3829,35 @@ (define-public ghc-fast-logger (define-public ghc-feed (package (name "ghc-feed") - (version "1.3.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "feed" version)) - (sha256 - (base32 - "0kv3vx3njqlhwvkmf12m1gmwl8jj97kfa60da2362vwdavhcf4dk")))) + (version "1.3.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "feed" version)) + (sha256 + (base32 + "0marh7qmggq1z5339nid3gil7k786d3yk79b0rwfkxxaxmr41xd8")))) (build-system haskell-build-system) (properties '((upstream-name . "feed"))) - (arguments `(#:tests? #f)) ; TODO: Fail. - (inputs - (list ghc-base-compat - ghc-old-locale - ghc-old-time - ghc-safe - ghc-time-locale-compat - ghc-utf8-string - ghc-xml-conduit - ghc-xml-types)) - (native-inputs - (list ghc-doctest-driver-gen - ghc-doctest - ghc-hunit - ghc-markdown-unlit - ghc-syb - ghc-test-framework - ghc-test-framework-hunit)) - (home-page "https://github.com/bergmark/feed") + (inputs (list ghc-base-compat + ghc-old-locale + ghc-old-time + ghc-safe + ghc-time-locale-compat + ghc-utf8-string + ghc-xml-types + ghc-xml-conduit)) + (native-inputs (list ghc-hunit + ghc-markdown-unlit + ghc-syb + ghc-test-framework + ghc-test-framework-hunit + ghc-doctest + ghc-doctest-driver-gen)) + (arguments (list #:tests? #f)) ; Must be installed before testing. + (home-page "https://github.com/haskell-party/feed") (synopsis "Haskell package for handling various syndication formats") - (description "This Haskell package includes tools for generating and + (description + "This Haskell package includes tools for generating and consuming feeds in both RSS (Really Simple Syndication) and Atom format.") (license license:bsd-3))) @@ -4004,15 +3876,14 @@ (define-public ghc-fgl (build-system haskell-build-system) (properties '((upstream-name . "fgl"))) (arguments - `(#:phases + `(#:cabal-revision ("1" + "0d5b88j42a3f50b7kbksszvwvcgr59f8pcg3p6cvzq9f4n7y51s7") + #:phases (modify-phases %standard-phases (add-before 'configure 'update-constraints (lambda _ (substitute* "fgl.cabal" - (("QuickCheck >= 2\\.8 && < 2\\.13") - "QuickCheck >= 2.8 && < 2.14") - (("hspec >= 2\\.1 && < 2\\.7") - "hspec >= 2.1 && < 2.8"))))))) + (("hspec >= 2\\.1 && < 2\\.8") "hspec"))))))) (inputs (list ghc-hspec ghc-quickcheck)) (home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell") @@ -4039,6 +3910,13 @@ (define-public ghc-fgl-arbitrary (properties '((upstream-name . "fgl-arbitrary"))) (inputs (list ghc-fgl ghc-quickcheck ghc-hspec)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "fgl-arbitrary.cabal" + (("hspec >= 2\\.1 && < 2\\.8") "hspec"))))))) (home-page "https://hackage.haskell.org/package/fgl-arbitrary") (synopsis "QuickCheck support for fgl") (description @@ -4091,24 +3969,31 @@ (define-public ghc-filemanip file contents, and more.") (license license:bsd-3))) +;; Deprecated. (define-public ghc-filepath-bytestring (package (name "ghc-filepath-bytestring") - (version "1.4.2.1.8") - (source - (origin - (method url-fetch) - (uri (hackage-uri "filepath-bytestring" version)) - (sha256 - (base32 - "0qrrvbjpjsk75ghqrdqzwqg7wjgm3rr9kk7p04ax98ilv90pm0ip")))) + (version "1.4.2.1.12") + (source (origin + (method url-fetch) + (uri (hackage-uri "filepath-bytestring" version)) + (sha256 + (base32 + "0i8j724fz8h1bcqvlvp3sxmgyrvx2sim74cvzkpc9m05yn9p27sq")))) (build-system haskell-build-system) (properties '((upstream-name . "filepath-bytestring"))) - (native-inputs - (list ghc-quickcheck)) - (home-page "https://hackage.haskell.org/package/filepath-bytestring") + (native-inputs (list ghc-quickcheck)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "filepath-bytestring.cabal" + (("filepath >= 1\\.4\\.2 && <= 1\\.4\\.2\\.1") "filepath"))))))) + (home-page "http://hackage.haskell.org/package/filepath-bytestring") (synopsis "Library for manipulating RawFilePaths in a cross-platform way") - (description "This package provides a drop-in replacement for the standard + (description + "This package provides a drop-in replacement for the standard @code{filepath} library, operating on @code{RawFilePath} values rather than @code{FilePath} values to get the speed benefits of using @code{ByteStrings}.") (license license:bsd-3))) @@ -4138,22 +4023,22 @@ (define-public ghc-findbin (define-public ghc-fingertree (package (name "ghc-fingertree") - (version "0.1.4.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "fingertree" version)) - (sha256 - (base32 - "0zvandj8fysck7ygpn0dw5bhrhmj1s63i326nalxbfkh2ls4iacm")))) + (version "0.1.5.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "fingertree" version)) + (sha256 + (base32 + "0wdzpli8bpgk8lrsp105zb0y5gn1r2029laclvhz264bza93q9pk")))) (build-system haskell-build-system) (properties '((upstream-name . "fingertree"))) - (native-inputs - (list ghc-hunit ghc-quickcheck ghc-test-framework - ghc-test-framework-hunit ghc-test-framework-quickcheck2)) - (home-page "https://hackage.haskell.org/package/fingertree") + (native-inputs (list ghc-hunit ghc-quickcheck ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) + (home-page "http://hackage.haskell.org/package/fingertree") (synopsis "Generic finger-tree structure") - (description "This library provides finger trees, a general sequence + (description + "This library provides finger trees, a general sequence representation with arbitrary annotations, for use as a base for implementations of various collection types. It includes examples, as described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a @@ -4163,15 +4048,16 @@ (define-public ghc-fingertree (define-public ghc-finite-typelits (package (name "ghc-finite-typelits") - (version "0.1.4.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "finite-typelits" version)) - (sha256 - (base32 "0iyp9fyd2ki9qcmk9infz9p6rjhsx9jrs3f5yz0yqs8vj5na81yj")))) + (version "0.1.6.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "finite-typelits" version)) + (sha256 + (base32 + "0f047dywlxiz3pl3rq6maym9wpwjwl4zjqfwlwnj0yiv7dmlaiih")))) (build-system haskell-build-system) (properties '((upstream-name . "finite-typelits"))) + (native-inputs (list ghc-quickcheck)) (home-page "https://github.com/mniip/finite-typelits") (synopsis "Finitely many values, indexed by type-level naturals") (description @@ -4225,31 +4111,30 @@ (define-public ghc-fmlist (define-public ghc-foldl (package (name "ghc-foldl") - (version "1.4.12") - (source - (origin - (method url-fetch) - (uri (hackage-uri "foldl" version)) - (sha256 - (base32 - "0zf4yljh3s2ddxa7dhzdglmylj14kfldhkclc44g37zvjq6kcnag")))) + (version "1.4.13") + (source (origin + (method url-fetch) + (uri (hackage-uri "foldl" version)) + (sha256 + (base32 + "14vlhgf40qmwkznwza37z4www3q1v5acsx4nw5vmg25wdnc8ibfw")))) (build-system haskell-build-system) (properties '((upstream-name . "foldl"))) - (outputs '("out" "static" "doc")) - (inputs (list ghc-comonad - ghc-contravariant - ghc-hashable + (inputs (list ghc-random ghc-primitive + ghc-vector + ghc-unordered-containers + ghc-hashable + ghc-contravariant ghc-profunctors - ghc-random ghc-semigroupoids - ghc-semigroups - ghc-unordered-containers - ghc-vector)) + ghc-comonad + ghc-semigroups)) (native-inputs (list ghc-doctest)) - (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library") + (home-page "http://hackage.haskell.org/package/foldl") (synopsis "Composable, streaming, and efficient left folds for Haskell") - (description "This Haskell library provides strict left folds that stream + (description + "This Haskell library provides strict left folds that stream in constant memory, and you can combine folds using @code{Applicative} style to derive new folds. Derived folds still traverse the container just once and are often as efficient as hand-written folds.") @@ -4258,27 +4143,15 @@ (define-public ghc-foldl (define-public ghc-foundation (package (name "ghc-foundation") - (version "0.0.26.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "foundation" version)) - (sha256 - (base32 - "1hri3raqf6nhh6631gfm2yrkv4039gb0cqfa9cqmjp8bbqv28w5d")))) + (version "0.0.29") + (source (origin + (method url-fetch) + (uri (hackage-uri "foundation" version)) + (sha256 + (base32 + "1hbkh6a3g6wsj2z48pjimd7djkm82mdxfwc24bnmmzag8amrp0rl")))) (build-system haskell-build-system) (properties '((upstream-name . "foundation"))) - (arguments - `(#:phases - (modify-phases %standard-phases - ;; This test is broken. For details, see - ;; https://github.com/haskell-foundation/foundation/issues/530 - (add-after 'unpack 'patch-tests - (lambda _ - (substitute* "tests/Test/Foundation/Number.hs" - ((", testDividible proxy") "")) - #t))))) - (outputs '("out" "static" "doc")) (inputs (list ghc-basement)) (home-page "https://github.com/haskell-foundation/foundation") (synopsis "Alternative prelude with batteries and no dependencies") @@ -4297,37 +4170,33 @@ (define-public ghc-foundation @item Numerical classes that better represent mathematical things (no more all-in-one @code{Num}); @item I/O system with less lazy IO. -@end enumerate\n") +@end enumerate +") (license license:bsd-3))) (define-public ghc-free (package (name "ghc-free") - (version "5.1.7") - (source - (origin - (method url-fetch) - (uri (hackage-uri "free" version)) - (sha256 - (base32 - "121b81wxjk30nc27ivwzxjxi1dcwc30y0gy8l6wac3dxwvkx2c5j")))) - (build-system haskell-build-system) + (version "5.1.10") + (source (origin + (method url-fetch) + (uri (hackage-uri "free" version)) + (sha256 + (base32 + "0whff0r0nvii5l9z9crw7v0rj0wwblwbnfp99515siyxjkzs9phj")))) + (build-system haskell-build-system) (properties '((upstream-name . "free"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-prelude-extras - ghc-profunctors - ghc-exceptions - ghc-bifunctors - ghc-comonad - ghc-distributive - ghc-semigroupoids - ghc-semigroups - ghc-transformers-base - ghc-transformers-compat)) - (home-page "https://github.com/ekmett/free/") + (inputs (list ghc-comonad + ghc-distributive + ghc-indexed-traversable + ghc-semigroupoids + ghc-th-abstraction + ghc-transformers-base + ghc-profunctors)) + (home-page "http://github.com/ekmett/free/") (synopsis "Unrestricted monads for Haskell") - (description "This library provides free monads, which are useful for many + (description + "This library provides free monads, which are useful for many tree-like structures and domain specific languages. If @code{f} is a @code{Functor} then the free @code{Monad} on @code{f} is the type of trees whose nodes are labeled with the constructors of @code{f}. The word \"free\" @@ -4367,22 +4236,19 @@ (define-public ghc-fsnotify (define-public ghc-generic-deriving (package (name "ghc-generic-deriving") - (version "1.14.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "generic-deriving" version)) - (sha256 - (base32 - "19qpahcfhs9nqqv6na8znybrvpw885cajbdnrfylxbsmm0sys4s7")))) + (version "1.14.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "generic-deriving" version)) + (sha256 + (base32 + "0bxacg6b1vz135x93vf7jk6129m08hdyj7426ymaylfl2w8kapi6")))) (build-system haskell-build-system) (properties '((upstream-name . "generic-deriving"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-th-abstraction)) - (native-inputs - (list ghc-hspec hspec-discover)) - (home-page "https://hackage.haskell.org/package/generic-deriving") + (inputs (list ghc-th-abstraction)) + ;(native-inputs (list ghc-hspec)) + (arguments (list #:tests? #f)) ;; Cannot resolve package cycle. + (home-page "https://github.com/dreixel/generic-deriving") (synopsis "Generalise the deriving mechanism to arbitrary classes") (description "This package provides functionality for generalising the deriving mechanism in Haskell to arbitrary classes.") @@ -4391,23 +4257,17 @@ (define-public ghc-generic-deriving (define-public ghc-generic-random (package (name "ghc-generic-random") - (version "1.2.0.0") + (version "1.5.0.1") (source (origin (method url-fetch) - (uri (string-append - "https://hackage.haskell.org/package/generic-random/" - "generic-random-" version ".tar.gz")) + (uri (hackage-uri "generic-random" version)) (sha256 - (base32 "130lmblycxnpqbsl7vf6a90zccibnvcb5zaclfajcn3by39007lv")))) + (base32 "02iczjf2xc4sxfi234nf6irfj5slvf3p5hpaxl8r5nc8hy052d6x")))) (build-system haskell-build-system) (properties `((upstream-name . "generic-random"))) (inputs (list ghc-quickcheck)) - (native-inputs - (list ghc-inspection-testing)) - (arguments - `(#:cabal-revision - ("1" "1d0hx41r7yq2a86ydnfh2fv540ah8cz05l071s2z4wxcjw0ymyn4"))) + (native-inputs (list ghc-inspection-testing ghc-inspection-testing)) (home-page "https://github.com/lysxia/generic-random") (synopsis @@ -4429,83 +4289,47 @@ (define-public ghc-generic-random and @code{withBaseCase}) or implicitly (@code{genericArbitrary'}).") (license license:expat))) -(define-public ghc-generic-random-1.3.0.1 - (package - (inherit ghc-generic-random) - (version "1.4.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "generic-random" version)) - (sha256 - (base32 "12rvb1dzrfjc46n9vdcw3yv773iih8vwhrac3hpzq70yp2z77jdw")))) - (arguments '()))) - (define-public ghc-generics-sop (package (name "ghc-generics-sop") - (version "0.5.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "generics-sop" version)) - (sha256 - (base32 - "1n65wjdbb9fswa43ys5k6c746c905877lw5ij33y66iabj5w7dw1")))) + (version "0.5.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "generics-sop" version)) + (sha256 + (base32 + "098blydb7c7wg77dn658r0zb1z20vfkar1him1rqlq0da90437b3")))) (build-system haskell-build-system) (properties '((upstream-name . "generics-sop"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-sop-core ghc-th-abstraction)) - (home-page "https://github.com/well-typed/generics-sop") + (inputs (list ghc-sop-core ghc-th-abstraction)) + (arguments + `(#:cabal-revision ("1" + "1s8bx25yrjqy1cj9y1s1m8a8qlby9dxjzin16yymz7g39fqcqxz8"))) + (home-page "http://hackage.haskell.org/package/generics-sop") (synopsis "Generic Programming using True Sums of Products for Haskell") - (description "This Haskell package supports the definition of generic + (description + "This Haskell package supports the definition of generic functions. Datatypes are viewed in a uniform, structured way: the choice between constructors is represented using an n-ary sum, and the arguments of each constructor are represented using an n-ary product.") (license license:bsd-3))) -(define-public ghc-geniplate-mirror - (package - (name "ghc-geniplate-mirror") - (version "0.7.8") - (source - (origin - (method url-fetch) - (uri (hackage-uri "geniplate-mirror" version)) - (sha256 - (base32 "1kw4q7l556sfd82r2p0z3cv4sg8kcr45wb4s2sy996bs3ymn8fjb")))) - (build-system haskell-build-system) - (properties '((upstream-name . "geniplate-mirror"))) - (home-page "https://github.com/danr/geniplate") - (synopsis "Use Template Haskell to generate Uniplate-like functions") - (description - "Use Template Haskell to generate Uniplate-like functions. This is a -maintained mirror of the @uref{https://hackage.haskell.org/package/geniplate, -geniplate} package, written by Lennart Augustsson.") - (license license:bsd-3))) - (define-public ghc-genvalidity (package (name "ghc-genvalidity") - (version "0.11.0.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "genvalidity" version)) - (sha256 - (base32 - "16bd5dx0ngc8z7mij23i2l3a8v3c112x8ksd623alik18zx7pi8j")))) + (version "1.1.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "genvalidity" version)) + (sha256 + (base32 + "08xvbgzhi9f2s3g81zzd8yhrn66mr84m0dvp478nrbck19jdg5sq")))) (build-system haskell-build-system) (properties '((upstream-name . "genvalidity"))) - (inputs - (list ghc-quickcheck ghc-validity)) - (native-inputs - (list ghc-hspec hspec-discover ghc-hspec-core)) - (home-page - "https://github.com/NorfairKing/validity") - (synopsis - "Testing utilities for the @code{validity} library") + (inputs (list ghc-quickcheck ghc-random ghc-validity)) + (native-inputs (list ghc-hspec ghc-hspec-core hspec-discover)) + (home-page "https://github.com/NorfairKing/validity#readme") + (synopsis "Testing utilities for the @code{validity} library") (description "This package provides testing utilities that are useful in conjunction with the @code{Validity} typeclass.") @@ -4514,28 +4338,19 @@ (define-public ghc-genvalidity (define-public ghc-genvalidity-property (package (name "ghc-genvalidity-property") - (version "0.5.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "genvalidity-property" version)) - (sha256 - (base32 - "0cvzc4z4771vpycwfgcj0yswyglzl6cl1h2wrfhs224nrcmk5a7z")))) + (version "1.0.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "genvalidity-property" version)) + (sha256 + (base32 + "1nxcdq04rkckrb3v49pjx378n5s828k24x7hix6manyxqmd3hplw")))) (build-system haskell-build-system) (properties '((upstream-name . "genvalidity-property"))) - (inputs - (list ghc-quickcheck - ghc-genvalidity - ghc-hspec - hspec-discover - ghc-pretty-show - ghc-validity)) - (native-inputs (list ghc-doctest)) - (home-page - "https://github.com/NorfairKing/validity") - (synopsis - "Standard properties for functions on @code{Validity} types") + (inputs (list ghc-quickcheck ghc-genvalidity ghc-hspec ghc-pretty-show + ghc-validity hspec-discover)) + (home-page "https://github.com/NorfairKing/validity#readme") + (synopsis "Standard properties for functions on @code{Validity} types") (description "This package supplements the @code{Validity} typeclass with standard properties for functions operating on them.") @@ -4589,16 +4404,19 @@ (define-public ghc-gitrev (define-public ghc-glob (package (name "ghc-glob") - (version "0.10.1") + (version "0.10.2") (source (origin (method url-fetch) (uri (hackage-uri "Glob" version)) (sha256 (base32 - "05fknrb114qvfzv6324ngx0fz43cwgrhrc700l3h2is9jinlgr6a")))) + "1h3kh46qds4nqvixm4myy1kb5slg53f44hfn8aymrlr7hjn75xka")))) (build-system haskell-build-system) (properties '((upstream-name . "Glob"))) + (arguments + `(#:cabal-revision + ("3" "1080rd5073g87rfm5whimb72b75105lqanybrbsfi14gmvndnbfx"))) (inputs (list ghc-dlist ghc-semigroups ghc-transformers-compat)) (native-inputs @@ -4613,21 +4431,20 @@ (define-public ghc-glob (define-public ghc-gluraw (package (name "ghc-gluraw") - (version "2.0.0.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "GLURaw" version)) - (sha256 - (base32 - "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq")))) + (version "2.0.0.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "GLURaw" version)) + (sha256 + (base32 + "1b3rnva77k9naw5bl573bqgmsq7n9i8rrrvfvhbjcndqgmzhkini")))) (build-system haskell-build-system) (properties '((upstream-name . "GLURaw"))) - (inputs - (list ghc-openglraw)) - (home-page "https://wiki.haskell.org/Opengl") + (inputs (list ghc-openglraw)) + (home-page "http://www.haskell.org/haskellwiki/Opengl") (synopsis "Raw Haskell bindings GLU") - (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL + (description + "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL utility library. It is basically a 1:1 mapping of GLU's C API, intended as a basis for a nicer interface.") (license license:bsd-3))) @@ -4657,32 +4474,18 @@ (define-public ghc-glut (define-public ghc-gnuplot (package (name "ghc-gnuplot") - (version "0.5.6.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "gnuplot" version)) - (sha256 - (base32 "1rfq94lnsyjr8y9p5r56jpllv3p8rvh9xxzjji016b6r5adi8cnb")))) + (version "0.5.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "gnuplot" version)) + (sha256 + (base32 + "1glahh3si5bpazsklnpwxx4h4ivgb4wyngc032797zq1496fhhm3")))) (build-system haskell-build-system) (properties '((upstream-name . "gnuplot"))) - (inputs - (list ghc-temporary - ghc-utility-ht - ghc-data-accessor-transformers - ghc-data-accessor - ghc-semigroups - gnuplot)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-before 'configure 'fix-path-to-gnuplot - (lambda* (#:key inputs #:allow-other-keys) - (let ((gnuplot (assoc-ref inputs "gnuplot"))) - (substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs" - (("(gnuplotName = ).*$" all cmd) - (string-append cmd "\"" gnuplot "/bin/gnuplot\""))))))))) - (home-page "https://wiki.haskell.org/Gnuplot") + (inputs (list ghc-temporary ghc-utility-ht ghc-data-accessor-transformers + ghc-data-accessor ghc-semigroups)) + (home-page "http://www.haskell.org/haskellwiki/Gnuplot") (synopsis "2D and 3D plots using gnuplot") (description "This package provides a Haskell module for creating 2D and 3D plots using gnuplot.") @@ -4710,6 +4513,9 @@ (define-public ghc-graphviz (native-inputs (list ghc-hspec graphviz ghc-fgl-arbitrary ghc-quickcheck hspec-discover)) + (arguments + `(#:cabal-revision ("2" + "110yp1h2jrswllnx2ks772g10v9h4vqxc07b33wfaksyim9769bp"))) (home-page "https://hackage.haskell.org/package/graphviz") (synopsis "Bindings to Graphviz for graph visualisation") (description @@ -4752,20 +4558,17 @@ (define-public ghc-groups (define-public ghc-gtk2hs-buildtools (package (name "ghc-gtk2hs-buildtools") - (version "0.13.8.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "gtk2hs-buildtools" version)) - (sha256 - (base32 - "102x753jbc90lfm9s0ng5kvm0risqwpar331xwsd752as0bms142")))) + (version "0.13.8.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "gtk2hs-buildtools" version)) + (sha256 + (base32 + "0fcm0v32hm9j908nyziia16ahb181y9hqppsy18clx2prvj480rv")))) (build-system haskell-build-system) (properties '((upstream-name . "gtk2hs-buildtools"))) - (inputs - (list ghc-random ghc-hashtables)) - (native-inputs - (list ghc-alex ghc-happy)) + (inputs (list ghc-random ghc-hashtables)) + (native-inputs (list ghc-alex ghc-happy)) (home-page "https://projects.haskell.org/gtk2hs/") (synopsis "Tools to build the Gtk2Hs suite of user interface libraries") (description @@ -4780,42 +4583,37 @@ (define-public ghc-gtk2hs-buildtools (define-public ghc-hackage-security (package (name "ghc-hackage-security") - (version "0.6.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hackage-security" version)) - (sha256 - (base32 - "05rgz31cmp52137j4jk0074z8lfgk8mrf2x56bzw28asmxrv8qli")))) + (version "0.6.2.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "hackage-security" version)) + (sha256 + (base32 + "0rm0avcc1k247qbrajhzi3vz92cgcc4nr3kbhhfmfm8rjxv0bvjj")))) (build-system haskell-build-system) (properties '((upstream-name . "hackage-security"))) - (arguments - `(#:cabal-revision - ("8" "1xpzcdpfz0agbv75sadsylq6r8pq7zr0pyzbzrz0nz130yixsv5f") - #:tests? #f)) ; Tests fail because of framework updates. - (inputs - (list ghc-base16-bytestring - ghc-base64-bytestring - ghc-cryptohash-sha256 - ghc-ed25519 - ghc-lukko - ghc-network - ghc-network-uri - ghc-tar - ghc-zlib)) - (native-inputs - (list ghc-aeson - ghc-quickcheck - ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck - ghc-temporary - ghc-unordered-containers - ghc-vector)) + (inputs (list ghc-base16-bytestring + ghc-base64-bytestring + ghc-ed25519 + ghc-cryptohash-sha256 + ghc-tar + ghc-zlib + ghc-lukko + ghc-cabal-syntax + ghc-network-uri + ghc-network)) + (native-inputs (list ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-quickcheck + ghc-aeson + ghc-vector + ghc-unordered-containers + ghc-temporary)) (home-page "https://github.com/haskell/hackage-security") (synopsis "Hackage security library") - (description "This Hackage security library provides both server and + (description + "This Hackage security library provides both server and client utilities for securing @uref{http://hackage.haskell.org/, the Hackage package server}. It is based on @uref{http://theupdateframework.com/, The Update Framework}, a set of @@ -4827,14 +4625,14 @@ (define-public ghc-hackage-security (define-public ghc-haddock (package (name "ghc-haddock") - (version "2.24.2") + (version "2.26.0") (source (origin (method url-fetch) (uri (hackage-uri "haddock" version)) (sha256 (base32 - "1ha4hrnidwkmwalqwd1ixa2933as5n4sj1lvz0cx89a3png7r930")))) + "0jqp37pbz4zjqc3dm0jkcsdqsh2ql9ygnr06m75bbk330yqchnl3")))) (build-system haskell-build-system) (properties '((upstream-name . "haddock"))) (arguments @@ -4860,20 +4658,28 @@ (define-public ghc-haddock (define-public ghc-haddock-api (package (name "ghc-haddock-api") - (version "2.24.2") + (version "2.26.0") (source (origin (method url-fetch) (uri (hackage-uri "haddock-api" version)) (sha256 (base32 - "1jj2csi85nlywsyvnbwhclfdz27j2kyfbhrl9cm7av0243br9vg1")))) + "0ris5m61vig5nh5y2ddm98midl3v51vzgfgvsfyhm3nwk5hif6ay")))) (build-system haskell-build-system) (properties '((upstream-name . "haddock-api"))) (inputs (list ghc-paths ghc-haddock-library)) (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "haddock-api.cabal" + (("haddock-library \\^>= 1\\.9\\.0") "haddock-library") + (("hspec \\^>= 2.8") "hspec"))))))) (home-page "https://www.haskell.org/haddock/") (synopsis "API for documentation-generation tool Haddock") (description "This package provides an API to Haddock, the @@ -4893,7 +4699,16 @@ (define-public ghc-haddock-library "15ak06q8yp11xz1hwr0sg2jqi3r78p1n89ik05hicqvxl3awf1pq")))) (build-system haskell-build-system) (properties '((upstream-name . "haddock-library"))) - (arguments `(#:tests? #f)) ; TODO: optparse-applicative ==0.15.*, tree-diff ==0.1.* + (arguments + `(#:cabal-revision ("3" + "1fnfcr3gvdjrya0czr3k2sqv4xmmvyv66yni2mckfppra93mcglg") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "haddock-library.cabal" + (("(base-compat|hspec|optparse-applicative|tree-diff)\\s+[^,]+" all dep) + dep))))))) (native-inputs (list ghc-base-compat ghc-hspec @@ -4999,24 +4814,22 @@ (define-public ghc-happy (define-public ghc-hashable (package (name "ghc-hashable") - (version "1.3.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hashable" version)) - (sha256 - (base32 - "1d4sn4xjf0swrfg8pl93ipavbj12ch3a9aykhkl6mjnczc9m8bl2")))) + (version "1.4.1.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "hashable" version)) + (sha256 + (base32 + "11sycr73821amdz8g0k8c97igi4z7f9xdvgaxlkxhsp6h310bcz1")))) (build-system haskell-build-system) (properties '((upstream-name . "hashable"))) - (arguments - `(#:tests? #f ; TODO: Tests require random<1.2 - #:cabal-revision - ("2" "16va8hx4ynw0n5s2warhs13ilj7hrs5fcdn140h1fiix480as36n"))) - (native-inputs - (list ghc-test-framework ghc-test-framework-hunit - ghc-test-framework-quickcheck2 ghc-hunit ghc-quickcheck)) - (home-page "https://github.com/tibbe/hashable") + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-random + ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) + (home-page "http://github.com/haskell-unordered-containers/hashable") (synopsis "Class for types that can be converted to a hash value") (description "This package defines a class, @code{Hashable}, for types that can be @@ -5035,55 +4848,29 @@ (define-public ghc-hashable-bootstrap (native-inputs '()) (properties '((hidden? #t))))) -(define-public ghc-hashable-time - (package - (name "ghc-hashable-time") - (version "0.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hashable-time" version)) - (sha256 - (base32 - "1zw2gqagpbwq1hgx5rlvy6mhsnb15cxg3pmhawwv0ylfihmx2yxh")))) - (build-system haskell-build-system) - (properties '((upstream-name . "hashable-time"))) - (arguments - `(#:cabal-revision - ("1" "151gxiprdlj3masa95vvrxal9nwa72n3p1y15xyj4hp7mvvl4s2l"))) - (inputs - (list ghc-hashable ghc-time-compat)) - (home-page "https://hackage.haskell.org/package/hashable-time") - (synopsis "Hashable instances for Data.Time") - (description - "This package provides @code{Hashable} instances for types in -@code{Data.Time}.") - (license license:bsd-3))) - (define-public ghc-hashtables (package (name "ghc-hashtables") - (version "1.2.4.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hashtables" version)) - (sha256 - (base32 "0vgggm7bqq55zmqj6qji89bfj3k1rdkikkfhyg81vsqf0f3bzhqa")))) + (version "1.3.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hashtables" version)) + (sha256 + (base32 + "1hsrihk948xfpy14qrhar50b41kp60i1rx8bkadjg1xb4bml0gbg")))) (build-system haskell-build-system) (properties '((upstream-name . "hashtables"))) - (inputs - (list ghc-hashable ghc-primitive ghc-vector)) - (native-inputs - (list ghc-mwc-random - ghc-quickcheck - ghc-hunit - ghc-test-framework - ghc-test-framework-quickcheck2 - ghc-test-framework-hunit)) - (home-page "https://github.com/gregorycollins/hashtables") + (inputs (list ghc-hashable ghc-primitive ghc-vector)) + (native-inputs (list ghc-mwc-random + ghc-quickcheck + ghc-hunit + ghc-test-framework + ghc-test-framework-quickcheck2 + ghc-test-framework-hunit)) + (home-page "http://github.com/gregorycollins/hashtables") (synopsis "Haskell Mutable hash tables in the ST monad") - (description "This package provides a Haskell library including a + (description + "This package provides a Haskell library including a couple of different implementations of mutable hash tables in the ST monad, as well as a typeclass abstracting their common operations, and a set of wrappers to use the hash tables in the IO monad.") @@ -5092,23 +4879,31 @@ (define-public ghc-hashtables (define-public ghc-haskeline (package (name "ghc-haskeline") - (version "0.8.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "haskeline" version)) - (sha256 - (base32 - "0gqsa5s0drim9m42hv4wrq61mnvcdylxysfxfw3acncwilfrn9pb")))) + (version "0.8.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "haskeline" version)) + (sha256 + (base32 + "1pr7zik1138cj0463867i1qqb2bgsq716mryap18jx7zb9f1b7gc")))) (build-system haskell-build-system) (properties '((upstream-name . "haskeline"))) - (inputs (list ghc-exceptions)) - (native-inputs (list ghc-hunit)) - ;; FIXME: Tests failing - (arguments `(#:tests? #f)) + (native-inputs (list ghc-hunit which)) + (arguments + (list + #:tests? #f ; Cannot run binary haskeline-examples-Test, which is just + ; built, even with PATH and LD_LIBRARY_PATH set. + #:cabal-revision + '("3" "101qavk0fmc4c6qa307kswz3345psskxqyxhk6hmykynjm05jjrv") + #:phases + #~(modify-phases %standard-phases + (add-before 'configure 'patch-which + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "tests/Unit.hs" + (("\"which\"") + (string-append "\"" (search-input-file inputs "/bin/which") "\"")))))))) (home-page "https://github.com/judah/haskeline") - (synopsis - "Command-line interface for user input, written in Haskell") + (synopsis "Command-line interface for user input, written in Haskell") (description "Haskeline provides a user interface for line input in command-line programs. This library is similar in purpose to readline, but since it is @@ -5121,43 +4916,38 @@ (define-public ghc-haskeline (define-public ghc-haskell-lexer (package (name "ghc-haskell-lexer") - (version "1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "haskell-lexer" version)) - (sha256 - (base32 "1mb3np20ig0hbgnfxrzr3lczq7ya4p76g20lvnxch8ikck61afii")))) + (version "1.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "haskell-lexer" version)) + (sha256 + (base32 + "0jgkv1api3w7i9j5z01h7qdx2i9cp93h54hp9hj1bw9hk9bdmvn8")))) (build-system haskell-build-system) (properties '((upstream-name . "haskell-lexer"))) - (home-page "https://hackage.haskell.org/package/haskell-lexer") + (home-page "https://github.com/yav/haskell-lexer") (synopsis "Fully compliant Haskell 98 lexer") - (description - "This package provides a fully compliant Haskell 98 lexer.") - (license license:bsd-3))) + (description "This package provides a fully compliant Haskell 98 lexer.") + (license license:expat))) (define-public ghc-haskell-src (package (name "ghc-haskell-src") - (version "1.0.3.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "haskell-src" version)) - (sha256 - (base32 - "0cjigvshk4b8wqdk0v0hz9ag1kyjjsmqsy4a1m3n28ac008cg746")))) + (version "1.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "haskell-src" version)) + (sha256 + (base32 + "1spkhv83hy5v1lxs44l3w53vk8zj7gnx42c40hrkj4fcz6apdiwb")))) (build-system haskell-build-system) (properties '((upstream-name . "haskell-src"))) + (inputs (list ghc-happy ghc-syb)) (arguments - `(#:cabal-revision - ("4" "0cyqdw77clzz7mq0b4c0jg2d1kdz9xii41268w2psmqmfpyn29pc"))) - (inputs - (list ghc-happy ghc-syb)) - (home-page - "https://hackage.haskell.org/package/haskell-src") - (synopsis - "Support for manipulating Haskell source code") + `(#:cabal-revision ("1" + "0dfjzq0sxxcalqxygp2svx4890qx8b4amad0xldwy1f4xrp3lsnb"))) + (home-page "http://hackage.haskell.org/package/haskell-src") + (synopsis "Support for manipulating Haskell source code") (description "The @code{haskell-src} package provides support for manipulating Haskell source code. The package provides a lexer, parser and pretty-printer, and a @@ -5218,23 +5008,20 @@ (define-public ghc-haskell-src-exts-util (define-public ghc-haskell-src-meta (package (name "ghc-haskell-src-meta") - (version "0.8.7") + (version "0.8.11") (source (origin (method url-fetch) (uri (hackage-uri "haskell-src-meta" version)) (sha256 (base32 - "1yy2dfb1ip1zqx3xh28g92209555abzvxrxiwcl95j27zzqxc6in")))) + "1wks0xb7ah2gj9n0ffbcaskjihy45l99qkf2h9k13cyfvqkzp9rw")))) (build-system haskell-build-system) (properties '((upstream-name . "haskell-src-meta"))) - (inputs - (list ghc-haskell-src-exts ghc-syb ghc-th-orphans)) - (native-inputs - (list ghc-hunit ghc-tasty ghc-tasty-hunit)) - (home-page "https://hackage.haskell.org/package/haskell-src-meta") + (inputs (list ghc-haskell-src-exts ghc-syb ghc-th-orphans)) + (native-inputs (list ghc-hunit ghc-tasty ghc-tasty-hunit)) + (home-page "http://hackage.haskell.org/package/haskell-src-meta") (synopsis "Parse source to template-haskell abstract syntax") - (description - "This package provides tools to parse Haskell sources to the + (description "This package provides tools to parse Haskell sources to the template-haskell abstract syntax.") (license license:bsd-3))) @@ -5253,7 +5040,7 @@ (define-public ghc-hasktags (properties '((upstream-name . "hasktags"))) (arguments `(#:cabal-revision - ("1" "0q39ssdgm6lcmqj92frjvr53i34divx53zli0qar39mx8ka1l8ml"))) + ("2" "0f3v6k3bvsczz0z5i09286c0i74wz782vayzyp5lndqvrx3b4g0x"))) (inputs (list ghc-system-filepath ghc-optparse-applicative)) (native-inputs @@ -5314,52 +5101,25 @@ (define-public ghc-highlighting-kate (define-public ghc-hindent (package (name "ghc-hindent") - (version "5.3.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hindent" version)) - (sha256 - (base32 - "129gkn8qg68wsd60mq8yk7hrqsc8sd8v56xn41m5ii3hriq1mmv7")))) + (version "5.3.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "hindent" version)) + (sha256 + (base32 + "1pc20iza3v0ljzbx6cycm1j1kbmz8h95xwfq47fd6zfmsrx9w6vn")))) (build-system haskell-build-system) (properties '((upstream-name . "hindent"))) - (arguments - `(#:modules ((guix build haskell-build-system) - (guix build utils) - (guix build emacs-utils)) - #:imported-modules (,@%haskell-build-system-modules - (guix build emacs-utils)) - #:phases - (modify-phases %standard-phases - (add-after 'install 'emacs-install - (lambda* (#:key inputs outputs #:allow-other-keys) - (let* ((out (assoc-ref outputs "out")) - (elisp-file "elisp/hindent.el") - (dest (string-append out "/share/emacs/site-lisp")) - (emacs (search-input-file inputs "/bin/emacs"))) - (make-file-writable elisp-file) - (emacs-substitute-variables elisp-file - ("hindent-process-path" - (string-append out "/bin/hindent"))) - (install-file elisp-file dest) - (emacs-generate-autoloads "hindent" dest))))))) - (inputs - (list ghc-haskell-src-exts - ghc-monad-loops - ghc-utf8-string - ghc-exceptions - ghc-yaml - ghc-unix-compat - ghc-path - ghc-path-io - ghc-optparse-applicative)) - (native-inputs - `(("ghc-hspec" ,ghc-hspec) - ("ghc-diff" ,ghc-diff) - ("emacs" ,emacs-minimal))) - (home-page - "https://github.com/commercialhaskell/hindent") + (inputs (list ghc-haskell-src-exts + ghc-monad-loops + ghc-utf8-string + ghc-yaml + ghc-unix-compat + ghc-path + ghc-path-io + ghc-optparse-applicative)) + (native-inputs (list ghc-hspec ghc-diff)) + (home-page "https://github.com/mihaimaruseac/hindent") (synopsis "Extensible Haskell pretty printer") (description "This package provides automatic formatting for Haskell files. Both a @@ -5390,47 +5150,47 @@ (define-public ghc-hinotify (define-public ghc-hledger-lib (package (name "ghc-hledger-lib") - (version "1.21") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hledger-lib" version)) - (sha256 - (base32 - "00prslqk8vnbyz388cpc0nsamzy8xcjzday5q9n3m9lx4p2dhb5y")))) + (version "1.27.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hledger-lib" version)) + (sha256 + (base32 + "0w2jnpyfc6pp3n5fzdjd78hdh9vv9w98xwd2j6dw98rm6hlapwhb")))) (build-system haskell-build-system) (properties '((upstream-name . "hledger-lib"))) - (inputs - (list ghc-aeson - ghc-aeson-pretty - ghc-ansi-terminal - ghc-base-compat-batteries - ghc-blaze-markup - ghc-call-stack - ghc-cassava - ghc-cassava-megaparsec - ghc-cmdargs - ghc-data-default - ghc-decimal - ghc-extra - ghc-file-embed - ghc-glob - ghc-hashtables - ghc-megaparsec - ghc-old-time - ghc-parser-combinators - ghc-pretty-simple - ghc-regex-tdfa - ghc-safe - ghc-tabular - ghc-tasty - ghc-tasty-hunit - ghc-timeit - ghc-uglymemo - ghc-unordered-containers - ghc-utf8-string)) + (inputs (list ghc-decimal + ghc-glob + ghc-aeson + ghc-aeson-pretty + ghc-ansi-terminal + ghc-blaze-markup + ghc-breakpoint + ghc-call-stack + ghc-cassava + ghc-cassava-megaparsec + ghc-cmdargs + ghc-data-default + ghc-doclayout + ghc-extra + ghc-file-embed + ghc-hashtables + ghc-megaparsec + ghc-microlens + ghc-microlens-th + ghc-parser-combinators + ghc-pretty-simple + ghc-regex-tdfa + ghc-safe + ghc-tabular + ghc-tasty + ghc-tasty-hunit + ghc-timeit + ghc-uglymemo + ghc-unordered-containers + ghc-utf8-string)) (native-inputs (list ghc-doctest)) - (home-page "https://hledger.org") + (home-page "http://hledger.org") (synopsis "Reusable library providing the core functionality of hledger") (description "A reusable library containing hledger's core functionality. @@ -5574,10 +5334,11 @@ (define-public ghc-hourglass "0jnay5j13vpz6i1rkaj3j0d9v8jfpri499xn3l7wd01f81f5ncs4")))) (build-system haskell-build-system) (properties '((upstream-name . "hourglass"))) + (arguments (list #:tests? #f)) ; Tests incompatible with newer versions. (inputs (list ghc-old-locale)) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit)) + ;(native-inputs + ; (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit)) (home-page "https://github.com/vincenthz/hs-hourglass") (synopsis "Simple time-related library for Haskell") (description @@ -5591,38 +5352,35 @@ (define-public ghc-hourglass (define-public ghc-hpack (package (name "ghc-hpack") - (version "0.34.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hpack" version)) - (sha256 - (base32 - "0gmm6jgi1sgyilphww6apq1x04grqznm7xhyb7g1rj5j7my40ws2")))) + (version "0.35.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hpack" version)) + (sha256 + (base32 + "1hpc6bwx94v943p73l12nnncbs656f2fn7q3hb4qs13xrxygzl4g")))) (build-system haskell-build-system) (properties '((upstream-name . "hpack"))) - (inputs - (list ghc-aeson - ghc-bifunctors - ghc-cryptonite - ghc-glob - ghc-http-client - ghc-http-client-tls - ghc-http-types - ghc-infer-license - ghc-scientific - ghc-unordered-containers - ghc-vector - ghc-yaml)) - (native-inputs - (list ghc-hspec - ghc-hunit - ghc-interpolate - ghc-mockery - ghc-quickcheck - ghc-temporary - hspec-discover)) - (home-page "https://github.com/sol/hpack") + (inputs (list ghc-glob + ghc-aeson + ghc-bifunctors + ghc-cryptonite + ghc-http-client + ghc-http-client-tls + ghc-http-types + ghc-infer-license + ghc-scientific + ghc-unordered-containers + ghc-vector + ghc-yaml)) + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-hspec + ghc-interpolate + ghc-mockery + ghc-temporary + hspec-discover)) + (home-page "https://github.com/sol/hpack#readme") (synopsis "Tools for an alternative Haskell package format") (description "Hpack is a format for Haskell packages. It is an alternative to the @@ -5692,8 +5450,8 @@ (define-public ghc-hslogger (build-system haskell-build-system) (properties '((upstream-name . "hslogger"))) (arguments - `(#:cabal-revision - ("3" "04mda3bwr2a00f5nbkqc84d46lmqfsk3gibzg3amdh74ngb451xq"))) + `(#:cabal-revision ("6" + "0xiqjl646kxynsccc2q1q91sch7pfx3274yl2745fsqhpb115df1"))) (inputs (list ghc-network ghc-old-locale)) (native-inputs @@ -5709,29 +5467,29 @@ (define-public ghc-hslogger (define-public ghc-hslua (package (name "ghc-hslua") - (version "1.3.0.2") + (version "2.2.1") (source (origin (method url-fetch) (uri (hackage-uri "hslua" version)) (sha256 (base32 - "0p39xm0mmxzs5x6aim11qkb7npn0d9h7li2kwfhry0dijd1vm18i")))) + "1q587cjwb29jsf71hhmra6djr2sycbx2hr0rhwlgvb8ax699vkv3")))) (build-system haskell-build-system) (properties '((upstream-name . "hslua"))) - (arguments - `(#:configure-flags '("-fsystem-lua") - #:extra-directories ("lua"))) - (inputs - (list lua ghc-base-compat)) - (native-inputs - (list ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck - ghc-quickcheck - ghc-quickcheck-instances - ghc-fail - ghc-semigroups)) - (home-page "https://hackage.haskell.org/package/hslua") + (inputs (list ghc-hslua-aeson + ghc-hslua-core + ghc-hslua-classes + ghc-hslua-marshalling + ghc-hslua-objectorientation + ghc-hslua-packaging)) + (native-inputs (list ghc-lua + ghc-lua-arbitrary + ghc-quickcheck + ghc-quickcheck-instances + ghc-tasty-hslua + ghc-tasty + ghc-tasty-hunit)) + (home-page "https://hslua.org/") (synopsis "Lua language interpreter embedding in Haskell") (description "The Scripting.Lua module is a wrapper of the Lua language interpreter as @@ -5741,23 +5499,22 @@ (define-public ghc-hslua (define-public ghc-hslua-module-system (package (name "ghc-hslua-module-system") - (version "0.2.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hslua-module-system" version)) - (sha256 - (base32 - "0hk2splyasbplnggknjhlb423axc5b32xq8aq8zal4vvwlqhzvf1")))) + (version "1.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-module-system" version)) + (sha256 + (base32 + "0lacf9jzd53r75dk5nvkx0nwgiakpkingjnz58bhjfnvi81r6ddn")))) (build-system haskell-build-system) (properties '((upstream-name . "hslua-module-system"))) - (inputs - (list ghc-hslua ghc-temporary)) - (native-inputs - (list ghc-tasty ghc-tasty-lua ghc-tasty-hunit)) - (home-page "https://github.com/hslua/hslua-module-system") + (inputs (list ghc-hslua-core ghc-hslua-packaging ghc-hslua-marshalling + ghc-temporary)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua)) + (home-page "https://github.com/hslua/hslua") (synopsis "Lua module wrapper around Haskell's System module") - (description "This library provides access to system information and + (description + "This library provides access to system information and functionality to Lua scripts via Haskell's @code{System} module. Intended usage for this package is to preload it by adding the loader function to @code{package.preload}. Note that the Lua @code{package} library must have @@ -5767,21 +5524,18 @@ (define-public ghc-hslua-module-system (define-public ghc-hslua-module-text (package (name "ghc-hslua-module-text") - (version "0.3.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hslua-module-text" version)) - (sha256 - (base32 - "1vmd15n905i2pcsx748hz3h9kv5nnv74y663rj57q8mp0b40cbfl")))) + (version "1.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-module-text" version)) + (sha256 + (base32 + "0xq5ndgjhs37d73s8lvm0pndwjpj2pqb67pr0ckjap8yzhjna7fq")))) (build-system haskell-build-system) (properties '((upstream-name . "hslua-module-text"))) - (inputs - (list ghc-hslua)) - (native-inputs - (list ghc-tasty ghc-tasty-lua ghc-tasty-hunit)) - (home-page "https://github.com/hslua/hslua-module-text") + (inputs (list ghc-hslua-core ghc-hslua-packaging ghc-hslua-marshalling)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua)) + (home-page "https://github.com/hslua/hslua") (synopsis "Lua module for text") (description "This package provides a UTF-8 aware subset of Lua's @code{string} module @@ -5792,28 +5546,23 @@ (define-public ghc-hslua-module-text (define-public ghc-hsyaml (package (name "ghc-hsyaml") - (version "0.2.1.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "HsYAML" version)) - (sha256 - (base32 - "10qzhsg789h37q22hm9p27dx4rhbykcbxp7p3pvkws8fr7ajgxv0")))) + (version "0.2.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "HsYAML" version)) + (sha256 + (base32 + "0a7nbvpl4p8kwbbjfn1dj6s3fif5k8zhbckdvyz1k74pj3yb8ns6")))) (build-system haskell-build-system) (properties '((upstream-name . "HsYAML"))) + (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-quickcheck)) (arguments - `(#:tests? #f ; TODO: Loops. - #:cabal-revision - ("2" "0f7867jfzlmlqnkv3fjrzjvvfzjlvhbm10kmg7n0qk69ic8grkbc"))) -; (native-inputs -; `(("ghc-hsyaml" ,ghc-hsyaml) -; ("ghc-quickcheck" ,ghc-quickcheck) -; ("ghc-tasty" ,ghc-tasty) -; ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + `(#:cabal-revision ("1" + "0jmbgrjywcblrd8k6zzv2b5givdz83f479y15v5gs0r93z25xpmv"))) (home-page "https://github.com/haskell-hvr/HsYAML") (synopsis "Pure Haskell YAML 1.2 parser") - (description "This library provides a + (description + "This library provides a @url{http://yaml.org/spec/1.2/spec.html, YAML 1.2} parser implementation for Haskell. Its features include: @@ -5843,34 +5592,31 @@ (define-public ghc-hsyaml (define-public ghc-http-api-data (package (name "ghc-http-api-data") - (version "0.4.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "http-api-data" version)) - (sha256 - (base32 - "0xzfvxxh33ivlnrnzmm19cni3jgb5ph18n9hykkw3d6l3rhwzcnl")))) + (version "0.4.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "http-api-data" version)) + (sha256 + (base32 + "171bw2a44pg50d3y77gw2y9vmx72laky7hnn5hw6r93pnjmlf9yz")))) (build-system haskell-build-system) (properties '((upstream-name . "http-api-data"))) (inputs (list ghc-attoparsec ghc-attoparsec-iso8601 + ghc-base-compat ghc-cookie ghc-hashable ghc-http-types + ghc-tagged ghc-time-compat ghc-unordered-containers ghc-uuid-types)) - (native-inputs - (list cabal-doctest - ghc-nats - ghc-hunit - ghc-hspec - ghc-quickcheck - ghc-quickcheck-instances - ghc-doctest - hspec-discover)) - (home-page "https://github.com/fizruk/http-api-data") + (native-inputs (list ghc-hunit ghc-hspec ghc-quickcheck + ghc-quickcheck-instances hspec-discover)) + (arguments + `(#:cabal-revision ("6" + "0q4rhz81r5v0z1mn7x9q0ldbfv1a2cp3dpw8s2j96halsq34l4zl"))) + (home-page "http://github.com/fizruk/http-api-data") (synopsis "Convert to/from HTTP API data like URL pieces, headers and query parameters") (description "This Haskell package defines typeclasses used for converting @@ -5968,19 +5714,18 @@ (define-public ghc-infer-license (define-public ghc-ini (package (name "ghc-ini") - (version "0.4.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ini" version)) - (sha256 - (base32 "0mvwii8jbh2ll54qb9dij5m66c6324s2y4vrwz1qr4wz40m3qa8l")))) + (version "0.4.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "ini" version)) + (sha256 + (base32 + "0dp9c48vli8z6058yajnqg9hyf9swglk8ga4wcwl03aal7n8r7gp")))) (build-system haskell-build-system) (properties '((upstream-name . "ini"))) + (inputs (list ghc-attoparsec ghc-unordered-containers)) (native-inputs (list ghc-hspec)) - (inputs - (list ghc-attoparsec ghc-unordered-containers)) - (home-page "https://github.com/chrisdone/ini") + (home-page "https://github.com/andreasabel/ini") (synopsis "Haskell library to easily handle configuration files in the INI format") (description @@ -5991,23 +5736,24 @@ (define-public ghc-ini (define-public ghc-inline-c (package (name "ghc-inline-c") - (version "0.9.1.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "inline-c" version)) - (sha256 - (base32 - "0a0m3bhh910c5g46cwkxgflsgw5ab7lzymwll9hijyvwgnsw3h7i")))) + (version "0.9.1.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "inline-c" version)) + (sha256 + (base32 + "06az494fp2nh6fnibq28yw8jsrpj4jq1swyx53a328qv04cbhrym")))) (build-system haskell-build-system) (properties '((upstream-name . "inline-c"))) - (inputs - (list ghc-ansi-wl-pprint ghc-hashable ghc-parsers - ghc-unordered-containers ghc-vector)) - (native-inputs - (list ghc-quickcheck ghc-hspec ghc-raw-strings-qq ghc-regex-posix - ghc-split)) - (home-page "https://hackage.haskell.org/package/inline-c") + (inputs (list ghc-ansi-wl-pprint ghc-hashable ghc-parsers + ghc-unordered-containers ghc-vector)) + (native-inputs (list ghc-quickcheck + ghc-hspec + ghc-quickcheck + ghc-raw-strings-qq + ghc-regex-posix + ghc-split)) + (home-page "http://hackage.haskell.org/package/inline-c") (synopsis "Write Haskell source files including C code inline") (description "inline-c lets you seamlessly call C libraries and embed high-performance @@ -6019,21 +5765,18 @@ (define-public ghc-inline-c (define-public ghc-inline-c-cpp (package (name "ghc-inline-c-cpp") - (version "0.4.0.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "inline-c-cpp" version)) - (sha256 - (base32 - "0bqrhyic3cw1pqg7knsmkqx5swpr4kvf9bmz0mhmqbl6brmv5il0")))) + (version "0.5.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "inline-c-cpp" version)) + (sha256 + (base32 + "0m14nb9brpnh2cgq8gg6182mdcmn45hf734la68dnhq23sn63lpx")))) (build-system haskell-build-system) (properties '((upstream-name . "inline-c-cpp"))) - (inputs - (list ghc-inline-c ghc-safe-exceptions)) - (native-inputs - (list ghc-hspec)) - (home-page "https://hackage.haskell.org/package/inline-c-cpp") + (inputs (list ghc-inline-c ghc-safe-exceptions)) + (native-inputs (list ghc-hspec ghc-vector)) + (home-page "http://hackage.haskell.org/package/inline-c-cpp") (synopsis "Lets you embed C++ code into Haskell") (description "This package provides utilities to inline C++ code into Haskell using @@ -6053,7 +5796,6 @@ (define-public ghc-integer-logarithms "0zzapclfabc76g8jzsbsqwdllx2zn0gp4raq076ib6v0mfgry2lv")))) (build-system haskell-build-system) (properties '((upstream-name . "integer-logarithms"))) - (arguments `(#:tests? #f)) ; TODO: Needs tasty<1.4 (native-inputs (list ghc-quickcheck ghc-smallcheck @@ -6061,6 +5803,17 @@ (define-public ghc-integer-logarithms ghc-tasty-hunit ghc-tasty-quickcheck ghc-tasty-smallcheck)) + (arguments + `(#:cabal-revision ("3" + "0z81yksgx20d0rva41blsjcp3jsp1qy9sy385fpig0l074fzv6ym") + #:phases + (modify-phases %standard-phases + ;; Needs tasty<1.4 + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "integer-logarithms.cabal" + (("(tasty)\\s+[^,]+" all dep) + dep))))))) (home-page "https://github.com/Bodigrim/integer-logarithms") (synopsis "Integer logarithms") (description @@ -6153,32 +5906,32 @@ (define-public ghc-intervals (define-public ghc-invariant (package (name "ghc-invariant") - (version "0.5.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "invariant" version)) - (sha256 - (base32 - "1jlp0gbfjsx7k08275djh8m3v4rpg8llw5gdkg9s9qfx0lc0mymr")))) + (version "0.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "invariant" version)) + (sha256 + (base32 + "07ffgcfpacsdihcmcmx2m1gp8czlg28657bxncxjykjiiiwjlaxm")))) (build-system haskell-build-system) (properties '((upstream-name . "invariant"))) - (inputs - (list ghc-bifunctors - ghc-comonad - ghc-contravariant - ghc-profunctors - ghc-semigroups - ghc-statevar - ghc-tagged - ghc-th-abstraction - ghc-transformers-compat - ghc-unordered-containers)) - (native-inputs - (list ghc-hspec ghc-quickcheck hspec-discover)) + (inputs (list ghc-bifunctors + ghc-comonad + ghc-contravariant + ghc-profunctors + ghc-statevar + ghc-tagged + ghc-th-abstraction + ghc-transformers-compat + ghc-unordered-containers)) + (native-inputs (list ghc-hspec ghc-quickcheck hspec-discover)) + (arguments + `(#:cabal-revision ("1" + "0551ll1swnrmq09j89jqnxl4qnirbbpdpsdym23adaf36qdd7v37"))) (home-page "https://github.com/nfrisby/invariant-functors") (synopsis "Haskell98 invariant functors") - (description "Haskell98 invariant functors (also known as exponential + (description + "Haskell98 invariant functors (also known as exponential functors). For more information, see Edward Kmett's article @uref{http://comonad.com/reader/2008/rotten-bananas/, Rotten Bananas}.") (license license:bsd-2))) @@ -6186,31 +5939,24 @@ (define-public ghc-invariant (define-public ghc-io-streams (package (name "ghc-io-streams") - (version "1.5.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "io-streams" version)) - (sha256 - (base32 - "1y3sqmxrwiksz7pl4hf3vzvg8p8n00qnv98nj5xbpcadlh468rny")))) + (version "1.5.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "io-streams" version)) + (sha256 + (base32 + "1zn4iyd18g9jc1qdgixp6hi56nj7czy4jdz2xca59hcn2q2xarfk")))) (build-system haskell-build-system) (properties '((upstream-name . "io-streams"))) - (inputs - (list ghc-attoparsec - ghc-bytestring-builder - ghc-network - ghc-primitive - ghc-vector - ghc-zlib-bindings)) - (native-inputs - (list ghc-hunit - ghc-quickcheck - ghc-test-framework - ghc-test-framework-hunit - ghc-test-framework-quickcheck2 - ghc-zlib)) - (home-page "https://hackage.haskell.org/package/io-streams") + (inputs (list ghc-attoparsec ghc-primitive ghc-vector ghc-zlib-bindings + ghc-network)) + (native-inputs (list ghc-zlib + ghc-hunit + ghc-quickcheck + ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2)) + (home-page "http://hackage.haskell.org/package/io-streams") (synopsis "Simple and composable stream I/O") (description "This library contains simple and easy-to-use primitives for I/O using streams.") @@ -6230,8 +5976,8 @@ (define-public ghc-io-streams-haproxy (build-system haskell-build-system) (properties '((upstream-name . "io-streams-haproxy"))) (arguments - `(#:cabal-revision - ("3" "02k9halblgnynlm781ahc81yxla8z7cck1gikm8555v78rf5hv7x"))) + `(#:cabal-revision ("6" + "024aw98q1x3fb1xq07qki3z446w6lk5gyjl13shy0dbrd5aafh92"))) (inputs (list ghc-attoparsec ghc-io-streams ghc-network)) (native-inputs @@ -6248,23 +5994,22 @@ (define-public ghc-io-streams-haproxy (define-public ghc-iproute (package (name "ghc-iproute") - (version "1.7.11") - (source - (origin - (method url-fetch) - (uri (hackage-uri "iproute" version)) - (sha256 - (base32 - "12wa59b1zgjqp8dmygq2x44ml0cb89fhn1k0zkj4aqz7rhkwsp90")))) + (version "1.7.12") + (source (origin + (method url-fetch) + (uri (hackage-uri "iproute" version)) + (sha256 + (base32 + "0qvb4d7nw8f6j4s09cnpn6z1rdwcwknwklfrhsgivg7wg4aisxgi")))) (build-system haskell-build-system) (properties '((upstream-name . "iproute"))) - (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder, - ; exported by ghc-byteorder. Doctest issue. - (inputs - (list ghc-appar ghc-byteorder ghc-network ghc-safe)) - (home-page "https://www.mew.org/~kazu/proj/iproute/") + (inputs (list ghc-appar ghc-byteorder ghc-network ghc-semigroups)) + (native-inputs (list ghc-doctest ghc-hspec ghc-quickcheck ghc-safe + hspec-discover)) + (home-page "http://www.mew.org/~kazu/proj/iproute/") (synopsis "IP routing table") - (description "IP Routing Table is a tree of IP ranges to search one of + (description + "IP Routing Table is a tree of IP ranges to search one of them on the longest match base. It is a kind of TRIE with one way branching removed. Both IPv4 and IPv6 are supported.") (license license:bsd-3))) @@ -6272,24 +6017,26 @@ (define-public ghc-iproute (define-public ghc-ipynb (package (name "ghc-ipynb") - (version "0.1.0.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ipynb" version)) - (sha256 - (base32 - "0qky4l5aaiq7ypwbxh0mr7s572290fi596f18dg68qpyzc49a9kx")))) + (version "0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "ipynb" version)) + (sha256 + (base32 + "1iwia4sxg40m4d290gys72wabqmkqx24ywsaranwzk2wx5s3sx4s")))) (build-system haskell-build-system) (properties '((upstream-name . "ipynb"))) - (inputs - (list ghc-unordered-containers ghc-base64-bytestring ghc-aeson - ghc-semigroups)) - (native-inputs - (list ghc-tasty ghc-tasty-hunit ghc-microlens-aeson ghc-microlens)) - (home-page "https://hackage.haskell.org/package/ipynb") + (inputs (list ghc-unordered-containers ghc-base64-bytestring ghc-aeson + ghc-semigroups)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-microlens-aeson + ghc-microlens)) + (arguments + `(#:cabal-revision ("1" + "0fl9x5amq0g5dg57dcgc0g4ir0r1fdbx06aldsqdwzdc9zs97v6k"))) + (home-page "http://hackage.haskell.org/package/ipynb") (synopsis "Data structure for working with Jupyter notebooks") - (description "This library defines a data structure for representing + (description + "This library defines a data structure for representing Jupyter notebooks, along with @code{ToJSON} and @code{FromJSON} instances for conversion to and from JSON .ipynb files.") (license license:bsd-3))) @@ -6346,18 +6093,16 @@ (define-public ghc-json (define-public ghc-juicypixels (package (name "ghc-juicypixels") - (version "3.3.6") + (version "3.3.7") (source (origin (method url-fetch) (uri (hackage-uri "JuicyPixels" version)) (sha256 (base32 - "1f8giivsqxma19ax78dr7j4gir12iyfqn2mlsd27zzl8dn7dy6w1")))) + "1rrvapzcj0q8sigxq1zq2k4h88i1r2hyca4p7pkqa1b4pk6vhdny")))) (build-system haskell-build-system) (properties '((upstream-name . "JuicyPixels"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-zlib ghc-vector ghc-primitive)) + (inputs (list ghc-zlib ghc-vector ghc-primitive)) (home-page "https://github.com/Twinside/Juicy.Pixels") (synopsis "Picture loading and serialization library") (description @@ -6368,29 +6113,29 @@ (define-public ghc-juicypixels (define-public ghc-kan-extensions (package (name "ghc-kan-extensions") - (version "5.2.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "kan-extensions" version)) - (sha256 - (base32 - "1rkjxwc2k2425d2shdra6wzd4f4dpj76hxmq8mish4f0lz9gxxml")))) + (version "5.2.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "kan-extensions" version)) + (sha256 + (base32 + "08mddsk9v75mahp1jqn28vglygmdil1g37drcj3ivbqc0k6dq55r")))) (build-system haskell-build-system) (properties '((upstream-name . "kan-extensions"))) - (inputs - (list ghc-adjunctions - ghc-comonad - ghc-contravariant - ghc-distributive - ghc-free - ghc-invariant - ghc-semigroupoids - ghc-tagged - ghc-transformers-compat)) - (home-page "https://github.com/ekmett/kan-extensions/") + (inputs (list ghc-adjunctions + ghc-comonad + ghc-contravariant + ghc-distributive + ghc-invariant + ghc-free + ghc-profunctors + ghc-semigroupoids + ghc-tagged + ghc-transformers-compat)) + (home-page "http://github.com/ekmett/kan-extensions/") (synopsis "Kan extensions library") - (description "This library provides Kan extensions, Kan lifts, various + (description + "This library provides Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads for Haskell.") (license license:bsd-3))) @@ -6483,73 +6228,67 @@ (define-public ghc-language-haskell-extract (define-public ghc-lens (package (name "ghc-lens") - (version "4.19.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lens" version)) - (sha256 - (base32 - "0fy2vr5r11cc6ana8m2swqgs3zals4kims55vd6119bi76p5iy2j")))) + (version "5.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "lens" version)) + (sha256 + (base32 + "08mkm2mjvhmwg9hc4kd4cd6dgmcszs1p2mzp1nmri7lqbpy9jknc")))) (build-system haskell-build-system) (properties '((upstream-name . "lens"))) + (inputs (list ghc-assoc + ghc-base-orphans + ghc-bifunctors + ghc-call-stack + ghc-comonad + ghc-contravariant + ghc-distributive + ghc-free + ghc-hashable + ghc-indexed-traversable + ghc-indexed-traversable-instances + ghc-kan-extensions + ghc-parallel + ghc-profunctors + ghc-reflection + ghc-semigroupoids + ghc-strict + ghc-tagged + ghc-th-abstraction + ghc-these + ghc-transformers-compat + ghc-unordered-containers + ghc-vector)) + (native-inputs (list ghc-quickcheck + ghc-test-framework + ghc-test-framework-quickcheck2 + ghc-hunit + ghc-test-framework + ghc-test-framework-hunit + ghc-simple-reflect)) (arguments - `(#:tests? #f ; TODO: Needs vector<0.12.2 - #:cabal-revision - ("6" "1k08my9rh1il3ibiyhljxkgndfgk143pn5a6nyzjnckw3la09myl"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-base-orphans - ghc-bifunctors - ghc-distributive - ghc-exceptions - ghc-free - ghc-kan-extensions - ghc-parallel - ghc-reflection - ghc-semigroupoids - ghc-vector - ghc-call-stack - ghc-comonad - ghc-contravariant - ghc-hashable - ghc-profunctors - ghc-semigroups - ghc-tagged - ghc-transformers-compat - ghc-unordered-containers - ghc-void - ghc-generic-deriving - ghc-nats - ghc-simple-reflect - hlint)) - (native-inputs - (list cabal-doctest - ghc-doctest - ghc-hunit - ghc-test-framework - ghc-test-framework-hunit - ghc-test-framework-quickcheck2 - ghc-quickcheck)) - (home-page "https://github.com/ekmett/lens/") + `(#:cabal-revision ("1" + "19z3k7ikpfa96b86yabxghfqpnq9d0ayy4gdlvci3ycvws0s8cy6"))) + (home-page "http://github.com/ekmett/lens/") (synopsis "Lenses, Folds and Traversals") - (description "This library provides @code{Control.Lens}. The combinators + (description + "This library provides @code{Control.Lens}. The combinators in @code{Control.Lens} provide a highly generic toolbox for composing families of getters, folds, isomorphisms, traversals, setters and lenses and their indexed variants.") - (license license:bsd-3))) + (license license:bsd-2))) (define-public ghc-lens-family-core (package (name "ghc-lens-family-core") - (version "2.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lens-family-core" version)) - (sha256 - (base32 - "0ni6s873hy2h3b316835ssmlyr05yinb3a8jq5b01p9ppp9zrd0r")))) + (version "2.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "lens-family-core" version)) + (sha256 + (base32 + "1dkkd33wh2ykgis92dpshjxz6d2d41dvjj4zz6b7mdy8frr9jnhv")))) (build-system haskell-build-system) (properties '((upstream-name . "lens-family-core"))) (home-page @@ -6576,19 +6315,16 @@ (define-public ghc-lens-family-core (define-public ghc-libffi (package (name "ghc-libffi") - (version "0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "libffi" version)) - (sha256 - (base32 - "0g7jnhng3j7z5517aaqga0144aamibsbpgm3yynwyfzkq1kp0f28")))) + (version "0.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "libffi" version)) + (sha256 + (base32 + "1w9ssmjx521f4lmaynmh1zargl2zmfvvpq2bldsvnwldfdgikbkn")))) (build-system haskell-build-system) (properties '((upstream-name . "libffi"))) - (native-inputs (list pkg-config)) - (inputs (list libffi)) - (home-page "https://hackage.haskell.org/package/libffi") + (home-page "http://haskell.org/haskellwiki/Library/libffi") (synopsis "Haskell binding to libffi") (description "A binding to libffi, allowing C functions of types only known at runtime @@ -6622,22 +6358,21 @@ (define-public ghc-libmpd (define-public ghc-lib-parser (package (name "ghc-lib-parser") - (version "8.10.7.20210828") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ghc-lib-parser" version)) - (sha256 - (base32 - "178v4f7q9ndqmlhg2vhlk6ifm3ilajlrz8iw84vggzs7rp0fnlx0")))) + (version "9.2.5.20221107") + (source (origin + (method url-fetch) + (uri (hackage-uri "ghc-lib-parser" version)) + (sha256 + (base32 + "1xh8rm5lwbh96g4v34whkcbb1yjsyvx3rwwycj30lrglhqk7f4c4")))) (build-system haskell-build-system) (properties '((upstream-name . "ghc-lib-parser"))) (outputs '("out" "static" "doc")) ; documentation is 39M - (native-inputs - (list ghc-alex ghc-happy)) + (native-inputs (list ghc-alex ghc-happy)) (home-page "https://github.com/digital-asset/ghc-lib") (synopsis "The GHC API, decoupled from GHC versions") - (description "This library implements the GHC API. It is like the + (description + "This library implements the GHC API. It is like the compiler-provided @code{ghc} package, but it can be loaded on many compiler versions.") (license license:bsd-3))) @@ -6701,29 +6436,27 @@ (define-public ghc-libyaml (define-public ghc-lifted-async (package (name "ghc-lifted-async") - (version "0.10.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lifted-async" version)) - (sha256 - (base32 - "0j4f5471qfxkxy84ri87bcvp30ikh4m30imcggwn8m5v8igp218d")))) + (version "0.10.2.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "lifted-async" version)) + (sha256 + (base32 + "1kq96cp9czf358gykai2vcmynnd7zivqja4pb3f8bif9ypln9vai")))) (build-system haskell-build-system) (properties '((upstream-name . "lifted-async"))) - (inputs - (list ghc-async - ghc-lifted-base - ghc-transformers-base - ghc-monad-control - ghc-constraints - ghc-hunit - ghc-tasty - ghc-tasty-expected-failure - ghc-tasty-hunit - ghc-tasty-th)) + (inputs (list ghc-async ghc-lifted-base ghc-transformers-base + ghc-monad-control ghc-constraints)) + (native-inputs (list ghc-hunit + ghc-tasty + ghc-tasty-expected-failure + ghc-tasty-hunit + ghc-tasty-th + ghc-tasty-hunit + ghc-tasty-th)) (home-page "https://github.com/maoe/lifted-async") - (synopsis "Run lifted IO operations asynchronously and wait for their results") + (synopsis + "Run lifted IO operations asynchronously and wait for their results") (description "This package provides IO operations from @code{async} package lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.") @@ -6758,40 +6491,35 @@ (define-public ghc-lifted-base (define-public ghc-linear (package (name "ghc-linear") - (version "1.21.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "linear" version)) - (sha256 - (base32 - "0ax6prmc7b53w0lz5ddc40wrjj9bm7wldpp57283gx9hdf8qrb35")))) + (version "1.21.10") + (source (origin + (method url-fetch) + (uri (hackage-uri "linear" version)) + (sha256 + (base32 + "1d3s1p4imkifn7dccqci2qiwcg99x22kf250hzh4fh4xghi361xr")))) (build-system haskell-build-system) (properties '((upstream-name . "linear"))) - (inputs - (list ghc-adjunctions - ghc-base-orphans - ghc-bytes - ghc-cereal - ghc-distributive - ghc-hashable - ghc-lens - ghc-reflection - ghc-semigroups - ghc-semigroupoids - ghc-tagged - ghc-transformers-compat - ghc-unordered-containers - ghc-vector - ghc-void)) - (native-inputs - (list cabal-doctest - ghc-doctest - ghc-simple-reflect - ghc-test-framework - ghc-test-framework-hunit - ghc-hunit)) - (home-page "https://github.com/ekmett/linear/") + (inputs (list ghc-adjunctions + ghc-base-orphans + ghc-bytes + ghc-cereal + ghc-distributive + ghc-hashable + ghc-indexed-traversable + ghc-lens + ghc-random + ghc-reflection + ghc-semigroups + ghc-semigroupoids + ghc-tagged + ghc-transformers-compat + ghc-unordered-containers + ghc-vector + ghc-void)) + (native-inputs (list ghc-simple-reflect ghc-test-framework + ghc-test-framework-hunit ghc-hunit)) + (home-page "http://github.com/ekmett/linear/") (synopsis "Linear algebra library for Haskell") (description "This package provides types and combinators for linear algebra on free @@ -6801,28 +6529,21 @@ (define-public ghc-linear (define-public ghc-listlike (package (name "ghc-listlike") - (version "4.7.6") - (source - (origin - (method url-fetch) - (uri - (hackage-uri "ListLike" version)) - (sha256 - (base32 - "08jip0q2f9qc95wcqka2lrqpf8r7sswsi5104w73kyrbmfirqnrd")))) + (version "4.7.8") + (source (origin + (method url-fetch) + (uri (hackage-uri "ListLike" version)) + (sha256 + (base32 + "1l9pfjy7gh7xqnzflixp37d6lsppmlffzmmq75xn9r8ij3r2jycs")))) (build-system haskell-build-system) (properties '((upstream-name . "ListLike"))) - (inputs - (list ghc-vector - ghc-dlist - ghc-fmlist - ghc-hunit - ghc-quickcheck - ghc-random - ghc-utf8-string)) - (home-page "https://github.com/JohnLato/listlike") + (inputs (list ghc-vector ghc-dlist ghc-fmlist ghc-utf8-string)) + (native-inputs (list ghc-hunit ghc-quickcheck ghc-random)) + (home-page "http://github.com/ddssff/listlike") (synopsis "Generic support for list-like structures") - (description "The ListLike module provides a common interface to the + (description + "The ListLike module provides a common interface to the various Haskell types that are list-like. Predefined interfaces include standard Haskell lists, Arrays, ByteStrings, and lazy ByteStrings. Custom types can easily be made ListLike instances as well. @@ -6832,105 +6553,54 @@ (define-public ghc-listlike can handle infinite lists.") (license license:bsd-3))) -(define-public ghc-llvm-hs-pure - (package - (name "ghc-llvm-hs-pure") - (version "9.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "llvm-hs-pure" version)) - (sha256 - (base32 - "0pxb5ah8r5pzpz2ibqw3g9g1isigb4z7pbzfrwr8kmcjn74ab3kf")))) - (build-system haskell-build-system) - (properties '((upstream-name . "llvm-hs-pure"))) - (inputs - (list ghc-attoparsec ghc-fail ghc-unordered-containers)) - (native-inputs - (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck)) - (home-page "https://github.com/llvm-hs/llvm-hs/") - (synopsis "Pure Haskell LLVM functionality (no FFI)") - (description "llvm-hs-pure is a set of pure Haskell types and functions -for interacting with LLVM. It includes an algebraic datatype (ADT) to represent -LLVM IR. The llvm-hs package builds on this one with FFI bindings to LLVM, but -llvm-hs-pure does not require LLVM to be available.") - (license license:bsd-3))) - -(define-public ghc-llvm-hs - (package - (name "ghc-llvm-hs") - (version "9.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "llvm-hs" version)) - (sha256 - (base32 - "0723xgh45h9cyxmmjsvxnsp8bpn1ljy4qgh7a7vqq3sj9d6wzq00")))) - (build-system haskell-build-system) - (properties '((upstream-name . "llvm-hs"))) - (inputs - (list ghc-attoparsec ghc-exceptions ghc-utf8-string ghc-llvm-hs-pure - llvm-9)) - (native-inputs - (list ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck - ghc-quickcheck - ghc-temporary - ghc-pretty-show - ghc-temporary)) - (home-page "https://github.com/llvm-hs/llvm-hs/") - (synopsis "General purpose LLVM bindings for Haskell") - (description "llvm-hs is a set of Haskell bindings for LLVM. Unlike other -current Haskell bindings, it uses an algebraic datatype (ADT) to represent LLVM -IR, and so offers two advantages: it handles almost all of the stateful -complexities of using the LLVM API to build IR; and it supports moving IR not -only from Haskell into LLVM C++ objects, but the other direction - from LLVM C++ -into Haskell.") - (license license:bsd-3))) - (define-public ghc-logging-facade (package (name "ghc-logging-facade") - (version "0.3.0") + (version "0.3.1") (source (origin (method url-fetch) (uri (hackage-uri "logging-facade" version)) (sha256 (base32 - "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf")))) + "0rn12j77gn3p84khrmbn5kq6fyj44i3z1hrdm29apikp7csv65ib")))) (build-system haskell-build-system) (properties '((upstream-name . "logging-facade"))) - (native-inputs - (list ghc-hspec hspec-discover)) - (home-page "https://hackage.haskell.org/package/logging-facade") + ;(arguments (list #:tests? #f)) + (inputs (list ghc-call-stack)) + (native-inputs (list ghc-hspec hspec-discover)) + (home-page "https://github.com/sol/logging-facade#readme") (synopsis "Simple logging abstraction that allows multiple back-ends") (description "This package provides a simple logging abstraction that allows multiple back-ends.") (license license:expat))) +(define-public ghc-logging-facade-bootstrap + (package + (inherit ghc-logging-facade) + (name "ghc-logging-facade-bootstrap") + (arguments `(#:tests? #f)) + (native-inputs '()) + (properties '((hidden? #t))))) + (define-public ghc-logict (package (name "ghc-logict") - (version "0.7.1.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "logict" version)) - (sha256 - (base32 - "1d22b7r8lnak5k8ars166cxbk1lv7gf8g0qs604irsx2s474ybi7")))) + (version "0.8.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "logict" version)) + (sha256 + (base32 + "0mpv50ifb3x9vfmgi1p9piwcgz8d19x0wdj789wxyhxwjpr6v4py")))) (build-system haskell-build-system) (properties '((upstream-name . "logict"))) (inputs (list ghc-fail)) - (native-inputs - (list ghc-async ghc-tasty ghc-tasty-hunit)) - (home-page "http://code.haskell.org/~dolio/") + (native-inputs (list ghc-async ghc-tasty ghc-tasty-hunit)) + (home-page "https://github.com/Bodigrim/logict#readme") (synopsis "Backtracking logic-programming monad") - (description "This library provides a continuation-based, backtracking, + (description + "This library provides a continuation-based, backtracking, logic programming monad. An adaptation of the two-continuation implementation found in the paper \"Backtracking, Interleaving, and Terminating Monad Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf, @@ -6940,28 +6610,24 @@ (define-public ghc-logict (define-public ghc-lucid (package (name "ghc-lucid") - (version "2.9.12.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lucid" version)) - (sha256 - (base32 - "0nky4pqxd6828kg3js90ks6r3hxs5x48ibfz37pw2dr7y1nygq21")))) + (version "2.11.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "lucid" version)) + (sha256 + (base32 + "13krwrvv0w24rnl7pc7qhv18c6030fkxpx7sxkffdm8sr9173xfw")))) (build-system haskell-build-system) (properties '((upstream-name . "lucid"))) - (inputs - (list ghc-blaze-builder ghc-hashable ghc-mmorph - ghc-unordered-containers)) - (native-inputs - (list ghc-hunit ghc-hspec ghc-bifunctors)) + (inputs (list ghc-blaze-builder ghc-hashable ghc-mmorph)) + (native-inputs (list ghc-hunit ghc-hspec ghc-bifunctors)) (arguments - `(#:cabal-revision - ("1" - "1xllyf26ypk37k807g5v6fl1449mhpvk18dljmqgwj723n0v8rpj"))) + `(#:cabal-revision ("1" + "0wipmh3xcs00x8lbq5j780rdc2klfj67nzni21qc1pdbhr2whn9d"))) (home-page "https://github.com/chrisdone/lucid") (synopsis "Haskell DSL for rendering HTML") - (description "Clear to write, read and edit Haskell DSL for HTML. + (description + "Clear to write, read and edit Haskell DSL for HTML. @itemize @bullet @item @@ -6976,23 +6642,17 @@ (define-public ghc-lucid (define-public ghc-lzma (package (name "ghc-lzma") - (version "0.0.0.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lzma" version)) - (sha256 - (base32 - "0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg")))) + (version "0.0.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "lzma" version)) + (sha256 + (base32 + "0fy11i7fanrsbh8w7cclwx0i6csn5df6vl38dh2112aqw6n7h382")))) (build-system haskell-build-system) (properties '((upstream-name . "lzma"))) - (arguments - '(#:tests? #f ; requires older versions of QuickCheck and tasty. - #:cabal-revision - ("6" "1sh2g5wkh0m6646cxnii0k20f0crwdcnprfl9jfg7gxn5875bkip"))) - (native-inputs - (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit - ghc-tasty-quickcheck)) + (native-inputs (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit + ghc-tasty-quickcheck)) (home-page "https://github.com/hvr/lzma") (synopsis "LZMA/XZ compression and decompression") (description @@ -7004,26 +6664,23 @@ (define-public ghc-lzma (define-public ghc-lzma-conduit (package (name "ghc-lzma-conduit") - (version "1.2.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lzma-conduit" version)) - (sha256 - (base32 - "1z6q16hzp2r5a4gdbg9akky5l9bfarzzhzswrgvh0v28ax400whb")))) + (version "1.2.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "lzma-conduit" version)) + (sha256 + (base32 + "1pmvmchrg429b2yk485x0066lxcr37cbyczlyp3ala2iaq8hm61z")))) (build-system haskell-build-system) (properties '((upstream-name . "lzma-conduit"))) - (inputs - (list ghc-conduit ghc-lzma ghc-resourcet)) - (native-inputs - (list ghc-base-compat - ghc-test-framework - ghc-test-framework-hunit - ghc-test-framework-quickcheck2 - ghc-hunit - ghc-quickcheck)) - (home-page "https://github.com/alphaHeavy/lzma-conduit") + (inputs (list ghc-conduit ghc-lzma ghc-resourcet)) + (native-inputs (list ghc-base-compat + ghc-test-framework + ghc-test-framework-hunit + ghc-test-framework-quickcheck2 + ghc-hunit + ghc-quickcheck)) + (home-page "http://github.com/alphaHeavy/lzma-conduit") (synopsis "Conduit interface for lzma/xz compression") (description "This package provides a @code{Conduit} interface for the LZMA @@ -7054,16 +6711,18 @@ (define-public ghc-magic (define-public ghc-managed (package (name "ghc-managed") - (version "1.0.8") - (source - (origin - (method url-fetch) - (uri (hackage-uri "managed" version)) - (sha256 - (base32 - "00wzfy9facwgimrilz7bxaigr79w10733h8zfgyhll644p2rnz38")))) + (version "1.0.9") + (source (origin + (method url-fetch) + (uri (hackage-uri "managed" version)) + (sha256 + (base32 + "0vx8aim8bcyyvxxnmi1xkbl3kwrvskjn99z3y8h458g7nsinsisd")))) (build-system haskell-build-system) (properties '((upstream-name . "managed"))) + (arguments + `(#:cabal-revision ("3" + "017h9533j7rlxlsf65ynxpva59yr0qwrdmvhp7if141i98ld4664"))) (home-page "https://hackage.haskell.org/package/managed") (synopsis "Monad for managed values") (description @@ -7144,20 +6803,16 @@ (define-public ghc-math-functions (define-public ghc-megaparsec (package (name "ghc-megaparsec") - (version "9.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "megaparsec" version)) - (sha256 - (base32 - "00953zvxfyjibw8c1ssmixxh0cwn59pz24zbh6s34rk3v14vqa3j")))) + (version "9.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "megaparsec" version)) + (sha256 + (base32 + "0d52dbcz9nlqkkfqfs9kck5kmvkfzf3628z4ik4gr7hbbkjh72x4")))) (build-system haskell-build-system) (properties '((upstream-name . "megaparsec"))) - (inputs - (list ghc-case-insensitive ghc-parser-combinators ghc-scientific)) - (native-inputs - (list ghc-quickcheck ghc-hspec ghc-hspec-expectations hspec-discover)) + (inputs (list ghc-case-insensitive ghc-parser-combinators ghc-scientific)) (home-page "https://github.com/mrkkrp/megaparsec") (synopsis "Monadic parser combinators") (description @@ -7169,19 +6824,20 @@ (define-public ghc-megaparsec (define-public ghc-memory (package (name "ghc-memory") - (version "0.15.0") + (version "0.17.0") (source (origin (method url-fetch) (uri (hackage-uri "memory" version)) (sha256 (base32 - "0a9mxcddnqn4359hk59d6l2zbh0vp154yb5vs1a8jw4l38n8kzz3")))) + "0yl3ivvn7i9wbx910b7bzj9c3g0jjjk91j05wj74qb5zx2yyf9rk")))) (build-system haskell-build-system) (properties '((upstream-name . "memory"))) - (inputs - (list ghc-basement ghc-foundation)) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit)) + (inputs (list ghc-basement)) + (native-inputs (list ghc-foundation)) + (arguments + `(#:cabal-revision ("1" + "1gybf726kz17jm1am0rphi0srmyqyza45y6jdqbq0b8sspm8kggb"))) (home-page "https://github.com/vincenthz/hs-memory") (synopsis "Memory abstractions for Haskell") (description @@ -7240,14 +6896,14 @@ (define-public ghc-microlens (define-public ghc-microlens-aeson (package (name "ghc-microlens-aeson") - (version "2.3.1") + (version "2.5.0") (source (origin (method url-fetch) (uri (hackage-uri "microlens-aeson" version)) (sha256 (base32 - "074mzpk7av6i0xf7xy42jpzgljlmyw805md1vz4sqy85m99f0ikr")))) + "0h5q0b2b4y28llhq28mb28kpdv2iifz0qkbbhmrwrz2bs6arr3d2")))) (build-system haskell-build-system) (properties '((upstream-name . "microlens-aeson"))) (inputs @@ -7269,20 +6925,20 @@ (define-public ghc-microlens-aeson (define-public ghc-microlens-ghc (package (name "ghc-microlens-ghc") - (version "0.4.13") - (source - (origin - (method url-fetch) - (uri (hackage-uri "microlens-ghc" version)) - (sha256 - (base32 - "1r6x788br3f9rksj0dmk1nyh5mfvd9zzasclf1mi3rxhb7c0j926")))) + (version "0.4.13.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "microlens-ghc" version)) + (sha256 + (base32 + "1258p84jj4kv6l71ijwjzpvzvqxxsqbvs5vrksi24mlf29gaxqi0")))) (build-system haskell-build-system) (properties '((upstream-name . "microlens-ghc"))) (inputs (list ghc-microlens)) - (home-page "https://github.com/monadfix/microlens") + (home-page "http://github.com/monadfix/microlens") (synopsis "Use @code{microlens} with GHC libraries like @code{array}") - (description "This library provides everything that @code{microlens} + (description + "This library provides everything that @code{microlens} provides plus instances to make @code{each}, @code{at}, and @code{ix} usable with arrays, @code{ByteString}, and containers. This package is a part of the @uref{http://hackage.haskell.org/package/microlens, @@ -7293,21 +6949,18 @@ (define-public ghc-microlens-ghc (define-public ghc-microlens-mtl (package (name "ghc-microlens-mtl") - (version "0.2.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "microlens-mtl" version)) - (sha256 - (base32 - "0ijy7xyd5lbc3calhcrhy8czkf3fjcxrv68p7kd2a5b352rfi7fp")))) + (version "0.2.0.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "microlens-mtl" version)) + (sha256 + (base32 + "1ilz0zyyk9f6h97gjsaqq65njfs23fk3wxhigvj4z0brf7rnlssd")))) (build-system haskell-build-system) (properties '((upstream-name . "microlens-mtl"))) - (inputs - (list ghc-microlens ghc-transformers-compat)) - (home-page "https://github.com/monadfix/microlens") - (synopsis - "@code{microlens} support for Reader/Writer/State from mtl") + (inputs (list ghc-microlens ghc-transformers-compat)) + (home-page "http://github.com/monadfix/microlens") + (synopsis "@code{microlens} support for Reader/Writer/State from mtl") (description "This package contains functions (like @code{view} or @code{+=}) which work on @code{MonadReader}, @code{MonadWriter}, and @code{MonadState} from the @@ -7319,25 +6972,23 @@ (define-public ghc-microlens-mtl (define-public ghc-microlens-platform (package (name "ghc-microlens-platform") - (version "0.4.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "microlens-platform" version)) - (sha256 - (base32 - "0yf0z0glq2d6mpclzswc64h9w2cck4fd8l8ffm89pyb0a5n8m4c7")))) + (version "0.4.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "microlens-platform" version)) + (sha256 + (base32 + "0z8snyzy18kqj32fb89mzgscjrg6w2z0jkkj4b9vl2jvbps0gkg6")))) (build-system haskell-build-system) (properties '((upstream-name . "microlens-platform"))) - (inputs - (list ghc-hashable - ghc-microlens - ghc-microlens-ghc - ghc-microlens-mtl - ghc-microlens-th - ghc-unordered-containers - ghc-vector)) - (home-page "https://github.com/monadfix/microlens") + (inputs (list ghc-hashable + ghc-microlens + ghc-microlens-ghc + ghc-microlens-mtl + ghc-microlens-th + ghc-unordered-containers + ghc-vector)) + (home-page "http://github.com/monadfix/microlens") (synopsis "Feature-complete microlens") (description "This package exports a module which is the recommended starting point @@ -7361,23 +7012,22 @@ (define-public ghc-microlens-platform (define-public ghc-microlens-th (package (name "ghc-microlens-th") - (version "0.4.3.10") - (source - (origin - (method url-fetch) - (uri (hackage-uri "microlens-th" version)) - (sha256 - (base32 - "1dg2xhj85fy8q39m5dd94kjlabjyxgc0336vzkg0174l6l110l1c")))) + (version "0.4.3.11") + (source (origin + (method url-fetch) + (uri (hackage-uri "microlens-th" version)) + (sha256 + (base32 + "1vjjaclfxr0kvlpmj8zh7f6ci4n4b8vynqd67zszx42al7gal6pj")))) (build-system haskell-build-system) (properties '((upstream-name . "microlens-th"))) (inputs (list ghc-microlens ghc-th-abstraction)) (native-inputs (list ghc-tagged)) - (home-page - "https://github.com/aelve/microlens") + (home-page "http://github.com/monadfix/microlens") (synopsis "Automatic generation of record lenses for @code{ghc-microlens}") - (description "This Haskell package lets you automatically generate lenses + (description + "This Haskell package lets you automatically generate lenses for data types; code was extracted from the lens package, and therefore generated lenses are fully compatible with ones generated by lens (and can be used both from lens and microlens).") @@ -7386,36 +7036,26 @@ (define-public ghc-microlens-th (define-public ghc-missingh (package (name "ghc-missingh") - (version "1.4.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "MissingH" version)) - (sha256 - (base32 - "196cniya5wzcv2d777nr0f7hinclpals4ia1mkzzv35870pqr6lw")))) + (version "1.5.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "MissingH" version)) + (sha256 + (base32 + "0c92fdv32nq51kfdizi3lpxmnvscsgk6marfzaycd7k05aka8byb")))) (build-system haskell-build-system) (properties '((upstream-name . "MissingH"))) + (inputs (list ghc-hslogger + ghc-old-locale + ghc-old-time + ghc-regex-compat + ghc-network-bsd + ghc-network)) + (native-inputs (list ghc-hunit)) (arguments - `(#:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "MissingH.cabal" - (("(random)\\s+[^,]+" all dep) - dep))))))) - (inputs - (list ghc-network - ghc-hunit - ghc-regex-compat - ghc-hslogger - ghc-random - ghc-old-time - ghc-old-locale)) - (native-inputs - (list ghc-errorcall-eq-instance ghc-quickcheck ghc-hunit)) - ;; ‘Official’ redirects to a 404. - (home-page "https://github.com/haskell-hvr/missingh") + `(#:cabal-revision ("2" + "11d922r06p00gcgzhb29hhjkq8ajy1xbqdiwdpbmhp2ar7fw7g9l"))) + (home-page "http://hackage.haskell.org/package/MissingH") (synopsis "Large utility library") (description "MissingH is a library of all sorts of utility functions for Haskell @@ -7447,19 +7087,20 @@ (define-public ghc-mmap (define-public ghc-mmorph (package (name "ghc-mmorph") - (version "1.1.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "mmorph" version)) - (sha256 - (base32 - "0bq9m3hlfax1826gg5yhih79x33rvfx59wdh8yf43azd7l74bys6")))) + (version "1.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "mmorph" version)) + (sha256 + (base32 + "1022d8mm523dihkf85mqsqxpm9rnyicmv91c8rm4csv7xdc80cv1")))) (build-system haskell-build-system) (properties '((upstream-name . "mmorph"))) - (inputs - (list ghc-transformers-compat)) - (home-page "https://hackage.haskell.org/package/mmorph") + (inputs (list ghc-transformers-compat ghc-fail)) + (arguments + `(#:cabal-revision ("3" + "1582vcpjiyimb1vwnhgq8gp805iziwa8sivv2frir0cgq4z236yz"))) + (home-page "http://hackage.haskell.org/package/mmorph") (synopsis "Monad morphisms") (description "This library provides monad morphism utilities, most commonly used for @@ -7488,6 +7129,16 @@ (define-public ghc-mockery "The mockery package provides support functions for automated testing.") (license license:expat))) +(define-public ghc-mockery-bootstrap + (package + (inherit ghc-mockery) + (name "ghc-mockery-bootstrap") + (arguments `(#:tests? #f)) + (inputs (modify-inputs (package-inputs ghc-mockery) + (replace "ghc-logging-facade" ghc-logging-facade-bootstrap))) + (native-inputs '()) + (properties '((hidden? #t))))) + (define-public ghc-monad-control (package (name "ghc-monad-control") @@ -7514,31 +7165,33 @@ (define-public ghc-monad-control (define-public ghc-monad-logger (package (name "ghc-monad-logger") - (version "0.3.36") - (source - (origin - (method url-fetch) - (uri (hackage-uri "monad-logger" version)) - (sha256 - (base32 - "12rw0k01gkhiqjm2fhxgkmribksmizhj14xphfn8fkd86wzl0vbh")))) + (version "0.3.37") + (source (origin + (method url-fetch) + (uri (hackage-uri "monad-logger" version)) + (sha256 + (base32 + "1z275a428zcj73zz0cpfha2adwiwqqqp7klx3kbd3i9rl20xa106")))) (build-system haskell-build-system) (properties '((upstream-name . "monad-logger"))) - (inputs (list ghc-transformers-compat - ghc-stm-chans - ghc-lifted-base - ghc-resourcet - ghc-conduit + (inputs (list ghc-conduit ghc-conduit-extra ghc-fast-logger - ghc-transformers-base + ghc-lifted-base ghc-monad-control ghc-monad-loops - ghc-blaze-builder - ghc-exceptions)) - (home-page "https://github.com/kazu-yamamoto/logger") + ghc-resourcet + ghc-stm-chans + ghc-transformers-base + ghc-transformers-compat + ghc-unliftio-core)) + (arguments + `(#:cabal-revision ("3" + "1dzkw08b4ijacdw0vcfxlr13rd819x2yj7b6sr9jrrwicd45zm1z"))) + (home-page "https://github.com/snoyberg/monad-logger#readme") (synopsis "Provides a class of monads which can log messages for Haskell") - (description "This Haskell package uses a monad transformer approach + (description + "This Haskell package uses a monad transformer approach for logging. This package provides Template Haskell functions for determining source @@ -7635,6 +7288,9 @@ (define-public ghc-monadrandom (properties '((upstream-name . "MonadRandom"))) (inputs (list ghc-transformers-compat ghc-primitive ghc-fail ghc-random)) + (arguments + `(#:cabal-revision ("2" + "1diy29if7w1c9ckc465mrrb52fm0zmd8zzym1h5ryh5a58qafwhr"))) (home-page "https://github.com/byorgey/MonadRandom") (synopsis "Random-number generation monad for Haskell") (description "This Haskell package provides support for computations @@ -7693,21 +7349,20 @@ (define-public ghc-mono-traversable (define-public ghc-monoid-extras (package (name "ghc-monoid-extras") - (version "0.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "monoid-extras" version)) - (sha256 - (base32 - "0ki1d3b1xpf653qj7brlqdgngghwrnmapy5gja75iiydfx2506a1")))) + (version "0.6.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "monoid-extras" version)) + (sha256 + (base32 + "1qaxp0cf2cvzvfpk7x9mjz1zmlpjfzxij8v2n45w89s7bq9ckvlw")))) (build-system haskell-build-system) (properties '((upstream-name . "monoid-extras"))) - (inputs - (list ghc-groups ghc-semigroupoids)) - (home-page "https://hackage.haskell.org/package/monoid-extras") + (inputs (list ghc-groups ghc-semigroupoids)) + (home-page "http://hackage.haskell.org/package/monoid-extras") (synopsis "Various extra monoid-related definitions and utilities") - (description "This package provides various extra monoid-related + (description + "This package provides various extra monoid-related definitions and utilities, such as monoid actions, monoid coproducts, semi-direct products, \"deletable\" monoids, \"split\" monoids, and \"cut\" monoids.") @@ -7769,16 +7424,16 @@ (define-public ghc-mtl-compat (define-public ghc-murmur-hash (package (name "ghc-murmur-hash") - (version "0.1.0.9") - (source - (origin - (method url-fetch) - (uri (hackage-uri "murmur-hash" version)) - (sha256 - (base32 "1bb58kfnzvx3mpc0rc0dhqc1fk36nm8prd6gvf20gk6lxaadpfc9")))) + (version "0.1.0.10") + (source (origin + (method url-fetch) + (uri (hackage-uri "murmur-hash" version)) + (sha256 + (base32 + "145z91zkx8jdd3y181pi8z9imqjgpk99cl55pbda4fl201hasbz9")))) (build-system haskell-build-system) (properties '((upstream-name . "murmur-hash"))) - (home-page "https://github.com/nominolo/murmur-hash") + (home-page "http://github.com/nominolo/murmur-hash") (synopsis "MurmurHash2 implementation for Haskell") (description "This package provides an implementation of MurmurHash2, a good, fast, @@ -7890,26 +7545,20 @@ (define-public ghc-ncurses (define-public ghc-network (package (name "ghc-network") - (version "3.1.1.1") - (outputs '("out" "static" "doc")) - (source - (origin - (method url-fetch) - (uri (hackage-uri "network" version)) - (sha256 - (base32 - "16ic2hgvadyiy0zfnyd2zknf8rxqmwzpy5mw5x9apwpzfc0mkvyp")))) + (version "3.1.2.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "network" version)) + (sha256 + (base32 + "119xqsyj44ix0z79mzfpww0cd9936bki1xa7cwykvbx1y7z20xkz")))) (build-system haskell-build-system) (properties '((upstream-name . "network"))) - ;; The regression tests depend on an unpublished module. - (arguments `(#:tests? #f)) - (native-inputs - (list ghc-hunit ghc-doctest ghc-test-framework - ghc-test-framework-hunit)) + (native-inputs (list ghc-hunit ghc-temporary ghc-hspec ghc-quickcheck + ghc-doctest hspec-discover)) (home-page "https://github.com/haskell/network") (synopsis "Low-level networking interface") - (description - "This package provides a low-level networking interface.") + (description "This package provides a low-level networking interface.") (license license:bsd-3))) (define-public ghc-network-bsd @@ -7960,19 +7609,19 @@ (define-public ghc-network-byte-order (define-public ghc-network-info (package (name "ghc-network-info") - (version "0.2.0.10") - (source - (origin - (method url-fetch) - (uri (hackage-uri "network-info" version)) - (sha256 - (base32 - "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n")))) + (version "0.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "network-info" version)) + (sha256 + (base32 + "015lm3b8n8sb16qsffjxz1jvijyy0z600ch0sm8h6a685wqqhbcv")))) (build-system haskell-build-system) (properties '((upstream-name . "network-info"))) - (home-page "https://github.com/jystic/network-info") + (home-page "http://github.com/jacobstanley/network-info") (synopsis "Access the local computer's basic network configuration") - (description "This Haskell library provides simple read-only access to the + (description + "This Haskell library provides simple read-only access to the local computer's networking configuration. It is currently capable of getting a list of all the network interfaces and their respective IPv4, IPv6 and MAC addresses.") @@ -8008,26 +7657,22 @@ (define-public ghc-network-multicast (define-public ghc-network-uri (package (name "ghc-network-uri") - (version "2.6.4.1") - (outputs '("out" "static" "doc")) - (source - (origin - (method url-fetch) - (uri (hackage-uri "network-uri" version)) - (sha256 - (base32 - "111m485rx2kyqdymi1x6sl08hi6lp34q3f41yqcx99086swnv1ap")))) + (version "2.6.4.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "network-uri" version)) + (sha256 + (base32 + "0a3jg6aykwm1yw32nh137hi6r86w2640xwl1p18352bf29rqj64w")))) (build-system haskell-build-system) (properties '((upstream-name . "network-uri"))) - (inputs - (list ghc-th-compat)) - (native-inputs - (list ghc-hunit ghc-quickcheck ghc-tasty ghc-tasty-hunit - ghc-tasty-quickcheck)) - (home-page - "https://github.com/haskell/network-uri") + (inputs (list ghc-th-compat)) + (native-inputs (list ghc-hunit ghc-tasty ghc-tasty-hunit + ghc-tasty-quickcheck ghc-quickcheck)) + (home-page "https://github.com/haskell/network-uri") (synopsis "Library for URI manipulation") - (description "This package provides an URI manipulation interface. In + (description + "This package provides an URI manipulation interface. In @code{network-2.6} the @code{Network.URI} module was split off from the @code{network} package into this package.") (license license:bsd-3))) @@ -8035,21 +7680,23 @@ (define-public ghc-network-uri (define-public ghc-newtype-generics (package (name "ghc-newtype-generics") - (version "0.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "newtype-generics" version)) - (sha256 - (base32 - "04bymwhkvlsgcsd0v630mndrzf0xnh3v81ba6nfzwcvbg3ksr2wa")))) + (version "0.6.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "newtype-generics" version)) + (sha256 + (base32 + "0km7cp041bgdgrxrbrawz611mcylxp943880a2yg228a09961b51")))) (build-system haskell-build-system) (properties '((upstream-name . "newtype-generics"))) - (native-inputs - (list ghc-hspec hspec-discover)) - (home-page "https://github.com/sjakobi/newtype-generics") + (native-inputs (list ghc-hspec hspec-discover)) + (arguments + `(#:cabal-revision ("1" + "0xgc7sxs1p3qibgwbikjdrhn47j7m4gk5x1wrv9hncks6hd6hsyf"))) + (home-page "http://github.com/sjakobi/newtype-generics") (synopsis "Typeclass and set of functions for working with newtypes") - (description "The @code{Newtype} typeclass represents the packing and + (description + "The @code{Newtype} typeclass represents the packing and unpacking of a newtype, and allows you to operate under that newtype with functions such as @code{ala}. Generics support was added in version 0.4, making this package a full replacement for the original newtype package, @@ -8132,19 +7779,19 @@ (define-public ghc-numeric-extras (define-public ghc-objectname (package (name "ghc-objectname") - (version "1.1.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ObjectName" version)) - (sha256 - (base32 - "046jm94rmm46cicd31pl54vdvfjvhd9ffbfycy2lxzc0fliyznvj")))) + (version "1.1.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "ObjectName" version)) + (sha256 + (base32 + "0xdkfc97salzj5s3fvmwk4k0097dcd8c4xcr5ghhv9mz0wcxm9gz")))) (build-system haskell-build-system) (properties '((upstream-name . "ObjectName"))) - (home-page "https://hackage.haskell.org/package/ObjectName") + (home-page "https://github.com/svenpanne/ObjectName") (synopsis "Helper library for Haskell OpenGL") - (description "This tiny package contains the class ObjectName, which + (description + "This tiny package contains the class ObjectName, which corresponds to the general notion of explicitly handled identifiers for API objects, e.g. a texture object name in OpenGL or a buffer object name in OpenAL.") @@ -8241,8 +7888,8 @@ (define-public ghc-opengl (build-system haskell-build-system) (properties '((upstream-name . "OpenGL"))) (arguments - `(#:cabal-revision - ("1" "1748mrb6r9mpf5jbrx436lwbg8w6dadyy8dhxw2dwnrj5z7zf741"))) + `(#:cabal-revision ("2" + "1nhlswxgxn8l1ysjq3fp3w5pvx6651d33036i8dlbqygzrn6iwmh"))) (inputs (list ghc-objectname ghc-gluraw ghc-statevar ghc-openglraw)) (home-page "https://wiki.haskell.org/Opengl") @@ -8255,23 +7902,24 @@ (define-public ghc-opengl (define-public ghc-openglraw (package (name "ghc-openglraw") - (version "3.3.4.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "OpenGLRaw" version)) - (sha256 - (base32 - "0gmsmysqzpm13qnyq4vvqxm4dzw25nayfd9wi5x645pympm6jqbm")))) + (version "3.3.4.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "OpenGLRaw" version)) + (sha256 + (base32 + "07nk0rgm6jcxz6yshwhv5lj5frs6371w3hdjxwa4biws2kmbs6hj")))) (build-system haskell-build-system) (properties '((upstream-name . "OpenGLRaw"))) + (inputs (list ghc-fixed ghc-half glu)) (arguments - `(#:extra-directories ("glu"))) - (inputs - (list ghc-half ghc-fixed glu)) - (home-page "https://wiki.haskell.org/Opengl") + `(#:extra-directories ("glu") + #:cabal-revision ("1" + "15abvqkxc08lx9d44323izccfp7bqfiljnd587zn80vdvmkzs6zc"))) + (home-page "http://www.haskell.org/haskellwiki/Opengl") (synopsis "Raw Haskell bindings for the OpenGL graphics system") - (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5 + (description + "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw offers access to all necessary functions, tokens and types plus a general @@ -8285,20 +7933,19 @@ (define-public ghc-openglraw (define-public ghc-operational (package (name "ghc-operational") - (version "0.2.4.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "operational" version)) - (sha256 - (base32 - "1hwmwbsxzwv68b39rv4gn3da6irv8zm89gqrkc3rdsgwi5ziyn3i")))) + (version "0.2.4.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "operational" version)) + (sha256 + (base32 + "0aa1pxymvkhbs0x03ikfiap2skzyf2z7307kz5adkmb3qmykcqa2")))) (build-system haskell-build-system) (properties '((upstream-name . "operational"))) - (inputs - (list ghc-random)) + (inputs (list ghc-random)) (home-page "http://wiki.haskell.org/Operational") - (synopsis "Implementation of difficult monads made easy with operational semantics") + (synopsis + "Implementation of difficult monads made easy with operational semantics") (description "This library makes it easy to implement monads with tricky control flow. This is useful for: writing web applications in a sequential style, @@ -8388,23 +8035,17 @@ (define ghc-options-bootstrap (define-public ghc-optparse-applicative (package (name "ghc-optparse-applicative") - (version "0.16.1.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "optparse-applicative" version)) - (sha256 - (base32 - "16nnrkmgd28h540f17nb017ziq4gbzgkxpdraqicaczkca1jf1b2")))) + (version "0.17.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "optparse-applicative" version)) + (sha256 + (base32 + "097p1bkvw9r3rvcr65w53yw14drb0s46ldkkl1jbmq5g7m6jwnw2")))) (build-system haskell-build-system) (properties '((upstream-name . "optparse-applicative"))) - (arguments - `(#:cabal-revision - ("1" "0401ik87gm9gjpch6lmkczygp59na3f1j7bcs6mc2r929c2xgsqn"))) - (inputs - (list ghc-transformers-compat ghc-ansi-wl-pprint)) - (native-inputs - (list ghc-quickcheck)) + (inputs (list ghc-transformers-compat ghc-ansi-wl-pprint)) + (native-inputs (list ghc-quickcheck)) (home-page "https://github.com/pcapriotti/optparse-applicative") (synopsis "Utilities and combinators for parsing command line options") (description "This package provides utilities and combinators for parsing @@ -8488,20 +8129,18 @@ (define-public ghc-emojis (define-public ghc-text-conversions (package (name "ghc-text-conversions") - (version "0.3.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "text-conversions" version)) - (sha256 - (base32 "0kbxin1q8xj9sgdl185gncrdjwcfzndp8sl5qll8y93l60yq8dxi")))) + (version "0.3.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "text-conversions" version)) + (sha256 + (base32 + "0pbjlzsjd3m8np5p6iq7zb0bx6n40d8jha76r8s07s4wg2x0yxy8")))) (build-system haskell-build-system) (properties '((upstream-name . "text-conversions"))) - (inputs - (list ghc-base16-bytestring ghc-base64-bytestring ghc-errors)) - (native-inputs - (list ghc-hspec hspec-discover)) - (home-page "https://github.com/cjdev/text-conversions#readme") + (inputs (list ghc-base16-bytestring ghc-base64-bytestring)) + (native-inputs (list ghc-hspec hspec-discover)) + (home-page "https://github.com/cjdev/text-conversions") (synopsis "Safe conversions between textual types") (description "Safe conversions between textual types") (license license:isc))) @@ -8509,27 +8148,24 @@ (define-public ghc-text-conversions (define-public ghc-text-short (package (name "ghc-text-short") - (version "0.1.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "text-short" version)) - (sha256 - (base32 - "0xyrxlb602z8bc9sr2y1fag0x56a20yj5qrkvy7iwc6hnznrynxz")))) + (version "0.1.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "text-short" version)) + (sha256 + (base32 + "1nid00c1rg5c1z7l9mwk3f2izc2sps2mip2hl30q985dwb6wcpm3")))) (build-system haskell-build-system) (properties '((upstream-name . "text-short"))) (inputs (list ghc-hashable)) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit - ghc-quickcheck-instances)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck)) (arguments - `(#:tests? #f ; TODO: Needs tasty<1.3 - #:cabal-revision - ("3" "1wjy98ihhipzr34b310sgjjq3cc12aydhckbrgr21kxkzwglm4nv"))) - (home-page "https://hackage.haskell.org/package/text-short") + `(#:cabal-revision ("1" + "0gmmwwchy9312kz8kr5jhiamqrnjqxdqg1wkrww4289yfj1p7dzb"))) + (home-page "http://hackage.haskell.org/package/text-short") (synopsis "Memory-efficient representation of Unicode text strings") - (description "This package provides the @code{ShortText} type which + (description + "This package provides the @code{ShortText} type which is suitable for keeping many short strings in memory. This is similar to how @code{ShortByteString} relates to @code{ByteString}. @@ -8543,19 +8179,17 @@ (define-public ghc-text-short (define-public ghc-text-zipper (package (name "ghc-text-zipper") - (version "0.11") - (source - (origin - (method url-fetch) - (uri (hackage-uri "text-zipper" version)) - (sha256 - (base32 "07l1pyx93gv95cn1wh1di129axhm9sqsn4znykliacv60ld854ys")))) + (version "0.12") + (source (origin + (method url-fetch) + (uri (hackage-uri "text-zipper" version)) + (sha256 + (base32 + "00k7d6qfznhp6l2ihw3pppkn580pwd7ac7wx9vidil4y9hjagaw6")))) (build-system haskell-build-system) (properties '((upstream-name . "text-zipper"))) - (native-inputs - (list ghc-hspec ghc-quickcheck hspec-discover)) - (inputs - (list ghc-vector)) + (inputs (list ghc-vector)) + (native-inputs (list ghc-hspec ghc-quickcheck hspec-discover)) (home-page "https://github.com/jtdaugherty/text-zipper/") (synopsis "Text editor zipper library") (description @@ -8571,20 +8205,21 @@ (define-public ghc-text-zipper (define-public ghc-doclayout (package (name "ghc-doclayout") - (version "0.3.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "doclayout" version)) - (sha256 - (base32 "1p9kgjlf7y4p1symvkwndgs4lvyw2c45bsgld09y9r4aiqbhdrxp")))) + (version "0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "doclayout" version)) + (sha256 + (base32 + "18xkzywfw0hl3hgbq9z36hs040vb0iz9yygx33cybxfi4i0dwbkx")))) (build-system haskell-build-system) (properties '((upstream-name . "doclayout"))) - (inputs - (list ghc-safe ghc-emojis)) - (native-inputs - (list ghc-tasty ghc-tasty-golden ghc-tasty-hunit - ghc-tasty-quickcheck)) + (inputs (list ghc-emojis ghc-safe)) + (native-inputs (list ghc-tasty ghc-tasty-golden ghc-tasty-hunit + ghc-tasty-quickcheck)) + (arguments + `(#:cabal-revision ("1" + "0djwb7nrdablc0iy1qakrxpd4m7nn0w94vhb78il3jhjbj2ji179"))) (home-page "https://github.com/jgm/doclayout") (synopsis "Pretty-printing library for laying out text documents") (description @@ -8593,93 +8228,93 @@ (define-public ghc-doclayout code. It was designed for use in @code{Pandoc}.") (license license:bsd-3))) -(define-public ghc-pandoc +(define-public pandoc (package - (name "ghc-pandoc") - (version "2.14.0.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "pandoc" version)) - (sha256 - (base32 - "1pgd6125mrvzj2faxbsfmackb7kchzcr6bjkrwqbyn9hzxdzbqw2")))) + (name "pandoc") + (version "2.19.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "pandoc" version)) + (sha256 + (base32 + "0ia2gpl345lwymk38y89sgcqjci7sjmxbi228idg6nkaqfa3ds1n")) + (modules '((guix build utils))) + (snippet + '(begin + ;; Fix test case. + (substitute* "test/writer.ms" + (("\\\\\\[u2212\\]") "-")))))) (build-system haskell-build-system) (properties '((upstream-name . "pandoc"))) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'find-library - (lambda _ - (substitute* "test/Tests/Command.hs" - (("= dynlibEnv") - (format #f "= [(\"LD_LIBRARY_PATH\" , \"~a/dist/build\")]" - (getcwd)))) - #t))))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-aeson - ghc-aeson-pretty - ghc-attoparsec - ghc-base64-bytestring - ghc-base-compat - ghc-blaze-html - ghc-blaze-markup - ghc-case-insensitive - ghc-citeproc - ghc-commonmark-extensions - ghc-commonmark - ghc-commonmark-pandoc - ghc-connection - ghc-data-default - ghc-doclayout - ghc-doctemplates - ghc-emojis - ghc-file-embed - ghc-glob - ghc-haddock-library - ghc-hslua - ghc-hslua-module-path - ghc-hslua-module-system - ghc-hslua-module-text - ghc-hsyaml - ghc-http-client - ghc-http-client-tls - ghc-http - ghc-http-types - ghc-ipynb - ghc-jira-wiki-markup - ghc-juicypixels - ghc-network - ghc-network-uri - ghc-pandoc-types - ghc-random - ghc-safe - ghc-scientific - ghc-sha - ghc-skylighting-core - ghc-skylighting - ghc-split - ghc-syb - ghc-tagsoup - ghc-temporary - ghc-texmath - ghc-text-conversions - ghc-unicode-collation - ghc-unicode-transforms - ghc-unordered-containers - ghc-xml-conduit - ghc-xml - ghc-zip-archive - ghc-zlib)) - (native-inputs - (list ghc-tasty - ghc-tasty-golden - ghc-tasty-hunit - ghc-tasty-lua - ghc-tasty-quickcheck - ghc-diff - ghc-quickcheck)) + (inputs (list ghc-glob + ghc-juicypixels + ghc-sha + ghc-aeson + ghc-aeson-pretty + ghc-attoparsec + ghc-blaze-html + ghc-blaze-markup + ghc-case-insensitive + ghc-citeproc + ghc-commonmark + ghc-commonmark-extensions + ghc-commonmark-pandoc + ghc-connection + ghc-data-default + ghc-doclayout + ghc-doctemplates + ghc-base64 + ghc-emojis + ghc-file-embed + ghc-gridtables + ghc-haddock-library + ghc-hslua-module-doclayout + ghc-hslua-module-path + ghc-hslua-module-system + ghc-hslua-module-text + ghc-hslua-module-version + ghc-http-client + ghc-http-client-tls + ghc-http-types + ghc-ipynb + ghc-jira-wiki-markup + ghc-lpeg + ghc-network + ghc-network-uri + ghc-pandoc-lua-marshal + ghc-pandoc-types + ghc-pretty-show + ghc-random + ghc-safe + ghc-scientific + ghc-skylighting + ghc-skylighting-core + ghc-split + ghc-syb + ghc-tagsoup + ghc-temporary + ghc-texmath + ghc-text-conversions + ghc-unicode-collation + ghc-unicode-transforms + ghc-xml + ghc-xml-conduit + ghc-xml-types + ghc-yaml + ghc-zip-archive + ghc-zlib + ghc-servant-server + ghc-wai + ghc-hslua + ghc-hslua-aeson + ghc-wai-extra + ghc-warp)) + (native-inputs (list ghc-diff + ghc-tasty + ghc-tasty-golden + ghc-tasty-hunit + ghc-tasty-lua + ghc-tasty-quickcheck)) (home-page "https://pandoc.org") (synopsis "Conversion between markup formats") (description @@ -8693,167 +8328,26 @@ (define-public ghc-pandoc provided for those who need a drop-in replacement for Markdown.pl.") (license license:gpl2+))) -(define-public pandoc - (package - (inherit ghc-pandoc) - (name "pandoc") - (arguments - `(#:configure-flags - (list "-fstatic" - ;; Do not build trypandoc; this is the default but it's better to - ;; be explicit. - "-f-trypandoc" - ;; TODO: Without these we cannot link the Haskell libraries - ;; statically. It would be nice if we could also build the - ;; shared libraries. - "--disable-shared" - "--disable-executable-dynamic" - ;; That's where we place all static libraries - "--extra-lib-dirs=static-libs/" - "--ghc-option=-static") - #:modules ((guix build haskell-build-system) - (guix build utils) - (ice-9 match) - (srfi srfi-1)) - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'create-simple-paths-module - (lambda* (#:key outputs #:allow-other-keys) - (call-with-output-file "Paths_pandoc.hs" - (lambda (port) - (format port "\ -{-# LANGUAGE CPP #-} -{-# LANGUAGE NoRebindableSyntax #-} -{-# OPTIONS_GHC -fno-warn-missing-import-lists #-} -module Paths_pandoc (version,getDataDir,getDataFileName) where -import Prelude -import Data.Version (Version(..)) -import System.Info -version :: Version -version = Version [~a] [] - -datadir :: FilePath -datadir = \"~a/share/\" ++ - arch ++ \"-\" ++ - os ++ \"-\" ++ - compilerName ++ \"-~a/pandoc-~a\" - -getDataDir :: IO FilePath -getDataDir = return datadir - -getDataFileName :: FilePath -> IO FilePath -getDataFileName name = do - dir <- getDataDir - return (dir ++ \"/\" ++ name) -" - (string-map (lambda (chr) (if (eq? chr #\.) #\, chr)) - ,(package-version ghc-pandoc)) - (assoc-ref outputs "out") - ,(package-version ghc) - ,(package-version ghc-pandoc)))) - #t)) - (add-after 'unpack 'prepare-static-libraries - (lambda* (#:key inputs #:allow-other-keys) - (mkdir-p (string-append (getcwd) "/static-libs")) - (for-each - (lambda (input) - (when (or (string-prefix? "static-" (car input)) - (string-prefix? "ghc" (car input))) - (match (find-files (cdr input) "\\.a$") - ((and (first . rest) libs) - (for-each (lambda (lib) - (let ((target (string-append (getcwd) "/static-libs/" - (basename lib)))) - (unless (file-exists? target) - (symlink first target)))) - libs)) - (_ #f)))) - inputs) - #t)) - (delete 'check) - ;; Remove libraries. If you need them, install ghc-pandoc instead. - (add-after 'register 'delete-libraries - (lambda* (#:key outputs #:allow-other-keys) - (delete-file-recursively (string-append (assoc-ref outputs "out") "/lib")))) - (add-after 'install 'post-install-check - (assoc-ref %standard-phases 'check))))) - (outputs '("out" "doc" "static")) - (inputs - (let* ((direct-inputs (package-inputs ghc-pandoc)) - (all-static-inputs - (map (lambda (pkg) - (list (string-append "static-" (package-name pkg)) - pkg "static")) - (delete-duplicates - (append (map cadr direct-inputs) - (filter (lambda (pkg) - (and - (string-prefix? "ghc-" (package-name pkg)) - (not (string=? "ghc-next" (package-name pkg))))) - (package-closure - (map cadr direct-inputs)))))))) - `(("zlib:static" ,zlib "static") - ,@all-static-inputs - ,@direct-inputs))) - (native-inputs - (let* ((direct-inputs (package-native-inputs ghc-pandoc)) - (all-static-inputs - (map (lambda (pkg) - (list (string-append "static-" (package-name pkg)) - pkg "static")) - (delete-duplicates - (append (map cadr direct-inputs) - (filter (lambda (pkg) - (and - (string-prefix? "ghc-" (package-name pkg)) - (not (string=? "ghc-next" (package-name pkg))))) - (package-closure - (map cadr direct-inputs)))))))) - `(,@all-static-inputs - ,@direct-inputs))))) +(define-public ghc-pandoc + (deprecated-package "ghc-pandoc" pandoc)) (define-public ghc-pandoc-types (package (name "ghc-pandoc-types") - (version "1.22.1") + (version "1.22.2.1") (source (origin (method url-fetch) (uri (hackage-uri "pandoc-types" version)) (sha256 (base32 - "0z2j306jsiriwhib0201hsllwyck7qcvqci5c25frwsmknr3mls2")))) + "17b5c4b9jmx2gca1wk9vlnvvlzdw21qiqc0bpikkkiv7kl99drsc")))) (build-system haskell-build-system) (properties '((upstream-name . "pandoc-types"))) - (arguments - `(#:phases - (modify-phases %standard-phases - ;; None of the directory names are actually used. By generating a - ;; simpler module without references to store names we avoid - ;; introducing references in the pandoc executable. - (add-after 'unpack 'create-simple-paths-module - (lambda _ - (call-with-output-file "Paths_pandoc_types.hs" - (lambda (port) - (format port "\ -{-# LANGUAGE CPP #-} -{-# LANGUAGE NoRebindableSyntax #-} -{-# OPTIONS_GHC -fno-warn-missing-import-lists #-} -module Paths_pandoc_types (version) where -import Data.Version (Version(..)) -version :: Version -version = Version [~a] [] -" (string-map (lambda (chr) (if (eq? chr #\.) #\, chr)) ,version)))) - #t))))) - (inputs - (list ghc-syb ghc-aeson)) - (native-inputs - (list ghc-quickcheck - ghc-test-framework - ghc-test-framework-hunit - ghc-test-framework-quickcheck2 - ghc-string-qq - ghc-hunit)) - (home-page "https://pandoc.org") + (inputs (list ghc-syb ghc-aeson ghc-quickcheck)) + (native-inputs (list ghc-test-framework ghc-test-framework-hunit + ghc-test-framework-quickcheck2 ghc-hunit + ghc-string-qq)) + (home-page "https://pandoc.org/") (synopsis "Types for representing a structured document") (description "This module defines the @code{Pandoc} data structure, which is used by @@ -8876,8 +8370,8 @@ (define-public ghc-parallel (build-system haskell-build-system) (properties '((upstream-name . "parallel"))) (arguments - `(#:cabal-revision - ("3" "1lv3y3zrdfc09nsiqxg7mzcahgnqi6z9caspd4lvifhhfrqy2722"))) + `(#:cabal-revision ("5" + "1q45wzpf2sda0244l55gakl3g5zqhcb27m86nhl3vslcjc35mpbf"))) (home-page "https://hackage.haskell.org/package/parallel") (synopsis "Parallel programming library") (description @@ -8930,14 +8424,13 @@ (define-public ghc-parsec-numbers (define-public ghc-parser-combinators (package (name "ghc-parser-combinators") - (version "1.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "parser-combinators" version)) - (sha256 - (base32 - "0k95nvgnl5820y094yfh7b868l0xd1diclm4kx9560p5rm02w5h3")))) + (version "1.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "parser-combinators" version)) + (sha256 + (base32 + "0is45q3q6ngfqvzpwwga9phbwk45v7g1q2x1rlm95a7q946yy44k")))) (build-system haskell-build-system) (properties '((upstream-name . "parser-combinators"))) (home-page "https://github.com/mrkkrp/parser-combinators") @@ -8950,28 +8443,26 @@ (define-public ghc-parser-combinators (define-public ghc-parsers (package (name "ghc-parsers") - (version "0.12.10") - (source - (origin - (method url-fetch) - (uri (hackage-uri "parsers" version)) - (sha256 - (base32 - "0v0smxbzk1qpdfkfqqmrzd2dngv3vxba10mkjn9nfm6a309izf8p")))) + (version "0.12.11") + (source (origin + (method url-fetch) + (uri (hackage-uri "parsers" version)) + (sha256 + (base32 + "068k7fm0s13z0jkkffc149cqcxnzpk1m066lp4ccdfcb41km1zwi")))) (build-system haskell-build-system) (properties '((upstream-name . "parsers"))) - (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy - ; -package attoparsec-0.13.0.1" - (inputs - (list ghc-base-orphans - ghc-attoparsec - ghc-scientific - ghc-semigroups - ghc-charset - ghc-unordered-containers)) - (home-page "https://github.com/ekmett/parsers/") + (inputs (list ghc-base-orphans + ghc-charset + ghc-scientific + ghc-unordered-containers + ghc-attoparsec + ghc-semigroups)) + (native-inputs (list ghc-quickcheck ghc-quickcheck-instances)) + (home-page "http://github.com/ekmett/parsers/") (synopsis "Parsing combinators") - (description "This library provides convenient combinators for working + (description + "This library provides convenient combinators for working with and building parsing combinator libraries. Given a few simple instances, you get access to a large number of canned definitions. Instances exist for the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s @@ -8981,31 +8472,24 @@ (define-public ghc-parsers (define-public ghc-path (package (name "ghc-path") - (version "0.8.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "path" version)) - (sha256 - (base32 - "0vzsa41q5sxs1ni72yv1vfpnc6r5mjdwnmdb6jrs6cszb2xlkjr4")))) + (version "0.9.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "path" version)) + (sha256 + (base32 + "15xxsjdxxqxnh20iqhprbdyhldk2igl5gd4ld6hhk9nqgwqdcr0f")))) (build-system haskell-build-system) (properties '((upstream-name . "path"))) - (arguments - `(#:cabal-revision - ("1" "02vhx94mqapyigvayb6cj7p7snn354pb542n3qyvsm0gih52wlja"))) - (inputs - (list ghc-aeson ghc-hashable)) - (native-inputs - (list ghc-hspec - ghc-quickcheck - ghc-genvalidity - ghc-genvalidity-hspec - ghc-genvalidity-property - ghc-hspec - ghc-validity)) - (home-page - "https://hackage.haskell.org/package/path") + (inputs (list ghc-aeson ghc-hashable)) + (native-inputs (list ghc-hspec + ghc-quickcheck + ghc-genvalidity + ghc-genvalidity-property + ghc-genvalidity-hspec + ghc-hspec + ghc-validity)) + (home-page "http://hackage.haskell.org/package/path") (synopsis "Support for well-typed paths") (description "This package introduces a type for paths upholding useful invariants.") @@ -9014,32 +8498,21 @@ (define-public ghc-path (define-public ghc-path-io (package (name "ghc-path-io") - (version "1.6.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "path-io" version)) - (sha256 - (base32 - "1dnc48hf8x83p0jy05qi8j8gmfmsy50swnql9ssdv74lsryp615n")))) - (build-system haskell-build-system) - (properties '((upstream-name . "path-io"))) - (arguments - `(#:cabal-revision - ("3" "0rsr9r2175lf7zcz2sns0mhxkvl21pm50sjidjq5v75nalrsw6rp"))) - (inputs - (list ghc-dlist - ghc-exceptions - ghc-path - ghc-transformers-base - ghc-unix-compat - ghc-temporary)) - (native-inputs - (list ghc-hspec)) - (home-page - "https://github.com/mrkkrp/path-io") + (version "1.7.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "path-io" version)) + (sha256 + (base32 + "1jr1inh3x0a42rdh4q0jipbw8jsprdza1j5xkzd7nxcq0a143g9l")))) + (build-system haskell-build-system) + (properties '((upstream-name . "path-io"))) + (inputs (list ghc-dlist ghc-path ghc-temporary ghc-unix-compat)) + (native-inputs (list ghc-hspec)) + (home-page "https://github.com/mrkkrp/path-io") (synopsis "Functions for manipulating well-typed paths") - (description "This package provides an interface to the @code{directory} + (description + "This package provides an interface to the @code{directory} package for users of @code{path}. It also implements some missing stuff like recursive scanning and copying of directories, working with temporary files/directories, and more.") @@ -9140,83 +8613,81 @@ (define-public ghc-pcre-light (define-public ghc-persistent (package (name "ghc-persistent") - (version "2.13.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "persistent" version)) - (sha256 - (base32 - "13lp9i94f57qhifdmr1vnsrra34526f7kqa1sybcaj2jh2v3q85k")))) + (version "2.13.3.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "persistent" version)) + (sha256 + (base32 + "0z69yvk0rd29dp5qdhi4p587b891y90azrzzpa3g10cxp3gyywvm")))) (build-system haskell-build-system) (properties '((upstream-name . "persistent"))) - (inputs - (list ghc-aeson - ghc-attoparsec - ghc-base64-bytestring - ghc-blaze-html - ghc-conduit - ghc-fast-logger - ghc-http-api-data - ghc-lift-type - ghc-monad-logger - ghc-path-pieces - ghc-resource-pool - ghc-resourcet - ghc-scientific - ghc-silently - ghc-th-lift-instances - ghc-unliftio-core - ghc-unliftio - ghc-unordered-containers - ghc-vector)) - (native-inputs - (list ghc-hspec ghc-quickcheck ghc-quickcheck-instances - ghc-shakespeare)) - (home-page "https://www.yesodweb.com/book/persistent") + (inputs (list ghc-conduit + ghc-aeson + ghc-attoparsec + ghc-base64-bytestring + ghc-blaze-html + ghc-fast-logger + ghc-http-api-data + ghc-lift-type + ghc-monad-logger + ghc-path-pieces + ghc-resource-pool + ghc-resourcet + ghc-scientific + ghc-silently + ghc-th-lift-instances + ghc-unliftio + ghc-unliftio-core + ghc-unordered-containers + ghc-vault + ghc-vector)) + (native-inputs (list ghc-hspec ghc-quickcheck ghc-quickcheck-instances + ghc-shakespeare)) + (arguments + `(#:cabal-revision ("3" + "0kyipwaspzah6f88s51d61kr8i9g05grm2g0lnnw28jp06nggg5d"))) + (home-page "http://www.yesodweb.com/book/persistent") (synopsis "Type-safe, multi-backend data serialization for Haskell") - (description "This Haskell package allows Haskell programs to access data + (description + "This Haskell package allows Haskell programs to access data storage systems like PostgreSQL, SQLite, and MariaDB in a type-safe way.") (license license:expat))) (define-public ghc-persistent-sqlite (package (name "ghc-persistent-sqlite") - (version "2.13.0.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "persistent-sqlite" version)) - (sha256 - (base32 - "12za89crbk74mya4qxpw5fp5fqp64vwz5s8vbjd7m8r3j3vbw338")))) + (version "2.13.1.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "persistent-sqlite" version)) + (sha256 + (base32 + "1z8650nv10f6yldn9sihk54c7mlcnkxwaj956igvs6q3x3s8aa1b")))) (build-system haskell-build-system) (properties '((upstream-name . "persistent-sqlite"))) - (inputs - (list ghc-persistent - ghc-aeson - ghc-conduit - ghc-microlens-th - ghc-monad-logger - ghc-resource-pool - ghc-resourcet - ghc-unliftio-core - ghc-unordered-containers)) - (native-inputs - (list ghc-persistent-template - ghc-persistent-test - ghc-exceptions - ghc-fast-logger - ghc-hspec - ghc-hunit - ghc-quickcheck - ghc-system-fileio - ghc-system-filepath - ghc-temporary)) - (home-page - "https://www.yesodweb.com/book/persistent") + (inputs (list ghc-persistent + ghc-aeson + ghc-conduit + ghc-microlens-th + ghc-monad-logger + ghc-resource-pool + ghc-resourcet + ghc-unliftio-core + ghc-unordered-containers)) + (native-inputs (list ghc-persistent-test + ghc-fast-logger + ghc-hspec + ghc-hunit + ghc-microlens + ghc-quickcheck + ghc-system-fileio + ghc-system-filepath + ghc-temporary)) + (home-page "http://www.yesodweb.com/book/persistent") (synopsis "Backend for the persistent library using sqlite3") - (description "This Haskell package includes a thin sqlite3 wrapper based + (description + "This Haskell package includes a thin sqlite3 wrapper based on the direct-sqlite package, as well as the entire C library, so there are no system dependencies.") (license license:expat))) @@ -9254,14 +8725,14 @@ (define-public ghc-persistent-template (define-public ghc-persistent-test (package (name "ghc-persistent-test") - (version "2.13.0.3") + (version "2.13.1.2") (source (origin (method url-fetch) (uri (hackage-uri "persistent-test" version)) (sha256 (base32 - "07q53jvhz00cf10k7a8fkvykgwcl10fgzh8k9gv1d248f336crvs")))) + "0cah2gyp5lm9hipm3wvcxnl14cmq51dajzcw3wcf9xd19sbm4k49")))) (build-system haskell-build-system) (properties '((upstream-name . "persistent-test"))) (inputs @@ -9342,6 +8813,9 @@ (define-public ghc-pipes (native-inputs (list ghc-quickcheck ghc-test-framework ghc-test-framework-quickcheck2)) + (arguments + `(#:cabal-revision ("6" + "16s8a1ijakhsk73ny2vrw6a8r2dszgncd0wk735ii6csg3l2c9pm"))) (home-page "https://hackage.haskell.org/package/pipes") (synopsis "Compositional pipelines") @@ -9399,8 +8873,8 @@ (define-public ghc-polyparse (build-system haskell-build-system) (properties '((upstream-name . "polyparse"))) (arguments - `(#:cabal-revision - ("2" "1n5q6w7x46cvcq7j1pg9jx9h72vcsc5di35rbkmwgjw6pq4w4gfl"))) + `(#:cabal-revision ("5" + "05qrn5pfdy45x1nkx7dvhnxs9j6d6cssws4kwn2sl3n9qmagr8mc"))) (home-page "http://code.haskell.org/~malcolm/polyparse/") (synopsis @@ -9417,18 +8891,19 @@ (define-public ghc-polyparse (define-public ghc-pqueue (package (name "ghc-pqueue") - (version "1.4.1.3") + (version "1.4.3.0") (source (origin (method url-fetch) (uri (hackage-uri "pqueue" version)) (sha256 (base32 - "1sz7hlnfd86hbwrgqxczmsjsl1ki0ryi9dgzscxlsgjkdgcdia2p")))) + "0kl608jw0xz0n4ysw7p3cvlm1s71xrysw8862cddrzbr38bv8jvq")))) (build-system haskell-build-system) (properties '((upstream-name . "pqueue"))) + (inputs (list ghc-indexed-traversable)) (native-inputs - (list ghc-quickcheck)) + (list ghc-tasty ghc-tasty-quickcheck)) (home-page "https://hackage.haskell.org/package/pqueue") (synopsis "Reliable, persistent, fast priority queues") (description @@ -9577,21 +9052,19 @@ (define-public ghc-pretty-show (define-public ghc-pretty-simple (package (name "ghc-pretty-simple") - (version "4.0.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "pretty-simple" version)) - (sha256 - (base32 "1srvx854ml2gffnkxr2fm12xk8syjsk078rfzrq0a3idwgv46myw")))) + (version "4.1.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "pretty-simple" version)) + (sha256 + (base32 + "0di7n3kq2bl0xqj9b1xxf3jznyy6cfyjs6hf6g0bi72rf4wprd1w")))) (build-system haskell-build-system) (properties '((upstream-name . "pretty-simple"))) - - (inputs - (list ghc-aeson ghc-optparse-applicative - ghc-prettyprinter-ansi-terminal ghc-prettyprinter)) - (native-inputs - (list cabal-doctest ghc-doctest ghc-glob ghc-quickcheck)) + (inputs (list ghc-prettyprinter ghc-prettyprinter-ansi-terminal + ghc-optparse-applicative ghc-aeson)) + (native-inputs (list ghc-doctest ghc-glob ghc-quickcheck)) + (arguments (list #:tests? #f)) ; Could not find module ‘Build_doctests’ (home-page "https://github.com/cdepillabout/pretty-simple") (synopsis "Pretty printer for data types with a 'Show' instance") (description @@ -9602,27 +9075,27 @@ (define-public ghc-pretty-simple (define-public ghc-primitive (package (name "ghc-primitive") - (version "0.7.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "primitive" version)) - (sha256 - (base32 - "1facmq2wxhn5mbgd209zz5swyaw1q970fv3hd84klaxrhabqaxwi")))) + (version "0.7.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "primitive" version)) + (sha256 + (base32 + "1p01fmw8yi578rvwicrlpbfkbfsv7fbnzb88a7vggrhygykgs31w")))) (build-system haskell-build-system) (properties '((upstream-name . "primitive"))) - (arguments `(#:tests? #f)) ; TODO: Loops. -; (native-inputs -; `(("ghc-base-orphans" ,ghc-base-orphans) -; ("ghc-quickcheck-classes-base" ,ghc-quickcheck-classes-base) -; ("ghc-quickcheck" ,ghc-quickcheck) -; ("ghc-tasty" ,ghc-tasty) -; ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) -; ("ghc-tagged" ,ghc-tagged) -; ("ghc-transformers-compat" ,ghc-transformers-compat))) - (home-page - "https://github.com/haskell/primitive") +; (native-inputs (list ghc-base-orphans +; ghc-quickcheck-classes-base +; ghc-quickcheck +; ghc-tasty +; ghc-tasty-quickcheck +; ghc-tagged +; ghc-transformers-compat)) + (arguments + `(#:tests? #f ; Cannot resolve package cycle. + #:cabal-revision ("2" + "0xh1m8nybz760c71gm1w9fga25y2rys1211q77v6wagdsas634yf"))) + (home-page "https://github.com/haskell/primitive") (synopsis "Primitive memory-related operations") (description "This package provides various primitive memory-related operations.") @@ -9735,20 +9208,18 @@ (define-public ghc-project-template (define-public ghc-protolude (package (name "ghc-protolude") - (version "0.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "protolude" version)) - (sha256 - (base32 - "1b6wprbwfdjyvds2bm6na0fbqgzdkj5ikkk33whbkyh3krd3i0s0")))) + (version "0.3.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "protolude" version)) + (sha256 + (base32 + "0i53yxg44nrz0czwr8cqhw1fdapz9db8kfnqz9a3lmj5skrikh3y")))) (build-system haskell-build-system) (properties '((upstream-name . "protolude"))) - (inputs - (list ghc-async ghc-hashable ghc-mtl-compat ghc-paths - ghc-transformers-compat)) - (home-page "https://github.com/protolude/protolude") + (inputs (list ghc-async ghc-hashable ghc-mtl-compat + ghc-transformers-compat)) + (home-page "https://github.com/sdiehl/protolude") (synopsis "Sensible set of defaults for writing custom Preludes") (description "Protolude gives you sensible defaults for writing custom Preludes to @@ -9758,18 +9229,19 @@ (define-public ghc-protolude (define-public ghc-psqueue (package (name "ghc-psqueue") - (version "1.1.0.1") + (version "1.1.1") (source (origin (method url-fetch) (uri (hackage-uri "PSQueue" version)) (sha256 (base32 - "1cik7sw10sacsijmfhghzy54gm1qcyxw14shlp86lx8z89kcnkza")))) + "02pgqzwxndi8cwa5fw668gfsh7z3lzbygkgcsf56bwrxwqjyz4bi")))) (build-system haskell-build-system) (properties '((upstream-name . "PSQueue"))) + (native-inputs (list ghc-quickcheck)) (arguments '(#:cabal-revision - ("2" "0n1yrv1x1dxbjn9hjr8lk4k5in9c75ixzldlmszayi26bvax7329"))) + ("1" "02a5g59sc9jh3v4pibhjpijv8lsbiydznrpqyin7qhwsyc0p813a"))) (home-page "https://hackage.haskell.org/package/PSQueue") (synopsis "Priority search queue") (description @@ -9784,32 +9256,26 @@ (define-public ghc-psqueue (define-public ghc-psqueues (package (name "ghc-psqueues") - (version "0.2.7.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "psqueues" version)) - (sha256 - (base32 - "1yckx2csqswghiy9nfj03cybmza8104nmnpbpcc9ngwlbmakn9i6")))) + (version "0.2.7.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "psqueues" version)) + (sha256 + (base32 + "1cmz7spfzx7niglmsphnndh0m4b8njkn0fhb9nshbnbq6nx515yh")))) (build-system haskell-build-system) (properties '((upstream-name . "psqueues"))) - (arguments - '(#:tests? #f ; TODO: Needs quickcheck<2.14 - #:cabal-revision - ("1" "0d0mm3c8x31dasfzp1884r2irkm3c9irvvbahjzfr1bzzxfb7vyv"))) - (inputs - (list ghc-hashable)) - (native-inputs - (list ghc-hunit - ghc-quickcheck - ghc-tagged - ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck)) - (home-page "https://github.com/jaspervdj/psqueues") + (inputs (list ghc-hashable)) + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-tagged)) + (home-page "http://hackage.haskell.org/package/psqueues") (synopsis "Pure priority search queues") - (description "The psqueues package provides + (description + "The psqueues package provides @uref{https://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in three different flavors: @@ -9878,36 +9344,33 @@ (define-public ghc-pwstore-fast (define-public ghc-random (package (name "ghc-random") - (version "1.2.0") - (outputs '("out" "static" "doc")) - (source - (origin - (method url-fetch) - (uri (hackage-uri "random" version)) - (sha256 - (base32 "1pmr7zbbqg58kihhhwj8figf5jdchhi7ik2apsyxbgsqq3vrqlg4")))) + (version "1.2.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "random" version)) + (sha256 + (base32 + "0xlv1k4sj87akwvj54kq4nrfkzi6qcz1941bf78pnkbaxpvp44iy")))) (build-system haskell-build-system) (properties '((upstream-name . "random"))) - (arguments - `(#:tests? #f - #:cabal-revision - ("6" "1hzfz9b1cxrsya8i53yx145iypaakfsfjix7l8girhx7vbz0cm8r"))) - (inputs `(("ghc-splitmix" ,ghc-splitmix-bootstrap))) - ;; ghc-random is widely used and causes quite a few loops. -; (native-inputs -; `(("ghc-doctest" ,ghc-doctest) -; ("ghc-mwc-random" ,ghc-mwc-random) -; ("ghc-primitive" ,ghc-primitive) -; ("ghc-unliftio" ,ghc-unliftio) -; ("ghc-vector" ,ghc-vector) -; ("ghc-smallcheck" ,ghc-smallcheck) -; ("ghc-tasty" ,ghc-tasty) -; ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck) -; ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure) -; ("ghc-tasty-hunit" ,ghc-tasty-hunit))) - (home-page "https://hackage.haskell.org/package/random") + ;; ghc-random is widely used and causes quite a few loops, so disable tests. + (arguments (list #:tests? #f)) + (inputs (list ghc-splitmix-bootstrap)) +; (native-inputs (list ghc-doctest +; ghc-mwc-random +; ghc-primitive +; ghc-unliftio-bootstrap +; ghc-vector +; ghc-smallcheck +; ghc-tasty +; ghc-tasty-smallcheck +; ghc-tasty-hunit +; ghc-tasty +; ghc-tasty-inspection-testing)) + (home-page "http://hackage.haskell.org/package/random") (synopsis "Random number library") - (description "This package provides a basic random number generation + (description + "This package provides a basic random number generation library, including the ability to split random number generators.") (license license:bsd-3))) @@ -9958,6 +9421,9 @@ (define-public ghc-readable "1ja39cg26wy2fs00gi12x7iq5k8i366pbqi3p916skfa5jnkfc3h")))) (build-system haskell-build-system) (properties '((upstream-name . "readable"))) + (arguments + `(#:cabal-revision ("1" + "0dywlvxjszqa1dj5r1cva0viv2l1hm8mw75zddnf96pfpd00fmga"))) (home-page "https://github.com/mightybyte/readable") (synopsis "Type class for reading from Text and ByteString") (description "This package provides a @code{Readable} type class for @@ -9968,38 +9434,41 @@ (define-public ghc-readable (define-public ghc-rebase (package (name "ghc-rebase") - (version "1.13.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "rebase" version)) - (sha256 - (base32 - "0sh1vha10n28c4jb97p99xglghqph8ppydqzbnb2h25a34057927")))) + (version "1.16.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "rebase" version)) + (sha256 + (base32 + "0mb1x5p3lvfhxsrnmkhsv6f4rd1cxp6m3qg6kyz30svrbwxsvvkz")))) (build-system haskell-build-system) (properties '((upstream-name . "rebase"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-bifunctors - ghc-comonad - ghc-contravariant - ghc-dlist - ghc-either - ghc-hashable - ghc-hashable-time - ghc-profunctors - ghc-scientific - ghc-selective - ghc-semigroupoids - ghc-unordered-containers - ghc-uuid-types - ghc-vector - ghc-vector-instances - ghc-void)) + (inputs (list ghc-bifunctors + ghc-contravariant + ghc-comonad + ghc-dlist + ghc-either + ghc-groups + ghc-hashable + ghc-invariant + ghc-profunctors + ghc-scientific + ghc-selective + ghc-semigroupoids + ghc-time-compat + ghc-unordered-containers + ghc-uuid-types + ghc-vector + ghc-vector-instances + ghc-void)) + (arguments + `(#:cabal-revision ("1" + "1igpk9gz54jfvf5m69xcp7hl567c4lkbmwhzylcbx0i1n0pd7i2n"))) (home-page "https://github.com/nikita-volkov/rebase") (synopsis "Progressive alternative to the base package for Haskell") - (description "This Haskell package is intended for those who are + (description + "This Haskell package is intended for those who are tired of keeping long lists of dependencies to the same essential libraries in each package as well as the endless imports of the same APIs all over again. @@ -10025,24 +9494,23 @@ (define-public ghc-rebase (define-public ghc-reducers (package (name "ghc-reducers") - (version "3.12.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "reducers" version)) - (sha256 - (base32 - "09wf8pl9ycglcv6qj5ba26gkg2s5iy81hsx9xp0q8na0cwvp71ki")))) + (version "3.12.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "reducers" version)) + (sha256 + (base32 + "0hsycdir52jdijnnvc77jj971fjrrc722v952wr62ivrvx2zarn0")))) (build-system haskell-build-system) (properties '((upstream-name . "reducers"))) + (inputs (list ghc-fingertree ghc-hashable ghc-unordered-containers + ghc-semigroupoids ghc-semigroups)) (arguments - '(#:cabal-revision - ("2" "1kd38n9h2hxl09khvkvkhnflgm6rbky1zkw3iazlpb8xk9zkk39s"))) - (inputs - (list ghc-fingertree ghc-hashable ghc-unordered-containers - ghc-semigroupoids ghc-semigroups)) - (home-page "https://github.com/ekmett/reducers/") - (synopsis "Semigroups, specialized containers and a general map/reduce framework") + `(#:cabal-revision ("2" + "1ji6rp0f857d0vp2kjqcck7avrjgqvqjgwnhdcxs3zbjkwpqyhfb"))) + (home-page "http://github.com/ekmett/reducers/") + (synopsis + "Semigroups, specialized containers and a general map/reduce framework") (description "This library provides various semigroups, specialized containers and a general map/reduce framework for Haskell.") (license license:bsd-3))) @@ -10096,36 +9564,23 @@ (define-public ghc-reflection (define-public ghc-regex (package (name "ghc-regex") - (version "1.1.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "regex" version)) - (sha256 - (base32 - "02hxgy5ck3h5pwd5gzs4565qbql8457cjdbbc2yrk236qzc1qa8x")))) + (version "1.1.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "regex" version)) + (sha256 + (base32 + "1nzyfkqmclmawmphvksvm9l64awqgnypic4xplc2s9sjcj4h814a")))) (build-system haskell-build-system) (properties '((upstream-name . "regex"))) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'relax-dependencies - (lambda _ - (substitute* "regex.cabal" - (("base-compat.*>=.*0.6.*") - "base-compat >= 0.6\n") - (("template-haskell.*>=.*2.7.*") - "template-haskell >= 2.7\n")) - #t))))) - (inputs - (list ghc-base-compat - ghc-hashable - ghc-regex-base - ghc-regex-pcre-builtin - ghc-regex-tdfa - ghc-time-locale-compat - ghc-unordered-containers - ghc-utf8-string)) + (inputs (list ghc-base-compat + ghc-hashable + ghc-regex-base + ghc-regex-pcre-builtin + ghc-regex-tdfa + ghc-time-locale-compat + ghc-unordered-containers + ghc-utf8-string)) (home-page "https://regex.uk") (synopsis "Toolkit for regex-base") (description @@ -10163,20 +9618,22 @@ (define-public ghc-regex-applicative (define-public ghc-regex-base (package (name "ghc-regex-base") - (version "0.94.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "regex-base" version)) - (sha256 - (base32 - "1ngdmmrxs1rhvib052c6shfa40yad82jylylikz327r0zxpxkcbi")))) + (version "0.94.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "regex-base" version)) + (sha256 + (base32 + "1w9fxad1dwi040r3db9i2cjhhrl86p3hngj13ixbcnqgb27l16bv")))) (build-system haskell-build-system) (properties '((upstream-name . "regex-base"))) - (home-page - "https://sourceforge.net/projects/lazy-regex") + (arguments + `(#:cabal-revision ("1" + "1k2gzjm7xz69f7zr08wh2wzb5dhb659cvimsvx0g9p8cf5f45x2g"))) + (home-page "https://wiki.haskell.org/Regular_expressions") (synopsis "Replaces/Enhances Text.Regex") - (description "@code{Text.Regex.Base} provides the interface API for + (description + "@code{Text.Regex.Base} provides the interface API for regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.") (license license:bsd-3))) @@ -10195,36 +9652,15 @@ (define-public ghc-regex-compat (properties '((upstream-name . "regex-compat"))) (inputs (list ghc-regex-base ghc-regex-posix)) + (arguments + `(#:cabal-revision ("2" + "0ldqpdxikm17ydrkfmichflkdqdrkspv4r0qy3zbdgqf5033pj4n"))) (home-page "https://sourceforge.net/projects/lazy-regex") (synopsis "Replaces/Enhances Text.Regex") (description "This library provides one module layer over @code{regex-posix} to replace @code{Text.Regex}.") (license license:bsd-3))) -(define-public ghc-regex-compat-tdfa - (package - (name "ghc-regex-compat-tdfa") - (version "0.95.1.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "regex-compat-tdfa" version)) - (sha256 - (base32 - "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg")))) - (build-system haskell-build-system) - (properties '((upstream-name . "regex-compat-tdfa"))) - (inputs - (list ghc-regex-base ghc-regex-tdfa)) - (home-page "https://hub.darcs.net/shelarcy/regex-compat-tdfa") - (synopsis "Unicode Support version of Text.Regex, using regex-tdfa") - (description - "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}. -@code{regex-compat} can't use Unicode characters correctly because of using regex-posix. -This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve -this problem.") - (license license:bsd-3))) - (define-public ghc-regex-pcre (package (name "ghc-regex-pcre") @@ -10298,23 +9734,18 @@ (define-public ghc-regex-posix (define-public ghc-regex-tdfa (package (name "ghc-regex-tdfa") - (version "1.3.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "regex-tdfa" version)) - (sha256 - (base32 - "1msrq31k4jmn2lmrdzn87jqarqhw265ca69rfg5jpa5adrzm3gmi")))) + (version "1.3.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "regex-tdfa" version)) + (sha256 + (base32 + "1lfzhir5zbgga44zhr4qvc2xc9pa9lslv12c8lwqqw80bzfdfq16")))) (build-system haskell-build-system) (properties '((upstream-name . "regex-tdfa"))) - (arguments - '(#:cabal-revision - ("1" "02gwf740vs0jy3l6dgw72r8c04yggshia6w16n140ncpsici8c4r"))) - (inputs - (list ghc-regex-base)) - (native-inputs (list ghc-utf8-string)) - (home-page "https://github.com/haskell-hvr/regex-tdfa") + (inputs (list ghc-regex-base)) + (native-inputs (list ghc-utf8-string ghc-doctest-parallel)) + (home-page "https://wiki.haskell.org/Regular_expressions") (synopsis "POSIX extended regular expressions in Haskell") (description "Regex-tdfa is a pure Haskell regular expression library implementing POSIX @@ -10325,18 +9756,15 @@ (define-public ghc-regex-tdfa (define-public ghc-repline (package (name "ghc-repline") - (version "0.4.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "repline" version)) - (sha256 - (base32 - "1dspwi28krinkxdd7waq4y6plz0dfmzz72885p9pcqp1r14qrhj3")))) + (version "0.4.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "repline" version)) + (sha256 + (base32 + "0nldn02yqqmrxkzwzrx3v6hkb4y2hch48jkcr2qrw1dl0vqv70b1")))) (build-system haskell-build-system) (properties '((upstream-name . "repline"))) - (inputs - (list ghc-exceptions ghc-haskeline)) (home-page "https://github.com/sdiehl/repline") (synopsis "Haskeline wrapper for GHCi-like REPL interfaces") (description @@ -10347,22 +9775,20 @@ (define-public ghc-repline (define-public ghc-rerebase (package (name "ghc-rerebase") - (version "1.13.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "rerebase" version)) - (sha256 - (base32 - "0j50l96whwi65ir35nfhn24h6103zy1ilfjsqiax63ajzw169fkv")))) + (version "1.16.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "rerebase" version)) + (sha256 + (base32 + "04pw2j4nh8x53axmfzp9d2plmiwxpxddgwcji0a8j24lkdyv8k32")))) (build-system haskell-build-system) (properties '((upstream-name . "rerebase"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-rebase)) + (inputs (list ghc-rebase)) (home-page "https://github.com/nikita-volkov/rerebase") (synopsis "Reexports from ``base'' with many other standard libraries") - (description "A rich drop-in replacement for @code{base}. For details and + (description + "A rich drop-in replacement for @code{base}. For details and documentation please visit @uref{https://github.com/nikita-volkov/rerebase, the project's home page}.") (license license:expat))) @@ -10381,9 +9807,16 @@ (define-public ghc-resolv (build-system haskell-build-system) (properties '((upstream-name . "resolv"))) (arguments - `(#:tests? #f ; TODO: tasty >=1.2.3 && <1.3 || >=1.3.1 && <1.4 - #:cabal-revision - ("3" "0af5dsdyn04i76d012xhhfkkml10bqzl6q2yivkhf8rlvh1fiii5"))) + `(;#:tests? #f ; tasty >=1.2.3 && <1.3 || >=1.3.1 && <1.4 + #:cabal-revision ("5" + "0df5y8bj9bxjmqnkvpwxvb17k70g1i174xs6vfrv9f1lys7xkqk1") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "resolv.cabal" + (("\\b(tasty)\\s+[^,]+" all dep) + dep))))))) (inputs (list ghc-base16-bytestring)) (native-inputs @@ -10422,26 +9855,18 @@ (define-public ghc-resource-pool (define-public ghc-resourcet (package (name "ghc-resourcet") - (version "1.2.4.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "resourcet" version)) - (sha256 - (base32 - "0zrvnikw1a0r2j59k12fxikyrg0ki5a7xhqhjgfl9h6dqpz54h85")))) + (version "1.2.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "resourcet" version)) + (sha256 + (base32 + "0d7xnpysrick56gxzkkj0mpblywbxaaldhziyl77am3822r3afzq")))) (build-system haskell-build-system) (properties '((upstream-name . "resourcet"))) - (inputs - (list ghc-transformers-base - ghc-monad-control - ghc-transformers-compat - ghc-mmorph - ghc-exceptions - ghc-unliftio-core)) - (native-inputs - (list ghc-lifted-base ghc-hspec)) - (home-page "https://github.com/snoyberg/conduit") + (inputs (list ghc-unliftio-core ghc-primitive)) + (native-inputs (list ghc-hspec)) + (home-page "http://github.com/snoyberg/conduit") (synopsis "Deterministic allocation and freeing of scarce resources") (description "ResourceT is a monad transformer which creates a region of code where you can safely allocate resources.") @@ -10450,24 +9875,22 @@ (define-public ghc-resourcet (define-public ghc-retry (package (name "ghc-retry") - (version "0.8.1.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "retry" version)) - (sha256 - (base32 - "0nwyis42xpmxfw8nz8qn59r3v7q0dkfzkzkhllgn30cdjbbmwhf5")))) + (version "0.9.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "retry" version)) + (sha256 + (base32 + "1kafm17xk6hylr0lwa98wxjcx7z3rgnqi4fzxcks7dy9dz5ms7n1")))) (build-system haskell-build-system) (properties '((upstream-name . "retry"))) - (inputs - (list ghc-exceptions ghc-random)) - (native-inputs - (list ghc-hunit ghc-tasty ghc-tasty-hunit ghc-tasty-hedgehog - ghc-hedgehog)) - (home-page "https://github.com/Soostone/retry") + (inputs (list ghc-random ghc-mtl-compat ghc-unliftio-core)) + (native-inputs (list ghc-hunit ghc-tasty ghc-tasty-hunit + ghc-tasty-hedgehog ghc-hedgehog)) + (home-page "http://github.com/Soostone/retry") (synopsis "Retry combinators for monadic actions that may fail") - (description "This package exposes combinators that can wrap + (description + "This package exposes combinators that can wrap arbitrary monadic actions. They run the action and potentially retry running it with some configurable delay for a configurable number of times. The purpose is to make it easier to work with IO and especially @@ -10503,31 +9926,29 @@ (define-public ghc-rfc5051 (define-public ghc-rio (package (name "ghc-rio") - (version "0.1.21.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "rio" version)) - (sha256 - (base32 - "013m4xgsmg8h1rba9krxppz49lc5wz26gksms5zibsjj0w59m58h")))) + (version "0.1.22.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "rio" version)) + (sha256 + (base32 + "0rpc4f2yvw0y6mqz9ykm3778j6srya7ssww691kpf9nb8vddgjb6")))) (build-system haskell-build-system) (properties '((upstream-name . "rio"))) - (inputs - (list ghc-hashable - ghc-microlens - ghc-microlens-mtl - ghc-primitive - ghc-typed-process - ghc-unliftio-core - ghc-unliftio - ghc-unordered-containers - ghc-vector)) - (native-inputs - (list ghc-hspec ghc-quickcheck hspec-discover)) + (inputs (list ghc-hashable + ghc-microlens + ghc-microlens-mtl + ghc-primitive + ghc-typed-process + ghc-unliftio + ghc-unliftio-core + ghc-unordered-containers + ghc-vector)) + (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover)) (home-page "https://github.com/commercialhaskell/rio#readme") (synopsis "Standard library for Haskell") - (description "This package works as a prelude replacement for Haskell, + (description + "This package works as a prelude replacement for Haskell, providing more functionality and types out of the box than the standard prelude (such as common data types like @code{ByteString} and @code{Text}), as well as removing common ``gotchas'', like partial @@ -10553,6 +9974,14 @@ (define-public ghc-roman-numerals (build-system haskell-build-system) (properties '((upstream-name . "roman-numerals"))) (inputs (list ghc-base-unicode-symbols)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "roman-numerals.cabal" + (("\\b(bytestring)\\s+[^,]+" all dep) + dep))))))) (home-page "https://github.com/roelvandijk/roman-numerals") (synopsis "Parsing and pretty printing of Roman numerals") (description @@ -10587,21 +10016,20 @@ (define-public ghc-safe (define-public ghc-safe-exceptions (package (name "ghc-safe-exceptions") - (version "0.1.7.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "safe-exceptions" version)) - (sha256 - (base32 - "15a80s87f603w8l7fnaba2cyqx62042vvcidpjzyga2685wpyqv9")))) + (version "0.1.7.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "safe-exceptions" version)) + (sha256 + (base32 + "1gxm61mccivrdz2qcfh5sim596nbrpapx0nli0bx7vx6z3c2ikli")))) (build-system haskell-build-system) (properties '((upstream-name . "safe-exceptions"))) - (native-inputs - (list ghc-hspec ghc-void hspec-discover)) - (home-page "https://github.com/fpco/safe-exceptions") + (native-inputs (list ghc-hspec ghc-void hspec-discover)) + (home-page "https://github.com/fpco/safe-exceptions#readme") (synopsis "Safe, consistent, and easy exception handling") - (description "Runtime exceptions - as exposed in @code{base} by the + (description + "Runtime exceptions - as exposed in @code{base} by the @code{Control.Exception} module - have long been an intimidating part of the Haskell ecosystem. This package is intended to overcome this. It provides a safe and simple API on top of the existing exception handling machinery. The @@ -10629,6 +10057,7 @@ (define-public ghc-safeio (native-inputs (list ghc-hunit ghc-test-framework ghc-test-framework-hunit ghc-test-framework-th)) + (arguments (list #:tests? #f)) ; Fail to build: Module ‘Data.ByteString’ does not export ‘hPutStrLn’. (home-page "https://github.com/luispedro/safeio") (synopsis "Write output to disk atomically") (description @@ -10738,6 +10167,9 @@ (define-public ghc-scientific ghc-tasty-quickcheck ghc-smallcheck ghc-quickcheck)) + (arguments + `(#:cabal-revision ("3" + "1n67w1b64q59nn4845z3kr8rm0x0p7bi3cyp6n1dpnfs8k4l8x2i"))) (home-page "https://github.com/basvandijk/scientific") (synopsis "Numbers represented using scientific notation") (description "This package provides @code{Data.Scientific}, which provides @@ -10786,22 +10218,22 @@ (define-public ghc-sdl (define-public ghc-sdl2 (package (name "ghc-sdl2") - (version "2.5.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "sdl2" version)) - (sha256 - (base32 - "08l24cb92spnx3bn26bj0z2cszpsawhaa9vvhblvsr3d6z76065q")))) + (version "2.5.4.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "sdl2" version)) + (sha256 + (base32 + "1g35phifz49kxk48s8jmgglxhxl79cbzc1cg2qlgk0vdpxpin8ym")))) (build-system haskell-build-system) (properties '((upstream-name . "sdl2"))) - (arguments '(#:tests? #f)) ; tests require graphical environment - (inputs - (list ghc-exceptions ghc-linear ghc-statevar ghc-vector sdl2)) - (native-inputs - (list ghc-weigh pkg-config)) - (home-page "https://hackage.haskell.org/package/sdl2") + (inputs (list ghc-statevar ghc-vector ghc-linear sdl2)) + (native-inputs (list ghc-weigh pkg-config)) + (arguments + `(#:tests? #f ; Needs a graphics card. + #:cabal-revision ("2" + "1yxzq4gb6ig3d94lc76i5d50fa0j1fxr1wdlmgwhkvlfd4xnh6sg"))) + (home-page "http://hackage.haskell.org/package/sdl2") (synopsis "High- and low-level bindings to the SDL library") (description "This package contains bindings to the SDL 2 library, in both high- and @@ -10817,21 +10249,18 @@ (define-public ghc-sdl2 (define-public ghc-sdl2-image (package (name "ghc-sdl2-image") - (version "2.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "sdl2-image" version)) - (sha256 - (base32 - "1pr6dkg73cy9z0w54lrkj9c5bhxj56nl92lxikjy8kz6nyr455rr")))) + (version "2.1.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "sdl2-image" version)) + (sha256 + (base32 + "03cjlmj844gmfxqn9mp8333hpsg227kaipgs6g68xwg0cvch696j")))) (build-system haskell-build-system) (properties '((upstream-name . "sdl2-image"))) - (inputs - (list ghc-sdl2 sdl2-image)) - (native-inputs - (list pkg-config)) - (home-page "https://hackage.haskell.org/package/sdl2-image") + (inputs (list ghc-sdl2 sdl2-image)) + (native-inputs (list pkg-config)) + (home-page "http://hackage.haskell.org/package/sdl2-image") (synopsis "Bindings to SDL2_image") (description "This package provides Haskell bindings to @code{SDL2_image}.") @@ -10840,26 +10269,19 @@ (define-public ghc-sdl2-image (define-public ghc-sdl2-mixer (package (name "ghc-sdl2-mixer") - (version "1.1.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "sdl2-mixer" version)) - (sha256 - (base32 - "1k8avyccq5l9z7bwxigim312yaancxl1sr3q6a96bcm7pnhiak0g")))) + (version "1.2.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "sdl2-mixer" version)) + (sha256 + (base32 + "16fgnxq2nmifbz3lrr7dn1qj57l5f2kzv124lya1fjaxmwk1h52q")))) (build-system haskell-build-system) (properties '((upstream-name . "sdl2-mixer"))) - (inputs - (list ghc-data-default-class - ghc-lifted-base - ghc-monad-control - ghc-sdl2 - ghc-vector - sdl2-mixer)) - (native-inputs - (list pkg-config)) - (home-page "https://hackage.haskell.org/package/sdl2-mixer") + (inputs (list ghc-data-default-class ghc-lifted-base ghc-monad-control + ghc-sdl2 ghc-vector sdl2-mixer)) + (native-inputs (list pkg-config)) + (home-page "http://hackage.haskell.org/package/sdl2-mixer") (synopsis "Bindings to SDL2 mixer") (description "This package provides Haskell bindings to @code{SDL2_mixer}.") @@ -10944,28 +10366,28 @@ (define-public ghc-securemem (define-public ghc-semialign (package (name "ghc-semialign") - (version "1.1.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "semialign" version)) - (sha256 - (base32 - "11qs4imy3cq4cx9mm6g30r6qk3rngqrmz7lkl5379gs1yvgvs44q")))) + (version "1.2.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "semialign" version)) + (sha256 + (base32 + "0ci1jpp37p1lzyjxc1bljd6zgg407qmkl9s36b50qjxf85q6j06r")))) (build-system haskell-build-system) (properties '((upstream-name . "semialign"))) - (inputs - (list ghc-these - ghc-base-compat - ghc-hashable - ghc-tagged - ghc-unordered-containers - ghc-vector - ghc-semigroupoids)) - (home-page - "https://github.com/isomorphism/these") - (synopsis - "Align and Zip type-classes from the common Semialign ancestor") + (inputs (list ghc-these + ghc-hashable + ghc-indexed-traversable + ghc-indexed-traversable-instances + ghc-tagged + ghc-unordered-containers + ghc-vector + ghc-semigroupoids)) + (arguments + `(#:cabal-revision ("3" + "0dbcdnksik508i12arh3s6bis6779lx5f1df0jkc0bp797inhd7f"))) + (home-page "https://github.com/haskellari/these") + (synopsis "Align and Zip type-classes from the common Semialign ancestor") (description "The major use of @code{These} of this is provided by the @code{align} member of @code{Semialign} class, representing a @@ -10978,31 +10400,29 @@ (define-public ghc-semialign (define-public ghc-semigroupoids (package (name "ghc-semigroupoids") - (version "5.3.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "semigroupoids" version)) - (sha256 - (base32 - "0glhqc9x8i5z3bdg23xvl2lfns95msid3h3x0jksna7i6c8j869n")))) + (version "5.3.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "semigroupoids" version)) + (sha256 + (base32 + "169pjrm7lxjxrqj5q1iyl288bx5nj8n0pf2ri1cclxccqnvcsibd")))) (build-system haskell-build-system) (properties '((upstream-name . "semigroupoids"))) - (outputs '("out" "static" "doc")) - (inputs - (list ghc-base-orphans - ghc-transformers-compat - ghc-bifunctors - ghc-comonad - ghc-contravariant - ghc-distributive - ghc-generic-deriving - ghc-hashable - ghc-tagged - ghc-unordered-containers)) - (home-page "https://github.com/ekmett/semigroupoids") + (inputs (list ghc-base-orphans + ghc-bifunctors + ghc-transformers-compat + ghc-generic-deriving + ghc-contravariant + ghc-distributive + ghc-comonad + ghc-tagged + ghc-hashable + ghc-unordered-containers)) + (home-page "http://github.com/ekmett/semigroupoids") (synopsis "Semigroupoids operations for Haskell") - (description "This library provides a wide array of (semi)groupoids and + (description + "This library provides a wide array of (semi)groupoids and operations for working with them. A @code{Semigroupoid} is a @code{Category} without the requirement of identity arrows for every object in the category. A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds. @@ -11010,26 +10430,26 @@ (define-public ghc-semigroupoids containers that can provide stronger guarantees about their contents, so versions of @code{Traversable} and @code{Foldable} that can be folded with just a @code{Semigroup} are added.") - (license license:bsd-3))) + (license license:bsd-2))) (define-public ghc-semigroups (package (name "ghc-semigroups") - (version "0.19.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "semigroups" version)) - (sha256 - (base32 - "0h1sl3i6k8csy5zkkpy65rxzds9wg577z83aaakybr3n1gcv4855")))) + (version "0.20") + (source (origin + (method url-fetch) + (uri (hackage-uri "semigroups" version)) + (sha256 + (base32 + "1qbk6scp1rzb69dy8mz26p6az5vi16g2lzwmwnfshh3br4rjwbch")))) (build-system haskell-build-system) (properties '((upstream-name . "semigroups"))) - (inputs - (list ghc-nats ghc-tagged ghc-unordered-containers ghc-hashable)) - (home-page "https://github.com/ekmett/semigroups/") + (inputs (list ghc-nats ghc-tagged ghc-hashable ghc-unordered-containers + ghc-transformers-compat)) + (home-page "http://github.com/ekmett/semigroups/") (synopsis "Semigroup operations for Haskell") - (description "This package provides semigroups for Haskell. In + (description + "This package provides semigroups for Haskell. In mathematics, a semigroup is an algebraic structure consisting of a set together with an associative binary operation. A semigroup generalizes a monoid in that there might not exist an identity element. It @@ -11082,29 +10502,28 @@ (define-public ghc-semirings (define-public ghc-serialise (package (name "ghc-serialise") - (version "0.2.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "serialise" version)) - (sha256 - (base32 - "0vp4wyxpximpx10pssfgdsir1pc23zb62fg3kj3iblpzqfrryy69")))) + (version "0.2.6.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "serialise" version)) + (sha256 + (base32 + "05m5h5vfjp4wvh6y7j2f3d4c3l6gxww2n1v38vqrjacpw641izwk")))) (build-system haskell-build-system) (properties '((upstream-name . "serialise"))) - (inputs - (list ghc-cborg - ghc-half - ghc-hashable - ghc-primitive - ghc-unordered-containers - ghc-vector)) - (native-inputs - (list ghc-quickcheck ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck - ghc-quickcheck-instances)) + (inputs (list ghc-cborg + ghc-half + ghc-hashable + ghc-primitive + ghc-strict + ghc-these + ghc-unordered-containers + ghc-vector)) + (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-hunit + ghc-tasty-quickcheck ghc-quickcheck-instances)) (arguments - `(#:cabal-revision - ("2" "1qcsp15v0swxy2qlvc40fil09zq32y3wl00y3passc2a4b4yhmr4"))) + `(#:cabal-revision ("1" + "0rlsi4jq2d1dak2fps5flcn27lywjlhvsi0x2k2lvnjqawnfb3f9"))) (home-page "https://github.com/well-typed/cborg") (synopsis "Binary serialisation library for Haskell values") (description @@ -11155,6 +10574,9 @@ (define-public ghc-setlocale "19rv89jkhq5ic7j5rzpygnmsbzim2mn8ip0m292za613q88gywir")))) (build-system haskell-build-system) (properties '((upstream-name . "setlocale"))) + (arguments + `(#:cabal-revision ("2" + "1k4idj2xl9dg5nfz128xazrrydz9mgm3bbjrc0cyby8n3c0ij9x1"))) (home-page "https://hackage.haskell.org/package/setlocale") (synopsis "Haskell bindings to setlocale") (description "This package provides Haskell bindings to the @@ -11164,27 +10586,28 @@ (define-public ghc-setlocale (define-public ghc-shakespeare (package (name "ghc-shakespeare") - (version "2.0.25") - (source - (origin - (method url-fetch) - (uri (hackage-uri "shakespeare" version)) - (sha256 - (base32 - "1fjv3yg425d87d3dih0l3ff95g5a5yp9w85m58sjara6xqivj9s4")))) - (build-system haskell-build-system) - (properties '((upstream-name . "shakespeare"))) - (inputs (list ghc-aeson + (version "2.0.30") + (source (origin + (method url-fetch) + (uri (hackage-uri "shakespeare" version)) + (sha256 + (base32 + "038yprj9yig2xbjs2pqsjzs4pl9ir2frdz9wn2pklc4kvdazx3aw")))) + (build-system haskell-build-system) + (properties '((upstream-name . "shakespeare"))) + (inputs (list ghc-aeson ghc-blaze-markup ghc-blaze-html + ghc-file-embed ghc-vector - ghc-th-lift ghc-unordered-containers - ghc-scientific)) + ghc-scientific + ghc-th-lift)) (native-inputs (list ghc-hspec ghc-hunit hspec-discover)) - (home-page "https://www.yesodweb.com/book/shakespearean-templates") + (home-page "http://www.yesodweb.com/book/shakespearean-templates") (synopsis "Family of type-safe template languages for Haskell") - (description "This Haskell package provides a family of type-safe + (description + "This Haskell package provides a family of type-safe templates with simple variable interpolation. Shakespeare templates can be used inline with a quasi-quoter or in an external file and it interpolates variables according to the type being inserted.") @@ -11193,30 +10616,26 @@ (define-public ghc-shakespeare (define-public ghc-shelly (package (name "ghc-shelly") - (version "1.9.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "shelly" version)) - (sha256 - (base32 - "1kma77gixhyciimh19p64h1ndbcrs9qhk8fgyv71iqh5q57zvday")))) + (version "1.10.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "shelly" version)) + (sha256 + (base32 + "0hgzh0rrhipir8378civ5mwvkvcsd063jm2pyx8dqngdynph0h65")))) (build-system haskell-build-system) (properties '((upstream-name . "shelly"))) - (inputs - (list ghc-unix-compat - ghc-system-filepath-bootstrap - ghc-system-fileio-bootstrap - ghc-monad-control - ghc-lifted-base - ghc-lifted-async - ghc-exceptions - ghc-enclosed-exceptions - ghc-async - ghc-transformers-base - ghc-hunit - ghc-hspec - ghc-hspec-contrib)) + (inputs (list ghc-async + ghc-enclosed-exceptions + ghc-lifted-async + ghc-lifted-base + ghc-monad-control + ghc-transformers-base + ghc-unix-compat)) + (native-inputs (list ghc-hspec ghc-hspec-contrib ghc-hunit)) + (arguments + `(#:cabal-revision ("1" + "07c1rjwvg2ldam6yaksvrr9f703b7d1rcw0482ns5yi2f7y1kczp"))) (home-page "https://github.com/yesodweb/Shelly.hs") (synopsis "Shell-like (systems) programming in Haskell") (description @@ -11227,23 +10646,30 @@ (define-public ghc-shelly (define-public ghc-silently (package (name "ghc-silently") - (version "1.2.5.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "silently" version)) - (sha256 - (base32 - "1lgs1gsr5dp0x21diqn4l03fxgai2kgdmj85gqp0iz3zykvbmjbz")))) + (version "1.2.5.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "silently" version)) + (sha256 + (base32 + "0wk3yci4r9v0vwyzylj3k07damz17jwc6n6imwqahf4lsapsz7ds")))) (build-system haskell-build-system) (properties '((upstream-name . "silently"))) - (arguments `(#:tests? #f)) ;; circular dependency with nanospec + (native-inputs (list ghc-nanospec ghc-temporary)) (home-page "https://github.com/hspec/silently") (synopsis "Prevent writing to stdout") (description "This package provides functions to prevent or capture writing to stdout and other handles.") (license license:bsd-3))) +(define-public ghc-silently-bootstrap + (package + (inherit ghc-silently) + (name "ghc-silently-bootstrap") + (arguments `(#:tests? #f)) + (native-inputs '()) + (properties '((hidden? #t))))) + (define-public ghc-simple-reflect (package (name "ghc-simple-reflect") @@ -11295,30 +10721,17 @@ (define-public ghc-simple-sendfile (define-public ghc-size-based (package (name "ghc-size-based") - (version "0.1.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "size-based" version)) - (sha256 - (base32 - "06hmlic0n73ncwlkpx49xlv09bzsrr27ncnp5byhzlknak2gd7vp")))) + (version "0.1.3.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "size-based" version)) + (sha256 + (base32 + "1x2z8iw4jgcp6xirclifjhh3rvyjy5xgqrd6lcv4gifj859sfjd2")))) (build-system haskell-build-system) (properties '((upstream-name . "size-based"))) - (inputs - (list ghc-dictionary-sharing ghc-testing-type-modifiers - ghc-template-haskell)) - (arguments - `(#:cabal-revision - ("1" "0kax1ypjyglkn6iff1x4yz12y7f2n249m95xvdhrc63hsa4xlcqv") - #:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "size-based.cabal" - (("(template-haskell)\\s+.+$" all dep) - (string-append dep "\n")))))))) - (home-page "https://hackage.haskell.org/package/size-based") + (inputs (list ghc-dictionary-sharing ghc-testing-type-modifiers)) + (home-page "http://hackage.haskell.org/package/size-based") (synopsis "Sized functors for size-based enumerations") (description "This library provides a framework for size-based enumerations.") @@ -11327,13 +10740,13 @@ (define-public ghc-size-based (define-public ghc-skylighting-core (package (name "ghc-skylighting-core") - (version "0.10.5.2") + (version "0.13.2") (source (origin (method url-fetch) (uri (hackage-uri "skylighting-core" version)) (sha256 (base32 - "0bskci0gng6nf324wna9ss4xbr1mwjkgk3mlfkr96r1m3wza5g3d")))) + "0iwzfgynj3l8rnvvrl4kg0i1n31rz15da8cf1943gw1vcfh6w585")))) (build-system haskell-build-system) (properties '((upstream-name . "skylighting-core"))) (inputs @@ -11364,20 +10777,115 @@ (define-public ghc-skylighting-core provided. Skylighting is intended to be the successor to highlighting-kate.") (license license:gpl2))) +(define-public ghc-skylighting-format-blaze-html + (package + (name "ghc-skylighting-format-blaze-html") + (version "0.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "skylighting-format-blaze-html" version)) + (sha256 + (base32 + "04zg92x1jnzv6hac6wdgksgma7gi5g82x2kdxk8r7pk9yd6rn4xi")))) + (build-system haskell-build-system) + (properties '((upstream-name . "skylighting-format-blaze-html"))) + (inputs (list ghc-skylighting-core ghc-blaze-html)) + (home-page "https://github.com/jgm/skylighting") + (synopsis "HTML formatter for skylighting syntax highlighting library") + (description + "This module allows tokens produced by skylighting-core to be rendered as HTML.") + (license license:bsd-3))) + +(define-public ghc-skylighting-format-latex + (package + (name "ghc-skylighting-format-latex") + (version "0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "skylighting-format-latex" version)) + (sha256 + (base32 + "0y7v5aifwar24i976pw32scfdywjwy2ad05ajhdf8l84nsd6rdlp")))) + (build-system haskell-build-system) + (properties '((upstream-name . "skylighting-format-latex"))) + (inputs (list ghc-skylighting-core)) + (home-page "https://github.com/jgm/skylighting") + (synopsis "LaTeX formatter for skylighting syntax highlighting library") + (description + "This module allows tokens produced by skylighting-core to be rendered as LaTeX +macros.") + (license license:bsd-3))) + +(define-public ghc-skylighting-format-context + (package + (name "ghc-skylighting-format-context") + (version "0.1.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "skylighting-format-context" version)) + (sha256 + (base32 + "1d4nf16wl2l4r627qnph09x21xwcq03r7bznqm08d4di1z241xv0")))) + (build-system haskell-build-system) + (properties '((upstream-name . "skylighting-format-context"))) + (inputs (list ghc-skylighting-core)) + (home-page "https://github.com/jgm/skylighting") + (synopsis "ConTeXt formatter for skylighting syntax highlighting library") + (description + "This module allows tokens produced by skylighting-core to be rendered as ConTeXt +commands.") + (license license:bsd-3))) + +(define-public ghc-skylighting-format-ansi + (package + (name "ghc-skylighting-format-ansi") + (version "0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "skylighting-format-ansi" version)) + (sha256 + (base32 + "16qavv10g5yqwi60axj7q595ll605vmnfjgdxyi029nd5rnaipr3")))) + (build-system haskell-build-system) + (properties '((upstream-name . "skylighting-format-ansi"))) + (inputs (list ghc-skylighting-core ghc-ansi-terminal ghc-colour)) + (home-page "https://github.com/jgm/skylighting") + (synopsis "ANSI formatter for skylighting syntax highlighting library") + (description + "This module allows tokens produced by skylighting-core to be rendered as ANSI +colored text.") + (license license:bsd-3))) + (define-public ghc-skylighting (package - (inherit ghc-skylighting-core) (name "ghc-skylighting") - (version "0.10.5.2") + (version "0.13.2") (source (origin (method url-fetch) - (uri (hackage-uri "skylighting-core" version)) + (uri (hackage-uri "skylighting" version)) (sha256 (base32 - "152ywiy7h04xjy0fdl571jwahl6c9350isqbm4p0na4cjd9cczzh")))) - (inputs - (modify-inputs (package-inputs ghc-skylighting-core) - (prepend ghc-skylighting-core))))) + "0dh4k39ddqca5px2d06ni8n9x3mifvkwd5i16077l472dwjcs879")))) + (build-system haskell-build-system) + (properties '((upstream-name . "skylighting"))) + (inputs (list ghc-skylighting-core + ghc-skylighting-format-ansi + ghc-skylighting-format-context + ghc-skylighting-format-latex + ghc-skylighting-format-blaze-html + ghc-pretty-show + ghc-blaze-html)) + (home-page "https://github.com/jgm/skylighting") + (synopsis "syntax highlighting library") + (description + "Skylighting is a syntax highlighting library with support for over one hundred +languages. It derives its tokenizers from XML syntax definitions used by KDE's +KSyntaxHighlighting framework, so any syntax supported by that framework can be +added. An optional command-line program is provided. Skylighting is intended +to be the successor to highlighting-kate. This package provides generated +syntax modules based on the KDE XML definitions provided by the +@code{skylighting-core} package.") + (license license:gpl2))) (define-public ghc-smallcheck (package @@ -11425,19 +10933,22 @@ (define-public ghc-socks (define-public ghc-sop-core (package (name "ghc-sop-core") - (version "0.5.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "sop-core" version)) - (sha256 - (base32 - "1c4xk4bw1ij4gpgy35iv08bhcxhv1siy55qnvp2xd6wcc3qnghys")))) + (version "0.5.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "sop-core" version)) + (sha256 + (base32 + "0rbj56icbaqlcxx5xwvbx4n4vmyv6cfcv7s45n1fv3drahigvgw7")))) (build-system haskell-build-system) (properties '((upstream-name . "sop-core"))) - (home-page "https://hackage.haskell.org/package/sop-core") + (arguments + `(#:cabal-revision ("1" + "1p6zyqja021gyndskn1qnj29glqr0hldyhxplnpxz06hz4xqwngz"))) + (home-page "http://hackage.haskell.org/package/sop-core") (synopsis "True Sums of Products") - (description "This package provides an implementation of + (description + "This package provides an implementation of @math{n}-ary sums and @math{n}-ary products. The module @code{Data.SOP} is the main module of this library and contains more detailed documentation. The main use case of this package is to serve as the @@ -11460,6 +10971,9 @@ (define-public ghc-special-values (properties '((upstream-name . "special-values"))) (inputs (list ghc-scientific ghc-ieee754 ghc-nats)) + (arguments + `(#:cabal-revision ("2" + "1vv5gydjd65jniifl3mnch8bzvpvdahi913gsa3kv5zijwhad699"))) (home-page "https://github.com/minad/special-values#readme") (synopsis "Typeclass providing special values") @@ -11471,24 +10985,20 @@ (define-public ghc-special-values (define-public ghc-split (package (name "ghc-split") - (version "0.2.3.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "split" version)) - (sha256 - (base32 - "0ahzdjcxw5wywr3w4msspia99k6fkckddam1m5506h4z9h8fa7r7")))) + (version "0.2.3.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "split" version)) + (sha256 + (base32 + "0n9ip49laq5jwqw0c43lhf69ii8y4lwci9j6d5bjnjim23bai2mz")))) (build-system haskell-build-system) (properties '((upstream-name . "split"))) - (arguments - `(#:cabal-revision - ("1" "06pmlvyrz4rr7rsrghpyrdypprphm9522rvnz4l3i8333n4pb304"))) - (native-inputs - (list ghc-quickcheck)) - (home-page "https://hackage.haskell.org/package/split") + (native-inputs (list ghc-quickcheck)) + (home-page "http://hackage.haskell.org/package/split") (synopsis "Combinator library for splitting lists") - (description "This package provides a collection of Haskell functions for + (description + "This package provides a collection of Haskell functions for splitting lists into parts, akin to the @code{split} function found in several mainstream languages.") (license license:bsd-3))) @@ -11496,30 +11006,36 @@ (define-public ghc-split (define-public ghc-splitmix (package (name "ghc-splitmix") - (version "0.1.0.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "splitmix" version)) - (sha256 - (base32 - "0das5n44dhlcv5i233iakx37d17kidqvhrvp6w9nd7hc015ry026")))) + (version "0.1.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "splitmix" version)) + (sha256 + (base32 + "1apck3nzzl58r0b9al7cwaqwjhhkl8q4bfrx14br2yjf741581kd")))) (build-system haskell-build-system) (properties '((upstream-name . "splitmix"))) - (native-inputs - (list ghc-async - ghc-base-compat-batteries - ghc-base-compat - ghc-hunit - ghc-math-functions - ghc-random-bootstrap - ghc-test-framework - ghc-test-framework-hunit - ghc-tf-random - ghc-vector)) - (home-page "https://hackage.haskell.org/package/splitmix") + (native-inputs (list ghc-hunit + ghc-base-compat + ghc-hunit + ghc-math-functions + ghc-test-framework + ghc-test-framework-hunit + ghc-async + ghc-base-compat-batteries + ghc-random + ghc-tf-random + ghc-vector + ghc-base-compat-batteries + ghc-hunit)) + (arguments + `(#:tests? #f ; Missing library testu01. + #:cabal-revision ("1" + "1iqlg2d4mybqwzwp67c5a1yxzd47cbp4f7mrpa6d0ckypis2akl0"))) + (home-page "http://hackage.haskell.org/package/splitmix") (synopsis "Fast and splittable pseudorandom number generator") - (description "This package provides a Pure Haskell implementation of the + (description + "This package provides a Pure Haskell implementation of the SplitMix pseudorandom number generator. SplitMix is a \"splittable\" pseudorandom number generator that is quite fast: 9 64-bit arithmetic/logical operations per 64 bits generated. SplitMix is tested @@ -11592,41 +11108,39 @@ (define-public ghc-statevar (define-public ghc-statistics (package (name "ghc-statistics") - (version "0.15.2.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "statistics" version)) - (sha256 - (base32 - "0j9awbg47fzb58k5z2wgkp6a0042j7hqrl1g6lyflrbsfswdp5n4")))) + (version "0.16.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "statistics" version)) + (sha256 + (base32 + "15yr0w25dqaqz16635qxkxvr6nj6mkjj9pl7wzw5yr3pn84xjryq")))) (build-system haskell-build-system) (properties '((upstream-name . "statistics"))) - (inputs - (list ghc-aeson - ghc-async - ghc-base-orphans - ghc-data-default-class - ghc-dense-linear-algebra - ghc-math-functions - ghc-monad-par - ghc-mwc-random - ghc-primitive - ghc-vector - ghc-vector-algorithms - ghc-vector-th-unbox - ghc-vector-binary-instances)) - (native-inputs - (list ghc-erf - ghc-ieee754 - ghc-quickcheck - ghc-tasty-expected-failure - ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck)) - (home-page "https://github.com/bos/mwc-random") + (inputs (list ghc-math-functions + ghc-mwc-random + ghc-random + ghc-aeson + ghc-async + ghc-primitive + ghc-dense-linear-algebra + ghc-parallel + ghc-vector + ghc-vector-algorithms + ghc-vector-th-unbox + ghc-vector-binary-instances + ghc-data-default-class)) + (native-inputs (list ghc-quickcheck + ghc-erf + ghc-ieee754 + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-tasty-expected-failure)) + (home-page "https://github.com/haskell/statistics") (synopsis "Haskell library of statistical types, data, and functions") - (description "This library provides a number of common functions + (description + "This library provides a number of common functions and types useful in statistics. We focus on high performance, numerical robustness, and use of good algorithms. Where possible, we provide references to the statistical literature. @@ -11756,22 +11270,21 @@ (define-public ghc-storable-complex (define-public ghc-storable-record (package (name "ghc-storable-record") - (version "0.0.5") - (source - (origin - (method url-fetch) - (uri - (hackage-uri "storable-record" version)) - (sha256 - (base32 - "17nf0bx3g169cpslf8prr5h5lvxl389m23rbsyb3kdai45fibpwf")))) + (version "0.0.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "storable-record" version)) + (sha256 + (base32 + "1d4c1ccbrpq8rnacsjib9nmxhgxk9yb1zxx1nvfavhqhv8nwq2fd")))) (build-system haskell-build-system) (properties '((upstream-name . "storable-record"))) - (inputs - (list ghc-semigroups ghc-utility-ht ghc-storablevector ghc-timeit)) - (home-page "https://hackage.haskell.org/package/storable-record") + (inputs (list ghc-quickcheck ghc-semigroups ghc-utility-ht + ghc-storablevector ghc-timeit)) + (home-page "http://code.haskell.org/~thielema/storable-record/") (synopsis "Elegant definition of Storable instances for records") - (description "With this package you can build a Storable instance of + (description + "With this package you can build a Storable instance of a record type from Storable instances of its elements in an elegant way. It does not do any magic, just a bit arithmetic to compute the right offsets, that would be otherwise done manually or by a preprocessor like @@ -11827,6 +11340,13 @@ (define-public ghc-storablevector ghc-unsafe ghc-quickcheck ghc-syb)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "storablevector.cabal" + (("bytestring >=0\\.9 && <0\\.11") "bytestring"))))))) (home-page "https://wiki.haskell.org/Storable_Vector") (synopsis "Fast, packed, strict storable arrays with a list interface") (description "This library provides fast, packed, strict storable @@ -11846,14 +11366,14 @@ (define-public ghc-storablevector (define-public ghc-streaming-commons (package (name "ghc-streaming-commons") - (version "0.2.1.1") + (version "0.2.2.5") (source (origin (method url-fetch) (uri (hackage-uri "streaming-commons" version)) (sha256 (base32 - "1lmyx3wkjsayhy5yilzvy0kf8qwmycwlk26r1d8f3cxbfhkr7s52")))) + "0157xjz8nhr65y9rm7rdf3pnjlrsgaqam7qfg7nqq91bvfdq2l6a")))) (build-system haskell-build-system) (properties '((upstream-name . "streaming-commons"))) (inputs @@ -11881,6 +11401,9 @@ (define-public ghc-strict (properties '((upstream-name . "strict"))) (inputs (list ghc-hashable ghc-these ghc-assoc)) + (arguments + `(#:cabal-revision ("4" + "0pdzqhy7z70m8gxcr54jf04qhncl1jbvwybigb8lrnxqirs5l86n"))) (home-page "https://hackage.haskell.org/package/strict") (synopsis "Strict data types and String IO") (description @@ -11973,8 +11496,8 @@ (define-public ghc-svg-builder (inputs (list ghc-blaze-builder ghc-hashable ghc-unordered-containers)) (arguments - `(#:cabal-revision - ("3" "1zc7shja5i63rn7kd9mnq2m052qhp7nh44qy8qp93dm64v9m9pi2"))) + `(#:cabal-revision ("6" + "1cprm8ya1rdid4pz1dk6692mv0kqkaxrsqaxg83bca5z4dkgqi2z"))) (home-page "https://github.com/diagrams/svg-builder.git") (synopsis "Domain-specific language for building Scalable Vector Graphics") (description "Easy-to-write domain-specific language (DSL) for @@ -11984,23 +11507,20 @@ (define-public ghc-svg-builder (define-public ghc-syb (package (name "ghc-syb") - (version "0.7.2.1") - (outputs '("out" "static" "doc")) - (source - (origin - (method url-fetch) - (uri (hackage-uri "syb" version)) - (sha256 - (base32 - "15ld5929n3lzfb5sy9nnm77x2l6i2sgsxw47jdrqcrz6fxpwc1qq")))) + (version "0.7.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "syb" version)) + (sha256 + (base32 + "1qxjjndfwz2vvpz9707banmcn6jl2v6w6zp401zxaj327fccchw1")))) (build-system haskell-build-system) (properties '((upstream-name . "syb"))) - (native-inputs - (list ghc-tasty ghc-tasty-hunit)) - (home-page - "http://www.cs.uu.nl/wiki/GenericProgramming/SYB") + (native-inputs (list ghc-tasty ghc-tasty-hunit)) + (home-page "http://www.cs.uu.nl/wiki/GenericProgramming/SYB") (synopsis "Scrap Your Boilerplate") - (description "This package contains the generics system described in the + (description + "This package contains the generics system described in the /Scrap Your Boilerplate/ papers (see @uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It defines the @code{Data} class of types permitting folding and unfolding of @@ -12208,9 +11728,10 @@ (define-public ghc-tar (build-system haskell-build-system) (properties '((upstream-name . "tar"))) (arguments - `(#:cabal-revision - ("4" "03a33nj9k62f318qgmp5pgk7i99c8cyqy5f7m7p0bwc5ni39ysfq"))) - (inputs + `(#:tests? #f ; Failed! Exception: 'TruncatedArchive' (after 4 tests): + #:cabal-revision ("5" + "15dqywn1lsyqb0nq1amj70mh1i079b7xwr02wbpcdzmdljg9c55w"))) + (native-inputs (list ghc-bytestring-handle ghc-quickcheck ghc-tasty ghc-tasty-quickcheck)) (home-page "https://hackage.haskell.org/package/tar") @@ -12305,16 +11826,16 @@ (define-public ghc-temporary-rc (define-public ghc-terminal-size (package (name "ghc-terminal-size") - (version "0.3.2.1") + (version "0.3.3") (source (origin (method url-fetch) (uri (hackage-uri "terminal-size" version)) (sha256 (base32 - "0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm")))) + "1hv0r8gr1ms258rrz602gd5kziykkxw5zlnnzz5f42r0ly7lq5wc")))) (build-system haskell-build-system) (properties '((upstream-name . "terminal-size"))) - (home-page "https://hackage.haskell.org/package/terminal-size") + (home-page "http://hackage.haskell.org/package/terminal-size") (synopsis "Get terminal window height and width") (description "Get terminal window height and width without ncurses dependency.") @@ -12323,20 +11844,18 @@ (define-public ghc-terminal-size (define-public ghc-texmath (package (name "ghc-texmath") - (version "0.12.3.2") + (version "0.12.5.4") (source (origin (method url-fetch) (uri (hackage-uri "texmath" version)) (sha256 (base32 - "1d9r3na7hmkgr0j63fs50ssll506l1wyqhw0dpap7jk0rdz8pv6n")))) + "1dn88s352y641c1vlj5j5mqwhnz6r1algkd7mx83y3fr0wp3nhlq")))) (build-system haskell-build-system) (properties '((upstream-name . "texmath"))) - (inputs - (list ghc-syb ghc-network-uri ghc-split ghc-xml ghc-pandoc-types)) - (native-inputs - (list ghc-temporary ghc-utf8-string)) - (home-page "https://github.com/jgm/texmath") + (inputs (list ghc-syb ghc-xml ghc-pandoc-types ghc-split)) + (native-inputs (list ghc-pretty-show ghc-tasty ghc-tasty-golden ghc-tagged)) + (home-page "http://github.com/jgm/texmath") (synopsis "Conversion between formats used to represent mathematics") (description "The texmath library provides functions to read and write TeX math, @@ -12345,7 +11864,7 @@ (define-public ghc-texmath native format (allowing conversion, via pandoc, to a variety of different markup formats). The TeX reader supports basic LaTeX and AMS extensions, and it can parse and apply LaTeX macros.") - (license license:gpl2+))) + (license license:gpl2))) (define-public ghc-text-binary (package @@ -12371,20 +11890,17 @@ (define-public ghc-text-binary (define-public ghc-text-manipulate (package (name "ghc-text-manipulate") - (version "0.3.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "text-manipulate" version)) - (sha256 - (base32 - "0pmzp38m3r0k6ps97b1wqplxlgvvlaid09x53jl3gxng0fwq910a")))) + (version "0.3.1.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "text-manipulate" version)) + (sha256 + (base32 + "1g06ldl6cdnyr31xlks5qm1sj44ccrdvq4bf8dk032mzfkpyyrws")))) (build-system haskell-build-system) (properties '((upstream-name . "text-manipulate"))) - (native-inputs - (list ghc-tasty ghc-tasty-hunit)) - (home-page - "https://github.com/brendanhay/text-manipulate") + (native-inputs (list ghc-tasty ghc-tasty-hunit)) + (home-page "https://github.com/brendanhay/text-manipulate") (synopsis "Case conversion, word boundary manipulation, and textual subjugation") (description @@ -12455,14 +11971,13 @@ (define-public ghc-tf-random (define-public ghc-th-abstraction (package (name "ghc-th-abstraction") - (version "0.4.3.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "th-abstraction" version)) - (sha256 - (base32 - "01nyscmjriga4fh4362b4zjad48hdv33asjkd28sj8hx3pii7fy8")))) + (version "0.4.5.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "th-abstraction" version)) + (sha256 + (base32 + "09hm0famyqsq09lal2ylnhsb31hybj8zanldi7cqncky4i7y5m80")))) (build-system haskell-build-system) (properties '((upstream-name . "th-abstraction"))) (home-page "https://github.com/glguy/th-abstraction") @@ -12477,21 +11992,17 @@ (define-public ghc-th-abstraction (define-public ghc-th-expand-syns (package (name "ghc-th-expand-syns") - (version "0.4.8.0") + (version "0.4.10.0") (source (origin (method url-fetch) (uri (hackage-uri "th-expand-syns" version)) (sha256 (base32 - "1mw0yxfbmicv0irfrcz4s6pn39za7yjd7zz09ialwym1b46624si")))) + "044h1hv4b0ihpwr9wndj55fa843cbzqp1difgj9wyy3mw925higm")))) (build-system haskell-build-system) (properties '((upstream-name . "th-expand-syns"))) - (arguments - `(#:cabal-revision - ("1" "0l30cmwm20lgjpvr3a5yxj6429s1hqahjsij8z2ap88754phd41l"))) - (inputs - (list ghc-syb ghc-th-abstraction)) - (home-page "https://hackage.haskell.org/package/th-expand-syns") + (inputs (list ghc-syb ghc-th-abstraction)) + (home-page "https://github.com/DanielSchuessler/th-expand-syns") (synopsis "Expands type synonyms in Template Haskell ASTs") (description "This package enables users to expand type synonyms in Template Haskell @@ -12512,6 +12023,9 @@ (define-public ghc-th-lift (properties '((upstream-name . "th-lift"))) (inputs (list ghc-th-abstraction)) + (arguments + `(#:cabal-revision ("2" + "1s95i774zy3q8yzk18ygdzhzky6wfcr7g55hd2g8h8lc05xzcdgi"))) (home-page "https://github.com/mboes/th-lift") (synopsis "Derive Template Haskell's Lift class for datatypes") (description @@ -12522,21 +12036,21 @@ (define-public ghc-th-lift (define-public ghc-th-lift-instances (package (name "ghc-th-lift-instances") - (version "0.1.18") - (source - (origin - (method url-fetch) - (uri (hackage-uri "th-lift-instances" version)) - (sha256 - (base32 - "09nv1zsffvv6zfz1fjzcqrla3lc350qr4i4xf7wgvzp049sprrdy")))) + (version "0.1.20") + (source (origin + (method url-fetch) + (uri (hackage-uri "th-lift-instances" version)) + (sha256 + (base32 + "0w6qc7xzyjymhh8hv72rlszh3n2xyzzamlfcl1hs9k6xbbww6czm")))) (build-system haskell-build-system) (properties '((upstream-name . "th-lift-instances"))) - (inputs - (list ghc-th-lift ghc-vector ghc-quickcheck)) - (home-page "https://github.com/bennofs/th-lift-instances/") + (inputs (list ghc-vector ghc-th-lift)) + (native-inputs (list ghc-quickcheck)) + (home-page "http://github.com/bennofs/th-lift-instances/") (synopsis "Lift instances for template-haskell for common data types") - (description "Most data types in the Haskell platform do not have Lift + (description + "Most data types in the Haskell platform do not have Lift instances. This package provides orphan instances for @code{containers}, @code{text}, @code{bytestring} and @code{vector}.") (license license:bsd-3))) @@ -12544,28 +12058,19 @@ (define-public ghc-th-lift-instances (define-public ghc-th-orphans (package (name "ghc-th-orphans") - (version "0.13.12") + (version "0.13.14") (source (origin (method url-fetch) (uri (hackage-uri "th-orphans" version)) (sha256 (base32 - "03n6qxnpxhbzyzbyrjq77d1y62dwgx39mmxfwmnc04l8pawgrxxz")))) + "0z07qcbbsj2b3j9p1qr4jvlpa7qgjfjvymkjd6vbizka1wd2mnwx")))) (build-system haskell-build-system) (properties '((upstream-name . "th-orphans"))) - (arguments - `(#:cabal-revision - ("1" "0vfz9dl5g9xwp2zmwqc5gngyvjaqj3i0s97vbcslafcqhdqw3qaj"))) - (inputs - (list ghc-th-lift - ghc-th-lift-instances - ghc-th-reify-many - ghc-th-compat - ghc-th-expand-syns - ghc-generic-deriving)) - (native-inputs - (list ghc-hspec)) - (home-page "https://hackage.haskell.org/package/th-orphans") + (inputs (list ghc-th-compat ghc-th-lift ghc-th-reify-many + ghc-generic-deriving ghc-th-lift-instances)) + (native-inputs (list ghc-hspec)) + (home-page "http://hackage.haskell.org/package/th-orphans") (synopsis "Orphan instances for TH datatypes") (description "This package provides orphan instances for Template Haskell datatypes. In particular, @@ -12590,8 +12095,8 @@ (define-public ghc-these (inputs (list ghc-hashable ghc-assoc)) (arguments - `(#:cabal-revision - ("2" "16x3am622jn97j1d9879x7j5zbjn33bkfaa0dq0xyp1fbc0s7h5x"))) + `(#:cabal-revision ("6" + "12ll5l8m482qkb8zn79vx51bqlwc89fgixf8jv33a32b4qzc3499"))) (home-page "https://github.com/isomorphism/these") (synopsis "Either-or-both data type") @@ -12625,22 +12130,21 @@ (define-public ghc-these (define-public ghc-threads (package (name "ghc-threads") - (version "0.5.1.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "threads" version)) - (sha256 - (base32 - "0bjnjhnq3km6xqk0fn1fgyz5xdw4h6lylbwwbcmkkfzwcz0c76hk")))) + (version "0.5.1.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "threads" version)) + (sha256 + (base32 + "1l226792dqlp772aaxqr3qzz8yq72702g708k16gi8lrkfhgxxp0")))) (build-system haskell-build-system) (properties '((upstream-name . "threads"))) - (native-inputs - (list ghc-concurrent-extra ghc-hunit ghc-test-framework - ghc-test-framework-hunit)) + (native-inputs (list ghc-concurrent-extra ghc-hunit ghc-test-framework + ghc-test-framework-hunit)) (home-page "https://github.com/basvandijk/threads") (synopsis "Fork threads and wait for their result") - (description "This package provides functions to fork threads and + (description + "This package provides functions to fork threads and wait for their result, whether it's an exception or a normal value. Besides waiting for the termination of a single thread this package also provides functions to wait for a group of threads to terminate. This @@ -12683,30 +12187,27 @@ (define-public ghc-th-reify-many (define-public ghc-time-compat (package (name "ghc-time-compat") - (version "1.9.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "time-compat" version)) - (sha256 - (base32 - "19p3056i6kh8lgcdsnwsh8pj80xyi23kmw9n7hmdacczs5kv49ii")))) + (version "1.9.6.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "time-compat" version)) + (sha256 + (base32 + "103b3vpn277kkccv6jv54b2wpi5c00mpb01ndl9w4y4nxc0bn1xd")))) (build-system haskell-build-system) (properties '((upstream-name . "time-compat"))) - (inputs - (list ghc-base-orphans)) - (native-inputs - (list ghc-hunit - ghc-base-compat - ghc-quickcheck - ghc-tagged - ghc-tasty - ghc-tasty-hunit - ghc-tasty-quickcheck)) + (inputs (list ghc-base-orphans ghc-hashable)) + (native-inputs (list ghc-hunit + ghc-base-compat + ghc-quickcheck + ghc-tagged + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck)) (arguments - `(#:cabal-revision - ("1" "1f6r8cyfgzpfg9nrsqbf99pi44fyds9wcmgwxb4s0zmlb5dbv1m5"))) - (home-page "https://github.com/phadej/time-compat") + `(#:cabal-revision ("4" + "1n39yfk21xz8y1xvkh01651yysk2zp5qac22l5pq2hi7scczmxaw"))) + (home-page "https://github.com/haskellari/time-compat") (synopsis "Compatibility package for time") (description "This package tries to compat as many @code{time} features as possible.") @@ -12775,52 +12276,50 @@ (define-public ghc-timeit (define-public ghc-timezone-series (package - (name "ghc-timezone-series") - (version "0.1.9") - (source - (origin - (method url-fetch) - (uri - (hackage-uri "timezone-series" version)) - (sha256 - (base32 - "1blwgnyzqn917rgqkl4dncv9whv3xmk0lav040qq0214vksmvlz5")))) - (build-system haskell-build-system) - (properties '((upstream-name . "timezone-series"))) - (home-page "https://archives.haskell.org/projects.haskell.org/time-ng/") - (synopsis "Enhanced timezone handling for Time") - (description - "This package endows @code{Data.Time}, from the time package, with several + (name "ghc-timezone-series") + (version "0.1.13") + (source (origin + (method url-fetch) + (uri (hackage-uri "timezone-series" version)) + (sha256 + (base32 + "18n6w7jxwlysq5mvb1sp1z57nyrsgn2ans642fy5rhmpwcavgvr8")))) + (build-system haskell-build-system) + (properties '((upstream-name . "timezone-series"))) + (arguments + `(#:cabal-revision ("1" + "1ak05p8z1q2nispv1xw32j7lhfmf3sfj2ibjrxpm347s37fmxnwc"))) + (home-page "http://projects.haskell.org/time-ng/") + (synopsis "Enhanced timezone handling for Time") + (description + "This package endows @code{Data.Time}, from the time package, with several data types and functions for enhanced processing of timezones. For one way to create timezone series, see the ghc-timezone-olson package.") - (license license:bsd-3))) + (license license:bsd-3))) (define-public ghc-timezone-olson (package - (name "ghc-timezone-olson") - (version "0.2.0") - (source - (origin - (method url-fetch) - (uri - (hackage-uri "timezone-olson" version)) - (sha256 - (base32 - "0b9vh27b9nz803yhd93d5z63bs370lvn4vkdajxaak9clxlw6mwg")))) - (build-system haskell-build-system) - (properties '((upstream-name . "timezone-olson"))) - (inputs - (list ghc-timezone-series ghc-extensible-exceptions)) - (home-page "https://archives.haskell.org/projects.haskell.org/time-ng/") - (synopsis "Parser and renderer for binary Olson timezone files") - (description - "A parser and renderer for binary Olson timezone files whose format + (name "ghc-timezone-olson") + (version "0.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "timezone-olson" version)) + (sha256 + (base32 + "10f5843sza2ikj2sg9fjhf5dhnhcidad86cdjmrj1y6zclkiqmdc")))) + (build-system haskell-build-system) + (properties '((upstream-name . "timezone-olson"))) + (inputs (list ghc-timezone-series ghc-extensible-exceptions)) + (home-page "http://projects.haskell.org/time-ng/") + (synopsis "Parser and renderer for binary Olson timezone files") + (description + "A parser and renderer for binary Olson timezone files whose format is specified by the tzfile(5) man page on Unix-like systems. For more information about this format, see @url{http://www.iana.org/time-zones/repository/tz-link.html}. Functions are provided for converting the parsed data into @code{TimeZoneSeries} objects from the timezone-series package.") - (license license:bsd-3))) + (license license:bsd-3))) (define-public ghc-tldr (package @@ -12938,19 +12437,20 @@ (define-public ghc-transformers-base (define-public ghc-transformers-compat (package (name "ghc-transformers-compat") - (version "0.6.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "transformers-compat" version)) - (sha256 - (base32 - "1yd936az31g9995frc84g05rrb5b7w59ajssc5183lp6wm8h4bky")))) + (version "0.7.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "transformers-compat" version)) + (sha256 + (base32 + "0slxrkxi8xa1bmi9saq9x8bz52clrf2slf877m3ckjzkr4276b5n")))) (build-system haskell-build-system) (properties '((upstream-name . "transformers-compat"))) - (home-page "https://github.com/ekmett/transformers-compat/") + (inputs (list ghc-generic-deriving)) + (home-page "http://github.com/ekmett/transformers-compat/") (synopsis "Small compatibility shim between transformers 0.3 and 0.4") - (description "This package includes backported versions of types that were + (description + "This package includes backported versions of types that were added to transformers in transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3 compatibility to run on old versions of the platform, but also need those types.") @@ -12959,42 +12459,38 @@ (define-public ghc-transformers-compat (define-public ghc-tree-diff (package (name "ghc-tree-diff") - (version "0.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "tree-diff" version)) - (sha256 - (base32 - "0bybi4qp7nj9117yza5qqgw2f7s6rk3i7q642jqd7sdn3bx5cnap")))) + (version "0.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "tree-diff" version)) + (sha256 + (base32 + "0g3lsp067dq1ydvj2im4nlfxa65g9zjmjjkv91dhjhnrklir10q0")))) (build-system haskell-build-system) (properties '((upstream-name . "tree-diff"))) - (arguments - `(#:cabal-revision - ("1" "0brlnq5ddmambidll1dn4jnjac2i44a9hd5hwp2p0rbh1s8jfyhm"))) - (inputs - (list ghc-aeson - ghc-ansi-terminal - ghc-ansi-wl-pprint - ghc-base-compat - ghc-bytestring-builder - ghc-hashable - ghc-parsers - ghc-primitive - ghc-quickcheck - ghc-scientific - ghc-semialign - ghc-strict - ghc-tagged - ghc-these - ghc-unordered-containers - ghc-uuid-types - ghc-vector)) - (native-inputs - (list ghc-trifecta ghc-tasty ghc-tasty-golden ghc-tasty-quickcheck)) + (inputs (list ghc-aeson + ghc-ansi-terminal + ghc-ansi-wl-pprint + ghc-base-compat + ghc-bytestring-builder + ghc-hashable + ghc-parsers + ghc-primitive + ghc-quickcheck + ghc-scientific + ghc-semialign + ghc-strict + ghc-tagged + ghc-these + ghc-unordered-containers + ghc-uuid-types + ghc-vector)) + (native-inputs (list ghc-tasty ghc-tasty-golden ghc-tasty-quickcheck + ghc-trifecta)) (home-page "https://github.com/phadej/tree-diff") (synopsis "Compute difference between (expression) trees") - (description "This Haskell library provides a function for computing + (description + "This Haskell library provides a function for computing the difference between (expression) trees. It also provides a way to compute the difference between arbitrary abstract datatypes (ADTs) using @code{Generics}-derivable helpers.") @@ -13003,36 +12499,37 @@ (define-public ghc-tree-diff (define-public ghc-trifecta (package (name "ghc-trifecta") - (version "2.1.1") + (version "2.1.2") (source (origin (method url-fetch) (uri (hackage-uri "trifecta" version)) (sha256 (base32 - "1lhzi0xxvilvgjy3yf3f85wfmrks562hhsnl0kg1xwji36rgwp6y")))) + "1akx8m6mgskwsbhsf90cxlqjq23jk4pwaxagvm923dpncwrlwfla")))) (build-system haskell-build-system) (properties '((upstream-name . "trifecta"))) - (inputs - (list ghc-ansi-terminal - ghc-blaze-builder - ghc-blaze-html - ghc-blaze-markup - ghc-charset - ghc-comonad - ghc-fingertree - ghc-hashable - ghc-indexed-traversable - ghc-lens - ghc-parsers - ghc-prettyprinter-ansi-terminal - ghc-prettyprinter - ghc-profunctors - ghc-reducers - ghc-unordered-containers - ghc-utf8-string)) - (native-inputs - (list ghc-quickcheck)) - (home-page "https://github.com/ekmett/trifecta/") + (inputs (list ghc-ansi-terminal + ghc-blaze-builder + ghc-blaze-html + ghc-blaze-markup + ghc-charset + ghc-comonad + ghc-fingertree + ghc-hashable + ghc-indexed-traversable + ghc-lens + ghc-parsers + ghc-prettyprinter + ghc-prettyprinter-ansi-terminal + ghc-profunctors + ghc-reducers + ghc-unordered-containers + ghc-utf8-string)) + (native-inputs (list ghc-quickcheck)) + (arguments + `(#:cabal-revision ("1" + "0a7cfbd04w3zbm234mmpib9mxar46ra5xvb62gcnbmixr7b343j9"))) + (home-page "http://github.com/ekmett/trifecta/") (synopsis "Parser combinator library with convenient diagnostics") (description "Trifecta is a modern parser combinator library for Haskell, with slicing and Clang-style colored diagnostics.") @@ -13062,34 +12559,29 @@ (define-public ghc-tuple-th (define-public ghc-turtle (package (name "ghc-turtle") - (version "1.5.22") - (source - (origin - (method url-fetch) - (uri (hackage-uri "turtle" version)) - (sha256 - (base32 - "14lf43b5rxci6p9sy1gkb715m4b1s4rl65swn2qpdqv3h2yvpi4s")))) + (version "1.5.25") + (source (origin + (method url-fetch) + (uri (hackage-uri "turtle" version)) + (sha256 + (base32 + "1hh2rbwk3m4iklk67f1l1a8shsng9qzs9132j6lpag7cgqkrmqdk")))) (build-system haskell-build-system) (properties '((upstream-name . "turtle"))) - (inputs - (list ghc-ansi-wl-pprint - ghc-async - ghc-clock - ghc-exceptions - ghc-foldl - ghc-hostname - ghc-managed - ghc-semigroups - ghc-system-filepath - ghc-system-fileio - ghc-streaming-commons - ghc-temporary - ghc-optparse-applicative - ghc-optional-args - ghc-unix-compat)) - (native-inputs - (list ghc-doctest ghc-fail)) + (inputs (list ghc-ansi-wl-pprint + ghc-async + ghc-clock + ghc-foldl + ghc-hostname + ghc-managed + ghc-system-filepath + ghc-system-fileio + ghc-streaming-commons + ghc-temporary + ghc-optparse-applicative + ghc-optional-args + ghc-unix-compat)) + (native-inputs (list ghc-doctest)) (home-page "https://hackage.haskell.org/package/turtle") (synopsis "Shell programming, Haskell-style") @@ -13119,21 +12611,24 @@ (define-public ghc-turtle (define-public ghc-typed-process (package (name "ghc-typed-process") - (version "0.2.6.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "typed-process" version)) - (sha256 - (base32 - "071mw4yv4xr5n82si33qbcqcxvcr7h56zlyd8gmsfrsdnacbq47k")))) + (version "0.2.10.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "typed-process" version)) + (sha256 + (base32 + "17h9jl7gi26v3cxb4jdcksbp755sqqp8w7303q8x8r36rmf8fdp4")))) (build-system haskell-build-system) (properties '((upstream-name . "typed-process"))) - (inputs - (list ghc-async ghc-unliftio-core)) - (native-inputs - (list ghc-base64-bytestring ghc-hspec hspec-discover ghc-temporary)) - (home-page "https://haskell-lang.org/library/typed-process") + (inputs (list ghc-async ghc-unliftio-core)) + (native-inputs (list ghc-base64-bytestring + ghc-hspec + ghc-temporary + ghc-base64-bytestring + ghc-hspec + ghc-temporary + hspec-discover)) + (home-page "https://github.com/fpco/typed-process") (synopsis "Run external processes with strong typing of streams") (description "This library provides the ability to launch and interact with external @@ -13164,21 +12659,18 @@ (define-public ghc-uglymemo (define-public ghc-unagi-chan (package (name "ghc-unagi-chan") - (version "0.4.1.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "unagi-chan" version)) - (sha256 - (base32 - "15fnk9x4fd2ryp31fjfrwm8k61m3a0qyb95m4065zc0yi0jyacp2")))) + (version "0.4.1.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "unagi-chan" version)) + (sha256 + (base32 + "1d98a6s7rydjlf2p3jv6j7wglq8ahf8kgcibji5fiy6y0ymz9mnr")))) (build-system haskell-build-system) (properties '((upstream-name . "unagi-chan"))) - (inputs - (list ghc-atomic-primops ghc-primitive)) - (arguments - `(#:tests? #f)) ; TODO: Fail. - (home-page "https://hackage.haskell.org/package/unagi-chan") + (inputs (list ghc-atomic-primops ghc-primitive)) + (arguments (list #:tests? #f)) ; counter is atomic... test: Counter broken: expecting 10000000 got 9999996 + (home-page "http://hackage.haskell.org/package/unagi-chan") (synopsis "Fast concurrent queues with a Chan-like API, and more") (description "This library provides implementations of concurrent FIFO queues (for @@ -13228,24 +12720,49 @@ (define-public ghc-unexceptionalio handled safely, this is what you're left with.") (license license:isc))) +(define-public ghc-unicode-data + (package + (name "ghc-unicode-data") + (version "0.4.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "unicode-data" version)) + (sha256 + (base32 + "1030n3h11hk1rbq0fdbpry3aclz6yz8bki2abjvbwh0rh2kdx99p")))) + (build-system haskell-build-system) + (properties '((upstream-name . "unicode-data"))) + (native-inputs (list ghc-hspec)) + (home-page "http://github.com/composewell/unicode-data") + (synopsis "Access Unicode Character Database (UCD)") + (description + "This package provides Haskell APIs to efficiently access the + (UCD). Performance is +the primary goal in the design of this package. The Haskell data structures +are generated programmatically from the UCD files.") + (license license:asl2.0))) + (define-public ghc-unicode-transforms (package (name "ghc-unicode-transforms") - (version "0.3.7.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "unicode-transforms" version)) - (sha256 - (base32 - "1010sahi4mjzqmxqlj3w73rlymbl2370x5vizjqbx7mb86kxzx4f")))) + (version "0.4.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "unicode-transforms" version)) + (sha256 + (base32 + "1z29jvli2rqkynfxni1gibl81458j7h8lrb8fg6lpnj8svhy2y1j")))) (build-system haskell-build-system) (properties '((upstream-name . "unicode-transforms"))) - (native-inputs - (list ghc-quickcheck ghc-getopt-generics ghc-split ghc-hspec)) - (home-page "https://github.com/composewell/unicode-transforms") + (inputs (list ghc-unicode-data)) + (native-inputs (list ghc-quickcheck ghc-quickcheck ghc-hspec ghc-split)) + (arguments + `(#:cabal-revision ("2" + "1imm3svpz2shilj2kmmmcyy5yd4c1mpmz5v1gvjrr98hrab2i9x7"))) + (home-page "http://github.com/composewell/unicode-transforms") (synopsis "Unicode normalization") - (description "This library provides tools for fast Unicode 12.1.0 + (description + "This library provides tools for fast Unicode 12.1.0 normalization in Haskell (normalization forms C, KC, D, and KD).") (license license:bsd-3))) @@ -13298,18 +12815,19 @@ (define-public ghc-uniplate (define-public ghc-unix-compat (package (name "ghc-unix-compat") - (version "0.5.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "unix-compat" version)) - (sha256 - (base32 - "1j75i3dj489rz60ij3nfza774mb7mw33amhdkm10dd0dxabvb4q8")))) + (version "0.5.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "unix-compat" version)) + (sha256 + (base32 + "1cd4lh2c16h7y5hzrcn5l9vir8aq2wcizwksppnagklsdsfmf942")))) (build-system haskell-build-system) (properties '((upstream-name . "unix-compat"))) - (home-page - "https://github.com/jystic/unix-compat") + (arguments + `(#:cabal-revision ("2" + "0mik6xb1jdmb2jlxlmzf0517mxfj0c1j2i4r6h5212m4q6znqqcm"))) + (home-page "http://github.com/jacobstanley/unix-compat") (synopsis "Portable POSIX-compatibility layer") (description "This package provides portable implementations of parts of the unix @@ -13320,22 +12838,19 @@ (define-public ghc-unix-compat (define-public ghc-unix-time (package (name "ghc-unix-time") - (version "0.4.7") - (source - (origin - (method url-fetch) - (uri (hackage-uri "unix-time" version)) - (sha256 - (base32 - "02fyh298lm8jsg52i3z0ikazwz477ljqjmhnqr2d88grmn5ky8qr")))) + (version "0.4.8") + (source (origin + (method url-fetch) + (uri (hackage-uri "unix-time" version)) + (sha256 + (base32 + "0hz8mi08kg84hiqnch5ycscgqmjyn1mnl5ih1bsrclyb3fhvdppy")))) (build-system haskell-build-system) (properties '((upstream-name . "unix-time"))) - (arguments - `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This - ; is weird, that should be provided by GHC 7.10.2. - (inputs - (list ghc-old-time ghc-old-locale)) - (home-page "https://hackage.haskell.org/package/unix-time") + (inputs (list ghc-old-time)) + (native-inputs (list ghc-doctest ghc-old-locale ghc-quickcheck ghc-hspec + hspec-discover)) + (home-page "http://hackage.haskell.org/package/unix-time") (synopsis "Unix time parser/formatter and utilities") (description "This library provides fast parsing and formatting utilities for Unix time in Haskell.") @@ -13344,25 +12859,22 @@ (define-public ghc-unix-time (define-public ghc-unliftio (package (name "ghc-unliftio") - (version "0.2.20") - (source - (origin - (method url-fetch) - (uri (hackage-uri "unliftio" version)) - (sha256 - (base32 - "0mbm57h7r16qd7kpglbm50qrnfjmazd70avbrl647n4jwhlrp7my")))) + (version "0.2.23.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "unliftio" version)) + (sha256 + (base32 + "1zg4ddi4z85550abw9ijycbbjg8ddig7r0vcma8ik03dxzga71id")))) (build-system haskell-build-system) (properties '((upstream-name . "unliftio"))) - (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH - (outputs '("out" "static" "doc")) - (inputs - (list ghc-async ghc-unliftio-core)) - (native-inputs (list ghc-hspec)) - (home-page "https://github.com/fpco/unliftio") + (inputs (list ghc-async ghc-safe-exceptions ghc-unliftio-core ghc-nats)) + (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover)) + (home-page "https://github.com/fpco/unliftio/tree/master/unliftio#readme") (synopsis "Provides MonadUnliftIO typecplass for unlifting monads to IO") - (description "This Haskell package provides the core @code{MonadUnliftIO} + (description + "This Haskell package provides the core @code{MonadUnliftIO} typeclass, a number of common instances, and a collection of common functions working with it.") (license license:expat))) @@ -13394,29 +12906,30 @@ (define-public ghc-unliftio-core (define-public ghc-unordered-containers (package (name "ghc-unordered-containers") - (version "0.2.14.0") - (outputs '("out" "static" "doc")) - (source - (origin - (method url-fetch) - (uri (hackage-uri "unordered-containers" version)) - (sha256 - (base32 - "0rw8kmg7xjlacmr1hcpin95abkd387awf154s9ran7zg9jllh3x1")))) + (version "0.2.19.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "unordered-containers" version)) + (sha256 + (base32 + "1li8s6qw8mgv6a7011y7hg0cn2nllv2g9sr9c1xb48nmw32vw9qv")))) (build-system haskell-build-system) (properties '((upstream-name . "unordered-containers"))) - (inputs - (list ghc-chasingbottoms - ghc-hunit - ghc-quickcheck - ghc-test-framework - ghc-test-framework-hunit - ghc-test-framework-quickcheck2 - ghc-hashable)) + (inputs (list ghc-hashable)) + (native-inputs (list ghc-chasingbottoms + ghc-hunit + ghc-quickcheck + ghc-random + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-nothunks-bootstrap)) + (arguments + `(#:cabal-revision ("1" + "0fcax3apnpxxy9maymclr6s2b4c28d3pkl3plbg0lv1mn0mh84fv"))) (home-page - "https://github.com/tibbe/unordered-containers") - (synopsis - "Efficient hashing-based container types") + "https://github.com/haskell-unordered-containers/unordered-containers") + (synopsis "Efficient hashing-based container types") (description "Efficient hashing-based container types. The containers have been optimized for performance critical use, both in terms of large data quantities @@ -13430,6 +12943,7 @@ (define-public ghc-unordered-containers-bootstrap (arguments `(#:tests? #f)) (inputs `(("ghc-hashable" ,ghc-hashable-bootstrap))) + (native-inputs '()) (properties '((hidden? #t))))) (define-public ghc-unsafe @@ -13489,16 +13003,17 @@ (define-public ghc-uri-bytestring (define-public ghc-utf8-light (package (name "ghc-utf8-light") - (version "0.4.2") + (version "0.4.4.0") (source (origin (method url-fetch) (uri (hackage-uri "utf8-light" version)) (sha256 (base32 - "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q")))) + "0415hapndlsnzvmm3bk2fl42h4vn1izky7jb3lbby3mzzzd8d1fx")))) (build-system haskell-build-system) (properties '((upstream-name . "utf8-light"))) + (native-inputs (list ghc-hspec hspec-discover)) (home-page "https://hackage.haskell.org/package/utf8-light") (synopsis "Lightweight unicode support for Haskell") @@ -13590,10 +13105,13 @@ (define-public ghc-uuid-types "1pd7xd6inkmmwjscf7pmiwqjks9y0gi1p8ahqbapvh34gadvhs5d")))) (build-system haskell-build-system) (properties '((upstream-name . "uuid-types"))) - (arguments `(#:tests? #f)) ; TODO: Wrong byteorder version? (inputs (list ghc-hashable ghc-random)) - (native-inputs (list ghc-byteorder ghc-quickcheck ghc-tasty + (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck)) + (arguments + `(#:tests? #f ; Missing GHC internal library ghc-byteorder. + #:cabal-revision ("3" + "10hpjshw6z8xnjpga47cazfdd4i27qvy4ash13lza2lmwf36k9ww"))) (home-page "https://github.com/hvr/uuid") (synopsis "Haskell type definitions for UUIDs") (description "This Haskell library contains type definitions for @@ -13605,24 +13123,28 @@ (define-public ghc-uuid-types (define-public ghc-validation (package (name "ghc-validation") - (version "1.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "validation" version)) - (sha256 - (base32 - "1dv7azpljdcf7irbnznnz31hq611bn1aj2m6ywghz3hgv835qqak")))) + (version "1.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "validation" version)) + (sha256 + (base32 + "15hhz2kj6h9zv568bvq79ymck3s3b89fpkasdavbwvyhfyjm5k8x")))) (build-system haskell-build-system) (properties '((upstream-name . "validation"))) - (inputs - (list ghc-semigroups ghc-semigroupoids ghc-assoc ghc-bifunctors - ghc-lens)) - (native-inputs - (list ghc-hedgehog ghc-hunit)) + (inputs (list ghc-assoc ghc-semigroups ghc-semigroupoids ghc-bifunctors + ghc-lens)) + (native-inputs (list ghc-hedgehog ghc-hunit)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "validation.cabal" + (("\\b(hedgehog|lens)\\s+[^,]+" all dep) + dep))))))) (home-page "https://github.com/qfpl/validation") - (synopsis - "Data-type like Either but with an accumulating Applicative") + (synopsis "Data-type like Either but with an accumulating Applicative") (description "A data-type like Either but with differing properties and type-class instances. @@ -13644,19 +13166,17 @@ (define-public ghc-validation (define-public ghc-validity (package (name "ghc-validity") - (version "0.11.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "validity" version)) - (sha256 - (base32 - "086nj5ymp4mxxfw9qjgjhd4j3z7gl2y9d89p0b7bkap5ampgdw2x")))) + (version "0.12.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "validity" version)) + (sha256 + (base32 + "1j9yswqas9dpb9mv132myfn1rky5vbh5gdvcxbb7p93k5c2y4g0w")))) (build-system haskell-build-system) (properties '((upstream-name . "validity"))) (native-inputs (list ghc-hspec hspec-discover)) - (home-page - "https://github.com/NorfairKing/validity") + (home-page "https://github.com/NorfairKing/validity#readme") (synopsis "Validity typeclass") (description "Values of custom types usually have invariants imposed upon them. This @@ -13679,6 +13199,9 @@ (define-public ghc-vault (properties '((upstream-name . "vault"))) (inputs (list ghc-unordered-containers ghc-hashable ghc-semigroups)) + (arguments + `(#:cabal-revision ("2" + "1bjwv3nv8jfhrdxa5kn3gvgxmyalpq7592bvyl7bpvcc7bbkfkf3"))) (home-page "https://github.com/HeinrichApfelmus/vault") (synopsis "Persistent store for arbitrary values") @@ -13761,6 +13284,9 @@ (define-public ghc-vector-binary-instances (list ghc-vector)) (native-inputs (list ghc-tasty ghc-tasty-quickcheck)) + (arguments + `(#:cabal-revision ("3" + "0av0k2gn90mf5ai74575bd368x73ljnr7xlkwsqmrs6zdzkw0i83"))) (home-page "https://github.com/bos/vector-binary-instances") (synopsis "Instances of Data.Binary and Data.Serialize for vector") (description "This library provides instances of @code{Binary} for the @@ -13773,27 +13299,27 @@ (define-public ghc-vector-binary-instances (define-public ghc-vector-builder (package (name "ghc-vector-builder") - (version "0.3.8.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "vector-builder" version)) - (sha256 - (base32 - "1g1zxp6xcwcq3372a5qqs44cl09a48p21m1jsys5bsampprlmcgs")))) + (version "0.3.8.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "vector-builder" version)) + (sha256 + (base32 + "0gc2n5j1ca07hd50shy7l5xybs1y720zrarzs5dj74dsdcpvmjxw")))) (build-system haskell-build-system) (properties '((upstream-name . "vector-builder"))) - (inputs (list ghc-vector ghc-semigroups ghc-base-prelude)) + (inputs (list ghc-vector)) (native-inputs (list ghc-attoparsec + ghc-quickcheck + ghc-quickcheck-instances + ghc-rerebase ghc-tasty ghc-tasty-hunit - ghc-tasty-quickcheck - ghc-hunit - ghc-quickcheck-instances - ghc-rerebase)) + ghc-tasty-quickcheck)) (home-page "https://github.com/nikita-volkov/vector-builder") (synopsis "Vector builder for Haskell") - (description "This Haskell package provides an API for constructing vectors. + (description + "This Haskell package provides an API for constructing vectors. It provides the composable @code{Builder} abstraction, which has instances of the @code{Monoid} and @code{Semigroup} classes. @@ -13805,21 +13331,24 @@ (define-public ghc-vector-builder (define-public ghc-vector-th-unbox (package (name "ghc-vector-th-unbox") - (version "0.2.1.9") - (source - (origin - (method url-fetch) - (uri (hackage-uri "vector-th-unbox" version)) - (sha256 - (base32 - "0jbzm31d91kxn8m0h6iplj54h756q6f4zzdrnb2w7rzz5zskgqyl")))) + (version "0.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "vector-th-unbox" version)) + (sha256 + (base32 + "0j81m09xxv24zziv0nanfppckzmas5184jr3npjhc9w49r3cm94a")))) (build-system haskell-build-system) (properties '((upstream-name . "vector-th-unbox"))) - (inputs - (list ghc-vector ghc-data-default)) - (home-page "https://github.com/liyang/vector-th-unbox") + (inputs (list ghc-vector)) + (native-inputs (list ghc-data-default)) + (arguments + `(#:cabal-revision ("3" + "0ki133sixq8pkfys36nl25jzdvnw40qq2bnskdmk2zyjhckdjcna"))) + (home-page "https://github.com/tsurucapital/vector-th-unbox") (synopsis "Deriver for Data.Vector.Unboxed using Template Haskell") - (description "This Haskell library provides a Template Haskell + (description + "This Haskell library provides a Template Haskell deriver for unboxed vectors, given a pair of coercion functions to and from some existing type with an Unbox instance.") (license license:bsd-3))) @@ -13860,13 +13389,8 @@ (define-public ghc-wave (build-system haskell-build-system) (properties '((upstream-name . "wave"))) (arguments - '(#:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "wave.cabal" - (("temporary.* < 1\\.3") - "temporary >= 1.1 && < 1.4"))))))) + `(#:cabal-revision ("1" + "19rxhnqhhv1qs35y723c15c8nifj8pakcrd09jlvg5271zg4qb0b"))) (inputs (list ghc-cereal ghc-data-default-class ghc-quickcheck ghc-temporary)) (native-inputs @@ -14019,40 +13543,34 @@ (define-public ghc-wl-pprint-annotated (define-public ghc-wl-pprint-text (package (name "ghc-wl-pprint-text") - (version "1.2.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "wl-pprint-text" version)) - (sha256 - (base32 - "030ckgzz14sv2c317g4j5g68hyq9xi40cmv0apwclw6sc6xgsvly")))) + (version "1.2.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "wl-pprint-text" version)) + (sha256 + (base32 + "0axivwh7bxmljxpfnccs66knxzrqck07byxmp2j737xbb26pf5cj")))) (build-system haskell-build-system) (properties '((upstream-name . "wl-pprint-text"))) - (inputs - (list ghc-base-compat)) - (home-page "https://hackage.haskell.org/package/wl-pprint-text") + (inputs (list ghc-base-compat)) + (home-page "http://hackage.haskell.org/package/wl-pprint-text") (synopsis "Wadler/Leijen Pretty Printer for Text values") - (description - "A clone of wl-pprint for use with the text library.") + (description "A clone of wl-pprint for use with the text library.") (license license:bsd-3))) (define-public ghc-word-wrap (package (name "ghc-word-wrap") - (version "0.4.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "word-wrap" version)) - (sha256 - (base32 "15rcqhg9vb7qisk9ryjnyhhfgigxksnkrczycaw2rin08wczjwpb")))) + (version "0.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "word-wrap" version)) + (sha256 + (base32 + "0i57233g4p9p8c0jf9mp3pvknwgv1lsrxm4mxjay38rw0372jpzq")))) (build-system haskell-build-system) (properties '((upstream-name . "word-wrap"))) (native-inputs (list ghc-hspec)) - (arguments - `(#:cabal-revision - ("1" "1k4w4g053vhmpp08542hrqaw81p3p35i567xgdarqmpghfrk68pp"))) (home-page "https://github.com/jtdaugherty/word-wrap/") (synopsis "Haskell library for word-wrapping text") (description @@ -14104,22 +13622,21 @@ (define-public ghc-wordexp (define-public ghc-x11 (package (name "ghc-x11") - (version "1.10.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "X11" version)) - (sha256 - (base32 "1ip207l97s8nw4daxp9s254agk8f0wibpf0prx0n695klqyn8bz1")))) + (version "1.10.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "X11" version)) + (sha256 + (base32 + "0hnj2q310a6s0h479hq8jsmywymvxdjxg13zw46mmdndynwd2jnq")))) (build-system haskell-build-system) (properties '((upstream-name . "X11"))) (arguments `(#:extra-directories ("libx11" "libxrandr" "libxinerama" "libxscrnsaver"))) - (inputs - (list libx11 libxrandr libxinerama libxscrnsaver - ghc-data-default-class)) - (home-page "https://github.com/haskell-pkg-janitors/X11") + (inputs (list libx11 libxrandr libxinerama libxscrnsaver + ghc-data-default-class)) + (home-page "https://github.com/xmonad/X11") (synopsis "Bindings to the X11 graphics library") (description "This package provides Haskell bindings to the X11 graphics library. The @@ -14129,27 +13646,25 @@ (define-public ghc-x11 (define-public ghc-x11-xft (package (name "ghc-x11-xft") - (version "0.3.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "X11-xft" version)) - (sha256 - (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf")))) - (arguments - `(#:extra-directories ("libx11" "libxft" "xorgproto"))) - (inputs - (list ghc-x11 ghc-utf8-string libx11 libxft xorgproto)) - (native-inputs - (list pkg-config)) + (version "0.3.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "X11-xft" version)) + (sha256 + (base32 + "05m988r45jiqpxqsw3vafz158whlwfcl7v8z9nnqnqz9mggd4032")))) (build-system haskell-build-system) (properties '((upstream-name . "X11-xft"))) - (home-page "https://hackage.haskell.org/package/X11-xft") + (arguments + `(#:extra-directories ("libx11" "libxft" "xorgproto"))) + (inputs (list ghc-x11 ghc-utf8-string libx11 libxft xorgproto)) + (native-inputs (list pkg-config)) + (home-page "http://hackage.haskell.org/package/X11-xft") (synopsis "Bindings to Xft") (description "Bindings to the Xft, X Free Type interface library, and some Xrender parts.") - (license license:lgpl2.1))) + (license license:bsd-3))) (define-public ghc-xdg-basedir (package @@ -14209,8 +13724,20 @@ (define-public ghc-xml-conduit ghc-data-default-class ghc-blaze-markup ghc-blaze-html)) - (native-inputs - (list ghc-doctest ghc-hspec ghc-cabal-doctest ghc-hunit)) + (native-inputs (list ghc-hspec ghc-hunit ghc-doctest hspec-discover)) + (arguments + `(#:cabal-revision ("2" + "0m6sknp9xxz8a3dhvyfpyjvxp8ph511w19j4vj1qsd6hl2pazjy6") + #:tests? #f ; Depend on non-existent doctest API. + #:phases + (modify-phases %standard-phases + ;; Tries to use non-existent doctest API. + (add-after 'unpack 'disable-doctest + (lambda _ + (with-output-to-file "Setup.hs" + (lambda _ + (display + "import Distribution.Simple\nmain = defaultMain\n")))))))) (home-page "https://github.com/snoyberg/xml") (synopsis "Utilities for dealing with XML with the conduit package") (description @@ -14240,56 +13767,56 @@ (define-public ghc-xml-types (define-public ghc-xml-hamlet (package (name "ghc-xml-hamlet") - (version "0.5.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "xml-hamlet" version)) - (sha256 - (base32 "0jrhcjy7ww59dafg857f2g2df1fw2jmbwcs1q379ph0pc5rxj3lj")))) + (version "0.5.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "xml-hamlet" version)) + (sha256 + (base32 + "109fck1626d74s00ssjffg837584wf7dxpswkil37wqqfy94mw2z")))) (build-system haskell-build-system) (properties '((upstream-name . "xml-hamlet"))) - (inputs - (list ghc-shakespeare ghc-xml-conduit)) - (native-inputs - (list ghc-hspec ghc-hunit)) - (home-page "https://www.yesodweb.com/") + (inputs (list ghc-shakespeare ghc-xml-conduit)) + (native-inputs (list ghc-hspec ghc-hunit)) + (home-page "http://www.yesodweb.com/") (synopsis "Hamlet-style quasiquoter for XML content") - (description "This package provides a type-safe tool for generating XML + (description + "This package provides a type-safe tool for generating XML code via quasi-quoting built on top of @code{ghc-shakespeare}.") (license license:bsd-3))) (define-public ghc-yaml (package (name "ghc-yaml") - (version "0.11.7.0") + (version "0.11.8.0") (source (origin (method url-fetch) (uri (hackage-uri "yaml" version)) (sha256 (base32 - "0s08kw0hqxixxripwjmz7b4yh9130dws3jaj460x8ds8q4b6khbx")))) + "1s0arllihjjqp65jbc8c1w5106i2infppsirvbsifpmpkf14w6pn")))) (build-system haskell-build-system) (properties '((upstream-name . "yaml"))) - (inputs - (list ghc-conduit - ghc-resourcet - ghc-aeson - ghc-unordered-containers - ghc-vector - ghc-attoparsec - ghc-scientific - ghc-libyaml - ghc-optparse-applicative)) - (native-inputs - (list ghc-hspec - ghc-hunit - ghc-base-compat - hspec-discover - ghc-mockery - ghc-raw-strings-qq - ghc-temporary)) - (home-page "https://github.com/snoyberg/yaml/") + (inputs (list ghc-aeson + ghc-attoparsec + ghc-conduit + ghc-libyaml + ghc-resourcet + ghc-scientific + ghc-unordered-containers + ghc-vector + ghc-optparse-applicative)) + (native-inputs (list ghc-hunit + ghc-base-compat + ghc-hspec + ghc-mockery + ghc-raw-strings-qq + ghc-temporary + hspec-discover)) + (arguments + `(#:cabal-revision ("2" + "1dix5jm3d380vjr9l6wqz54zk883kilk8rijlvjp6b13mjxwcj1l"))) + (home-page "https://github.com/snoyberg/yaml#readme") (synopsis "Parsing and rendering YAML documents") (description "This package provides a library to parse and render YAML documents.") @@ -14298,16 +13825,17 @@ (define-public ghc-yaml (define-public ghc-zip-archive (package (name "ghc-zip-archive") - (version "0.4.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "zip-archive" version)) - (sha256 - (base32 - "1cdix5mnxrbs7b2kivhdydhfzgxidd9dqlw71mdw5p21cabwkmf5")))) + (version "0.4.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "zip-archive" version)) + (sha256 + (base32 + "02b76hm76gqallij70z77xz1y981ig4biklzm0wgxran8d06n0d4")))) (build-system haskell-build-system) (properties '((upstream-name . "zip-archive"))) + (inputs (list ghc-zlib ghc-digest)) + (native-inputs (list ghc-hunit ghc-temporary which unzip)) (arguments `(#:phases (modify-phases %standard-phases @@ -14318,46 +13846,31 @@ (define-public ghc-zip-archive (path (getenv "PATH"))) (setenv "PATH" (string-append unzip "/bin:" which "/bin:" path)) #t)))))) - (inputs - (list ghc-digest ghc-temporary ghc-zlib)) - (native-inputs - (list ghc-hunit unzip which)) - (home-page "https://hackage.haskell.org/package/zip-archive") + (home-page "http://github.com/jgm/zip-archive") (synopsis "Zip archive library for Haskell") - (description "The zip-archive library provides functions for creating, + (description + "The zip-archive library provides functions for creating, modifying, and extracting files from zip archives in Haskell.") (license license:bsd-3))) (define-public ghc-zlib (package (name "ghc-zlib") - (version "0.6.2.3") - (outputs '("out" "static" "doc")) - (source - (origin - (method url-fetch) - (uri (hackage-uri "zlib" version)) - (sha256 - (base32 - "125wbayk8ifp0gp8cb52afck2ziwvqfrjzbmwmy52g6bz7fnnzw0")))) + (version "0.6.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "zlib" version)) + (sha256 + (base32 + "1nh4xsm3kgsg76jmkcphvy7hhslg9hx1s75mpsskhi2ksjd9ialy")))) (build-system haskell-build-system) (properties '((upstream-name . "zlib"))) (arguments - `(#:extra-directories ("zlib") - #:phases - (modify-phases %standard-phases - (add-before 'configure 'strip-test-framework-constraints - (lambda _ - (substitute* "zlib.cabal" - (("tasty >= 0\\.8 && < 0\\.12") "tasty") - (("tasty-hunit >= 0\\.8 && < 0\\.10") "tasty-hunit") - (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck"))))))) + `(#:extra-directories ("zlib"))) (inputs (list zlib)) - (native-inputs - (list ghc-quickcheck ghc-tasty ghc-tasty-hunit ghc-tasty-quickcheck)) - (home-page "https://hackage.haskell.org/package/zlib") - (synopsis - "Compression and decompression in the gzip and zlib formats") + (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-quickcheck)) + (home-page "http://hackage.haskell.org/package/zlib") + (synopsis "Compression and decompression in the gzip and zlib formats") (description "This package provides a pure interface for compressing and decompressing streams of data represented as lazy @code{ByteString}s. It uses the zlib C @@ -14420,20 +13933,20 @@ (define-public ghc-zstd (define-public ghc-indexed-traversable (package (name "ghc-indexed-traversable") - (version "0.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "indexed-traversable" version)) - (sha256 - (base32 "0fc18vdm1894yjbjkj9wjm27bf37ac3gvkzak677mgiw2pinmhvs")))) + (version "0.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "indexed-traversable" version)) + (sha256 + (base32 + "13b91rkhs6wcshaz3dwx6x3xjpw5z5bm2riwp78zxccqf7p5hs2i")))) (build-system haskell-build-system) (properties '((upstream-name . "indexed-traversable"))) (inputs (list ghc-generic-deriving)) (arguments - `(#:cabal-revision - ("1" "0krvp9v5dh4w2076kar48cpkk62ndqp769v2ai3b38rsa5bj6q74"))) - (home-page "https://hackage.haskell.org/package/indexed-traversable") + `(#:cabal-revision ("2" + "0l2k9jrmixkkf7qzzq0bqgvk6axaqi9sxxkpb4dgj8frmc4bg8aj"))) + (home-page "http://hackage.haskell.org/package/indexed-traversable") (synopsis "Indexed Functor, Foldable, and Traversable typeclasses") (description "This Haskell package provides three useful generalizations: @@ -14471,8 +13984,8 @@ (define-public ghc-type-equality (build-system haskell-build-system) (properties '((upstream-name . "type-equality"))) (arguments - `(#:cabal-revision - ("2" "1a3irpv5kyg3rywhmcp5fwg5irrdbdr0hrlw7asdk113nakrba7j"))) + `(#:cabal-revision ("4" + "0sajw67mmk5syhbrwx4bz82j5cjhm04n4kjl0pp3dnphxg1m5nbw"))) (home-page "https://github.com/hesselink/type-equality") (synopsis "@code{Data.Type.Equality} compatibility package") (description @@ -14491,18 +14004,16 @@ (define-public ghc-type-equality (define-public ghc-selective (package (name "ghc-selective") - (version "0.4.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "selective" version)) - (sha256 - (base32 "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l")))) + (version "0.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "selective" version)) + (sha256 + (base32 + "18wd5wn8xaw0ilx34j292l06cqn6r2rri1wvxng8ygd8141sizdh")))) (build-system haskell-build-system) (properties '((upstream-name . "selective"))) - (native-inputs - (list ghc-quickcheck ghc-tasty ghc-tasty-expected-failure - ghc-tasty-quickcheck)) + (native-inputs (list ghc-quickcheck)) (home-page "https://github.com/snowleopard/selective") (synopsis "Selective applicative functors") (description @@ -14534,6 +14045,9 @@ (define-public ghc-keys ghc-tagged ghc-transformers-compat ghc-unordered-containers)) + (arguments + `(#:cabal-revision ("2" + "1sb7ii9mhx77rhviqbmdc5r6wlimkmadxi1pyk7k3imdqcdzgjlp"))) (home-page "http://github.com/ekmett/keys/") (synopsis "Keyed functors and containers") (description @@ -14546,26 +14060,25 @@ (define-public ghc-keys (define-public ghc-pointed (package (name "ghc-pointed") - (version "5.0.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "pointed" version)) - (sha256 - (base32 "07p92y62dibys3xa59rvx52xyyr39nghl73z7hzwnksa3ry3vfmq")))) + (version "5.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "pointed" version)) + (sha256 + (base32 + "1mv06x2hscs220w4acm5jwg96vi4faky6ir9hnljfry3n2r2xix3")))) (build-system haskell-build-system) (properties '((upstream-name . "pointed"))) - (inputs - (list ghc-data-default-class - ghc-comonad - ghc-kan-extensions - ghc-semigroupoids - ghc-semigroups - ghc-tagged - ghc-transformers-compat - ghc-hashable - ghc-unordered-containers)) - (home-page "https://github.com/ekmett/pointed/") + (inputs (list ghc-data-default-class + ghc-comonad + ghc-kan-extensions + ghc-semigroupoids + ghc-semigroups + ghc-tagged + ghc-transformers-compat + ghc-hashable + ghc-unordered-containers)) + (home-page "http://github.com/ekmett/pointed/") (synopsis "Pointed and copointed data types") (description "This Haskell library provides pointed and copointed data types.") @@ -14601,17 +14114,16 @@ (define-public ghc-vector-instances (define-public ghc-th-compat (package (name "ghc-th-compat") - (version "0.1.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "th-compat" version)) - (sha256 - (base32 "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b")))) + (version "0.1.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "th-compat" version)) + (sha256 + (base32 + "1f5ssi24mnhmmi91dl5ddg2jwci6akwlznqggf56nyxl9b0pmyfq")))) (build-system haskell-build-system) (properties '((upstream-name . "th-compat"))) - (native-inputs - (list ghc-base-compat ghc-hspec hspec-discover)) + (native-inputs (list ghc-base-compat ghc-hspec hspec-discover)) (home-page "https://github.com/haskell-compat/th-compat") (synopsis "Backward- and forward-compatible @code{Quote} and @code{Code} types") @@ -14626,19 +14138,18 @@ (define-public ghc-th-compat (define-public ghc-filepattern (package (name "ghc-filepattern") - (version "0.1.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "filepattern" version)) - (sha256 - (base32 "0nznzji5haxl4ninm2a79dqf4c7fj6pc3z9gdc6wbf5h1pp14afr")))) + (version "0.1.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "filepattern" version)) + (sha256 + (base32 + "0dlnwnwhsfdkwm69z66wj5d2x9n3la55glq4fsn5rxm2kr1msi6c")))) (build-system haskell-build-system) (properties '((upstream-name . "filepattern"))) - (inputs - (list ghc-extra ghc-semigroups)) + (inputs (list ghc-extra)) (native-inputs (list ghc-quickcheck)) - (home-page "https://github.com/ndmitchell/filepattern") + (home-page "https://github.com/ndmitchell/filepattern#readme") (synopsis "File path glob-like matching") (description "This package provides Haskell library for matching files using patterns @@ -14667,19 +14178,18 @@ (define-public ghc-filepattern (define-public ghc-lib-parser-ex (package (name "ghc-lib-parser-ex") - (version "8.10.0.23") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ghc-lib-parser-ex" version)) - (sha256 - (base32 "0r5sl7hhn0cxp0b1dskx1lshplc0yka7hcvs2nh10nrj07fjd3vj")))) + (version "9.2.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "ghc-lib-parser-ex" version)) + (sha256 + (base32 + "138wkpy7qpdkp07028flab3lwq4b3mns0qcrkfrhclixlz8pi74v")))) (build-system haskell-build-system) (properties '((upstream-name . "ghc-lib-parser-ex"))) (inputs (list ghc-uniplate)) - (native-inputs - (list ghc-tasty ghc-tasty-hunit ghc-extra)) - (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex") + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-extra)) + (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme") (synopsis "Algorithms on GHC parse trees") (description "The @code{ghc-lib-parser-ex} package contains GHC API parse tree utilities.") @@ -14688,16 +14198,16 @@ (define-public ghc-lib-parser-ex (define-public ghc-lift-type (package (name "ghc-lift-type") - (version "0.1.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "lift-type" version)) - (sha256 - (base32 "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf")))) + (version "0.1.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "lift-type" version)) + (sha256 + (base32 + "039psym2ghkydk4qyycs3cxndrf85ab5hwzrqv0ajxcilqr11n0h")))) (build-system haskell-build-system) (properties '((upstream-name . "lift-type"))) - (home-page "https://github.com/parsonsmatt/lift-type") + (home-page "https://github.com/parsonsmatt/lift-type#readme") (synopsis "Lift a type from a Typeable constraint to a Template Haskell type") (description @@ -14709,19 +14219,18 @@ (define-public ghc-lift-type (define-public ghc-unicode-collation (package (name "ghc-unicode-collation") - (version "0.1.3") - (source - (origin - (method url-fetch) - (uri (hackage-uri "unicode-collation" version)) - (sha256 - (base32 "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi")))) + (version "0.1.3.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "unicode-collation" version)) + (sha256 + (base32 + "0imcdsk0qqwj31zwgpick4s2nbxlyxwa64lq6r212jd0y0hrrvvl")))) (build-system haskell-build-system) (properties '((upstream-name . "unicode-collation"))) (inputs (list ghc-th-lift-instances)) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit - ghc-unicode-transforms ghc-doctest)) + (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit + ghc-unicode-transforms ghc-doctest)) (home-page "https://github.com/jgm/unicode-collation") (synopsis "Haskell implementation of the Unicode Collation Algorithm") (description @@ -14735,32 +14244,31 @@ (define-public ghc-unicode-collation (define-public ghc-citeproc (package (name "ghc-citeproc") - (version "0.4.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "citeproc" version)) - (sha256 - (base32 "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv")))) + (version "0.8.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "citeproc" version)) + (sha256 + (base32 + "1rja6vdggmh7d40gsg2xfs9md6m1zbfddpsd27a15qyqb3530jzw")))) (build-system haskell-build-system) (properties '((upstream-name . "citeproc"))) - (inputs - (list ghc-safe - ghc-case-insensitive - ghc-vector - ghc-scientific - ghc-uniplate - ghc-xml-conduit - ghc-attoparsec - ghc-data-default - ghc-aeson - ghc-file-embed - ghc-pandoc-types - ghc-unicode-collation - ghc-base-compat - ghc-aeson-pretty)) + (inputs (list ghc-safe + ghc-case-insensitive + ghc-vector + ghc-scientific + ghc-uniplate + ghc-xml-conduit + ghc-attoparsec + ghc-data-default + ghc-aeson + ghc-file-embed + ghc-pandoc-types + ghc-unicode-collation + ghc-base-compat + ghc-aeson-pretty)) (native-inputs (list ghc-timeit ghc-diff)) - (home-page "https://hackage.haskell.org/package/citeproc") + (home-page "http://hackage.haskell.org/package/citeproc") (synopsis "Generate citations and bibliography from CSL styles") (description "@code{ghc-citeproc} parses @acronym{Citation Style Language, CSL} style files @@ -14771,18 +14279,17 @@ (define-public ghc-citeproc (define-public ghc-commonmark (package (name "ghc-commonmark") - (version "0.2.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "commonmark" version)) - (sha256 - (base32 "105szy7l4ji255fwv0kbfcy3i3a3a4197zgj6s9jb12kwbn6n0c7")))) + (version "0.2.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "commonmark" version)) + (sha256 + (base32 + "0kmjc9xgzy33kxz842mw5rdywip3lmk7v3ambrs87nakawgl42xp")))) (build-system haskell-build-system) (properties '((upstream-name . "commonmark"))) - (inputs (list ghc-unicode-transforms)) - (native-inputs - (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit)) + (inputs (list ghc-unicode-transforms ghc-unicode-data)) + (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit)) (home-page "https://github.com/jgm/commonmark-hs") (synopsis "Pure Haskell Commonmark parser") (description @@ -14805,19 +14312,17 @@ (define-public ghc-commonmark (define-public ghc-commonmark-extensions (package (name "ghc-commonmark-extensions") - (version "0.2.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "commonmark-extensions" version)) - (sha256 - (base32 "0jm6w84p2a2gyaljvnlvjjwrwnir1lss3ps53d0bd8mkvhixxrqr")))) + (version "0.2.3.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "commonmark-extensions" version)) + (sha256 + (base32 + "009yrsb2xxna73q6nnijfx5ngffaz369mildvqvn91qbrkrzq7pl")))) (build-system haskell-build-system) (properties '((upstream-name . "commonmark-extensions"))) - (inputs - (list ghc-network-uri ghc-commonmark ghc-emojis)) - (native-inputs - (list ghc-tasty ghc-tasty-hunit)) + (inputs (list ghc-network-uri ghc-commonmark ghc-emojis)) + (native-inputs (list ghc-tasty ghc-tasty-hunit)) (home-page "https://github.com/jgm/commonmark-hs") (synopsis "Extensions for @code{ghc-commonmark}") (description @@ -14829,17 +14334,16 @@ (define-public ghc-commonmark-extensions (define-public ghc-commonmark-pandoc (package (name "ghc-commonmark-pandoc") - (version "0.2.1.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "commonmark-pandoc" version)) - (sha256 - (base32 "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp")))) + (version "0.2.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "commonmark-pandoc" version)) + (sha256 + (base32 + "1dpi8zvjshab96w56qfqcys9h09f46lld8sc9q4xzb0y1p6lwmap")))) (build-system haskell-build-system) (properties '((upstream-name . "commonmark-pandoc"))) - (inputs - (list ghc-commonmark ghc-commonmark-extensions ghc-pandoc-types)) + (inputs (list ghc-commonmark ghc-commonmark-extensions ghc-pandoc-types)) (home-page "https://github.com/jgm/commonmark-hs") (synopsis "Bridge between Commonmark and Pandoc AST") (description @@ -14850,19 +14354,18 @@ (define-public ghc-commonmark-pandoc (define-public ghc-hslua-module-path (package (name "ghc-hslua-module-path") - (version "0.1.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "hslua-module-path" version)) - (sha256 - (base32 "1zxfljcn74rky26ijqmba6grpj0h9plgr47wxdaf7gcz1y8dhn68")))) + (version "1.0.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-module-path" version)) + (sha256 + (base32 + "1sy2k4mb263kg85vkf39ja84xz5kvm6z61xn62jy1swhrvvd96sr")))) (build-system haskell-build-system) (properties '((upstream-name . "hslua-module-path"))) - (inputs (list ghc-hslua)) - (native-inputs - (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua)) - (home-page "https://github.com/hslua/hslua-module-path") + (inputs (list ghc-hslua-core ghc-hslua-marshalling ghc-hslua-packaging)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua)) + (home-page "https://hslua.org/") (synopsis "Lua module to work with file paths") (description "This Haskell library provides a Lua module to work with file paths in a @@ -14872,16 +14375,22 @@ (define-public ghc-hslua-module-path (define-public ghc-template-haskell (package (name "ghc-template-haskell") - (version "2.16.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "template-haskell" version)) - (sha256 - (base32 "1nk1cv35szp80qkhbyh5gn6vn194zzl0wz186qrqdrdx3a9r9w4g")))) + (version "2.18.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "template-haskell" version)) + (sha256 + (base32 + "0mcb7psdkyx9ddwkny0ymvadrsy2dnj82d6jdm23c63zv99z3g1r")))) (build-system haskell-build-system) (properties '((upstream-name . "template-haskell"))) - (inputs (list ghc-boot-th)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "template-haskell.cabal" + (("ghc-boot-th == 9.2.1") "ghc-boot-th"))))))) (home-page "https://hackage.haskell.org/package/template-haskell") (synopsis "Support library for Template Haskell") (description @@ -14894,74 +14403,50 @@ (define-public ghc-template-haskell (define-public ghc-genvalidity-hspec (package (name "ghc-genvalidity-hspec") - (version "0.7.0.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "genvalidity-hspec" version)) - (sha256 - (base32 "0aajx07n2rznyqxb0c4pn9j2cvkzw5brz9ki4grhhigbcri3jzmv")))) + (version "1.0.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "genvalidity-hspec" version)) + (sha256 + (base32 + "00sv0mzlvny5ch7c9fnd19szqd0pjrkvi080x1i62qa5fdzs5yc4")))) (build-system haskell-build-system) (properties '((upstream-name . "genvalidity-hspec"))) - (inputs - (list ghc-quickcheck - ghc-genvalidity - ghc-genvalidity-property - ghc-hspec - hspec-discover - ghc-hspec-core - ghc-validity)) - (home-page "https://github.com/NorfairKing/validity") + (inputs (list ghc-quickcheck + ghc-genvalidity + ghc-genvalidity-property + ghc-hspec + ghc-hspec-core + ghc-validity)) + (native-inputs (list hspec-discover)) + (home-page "https://github.com/NorfairKing/validity#readme") (synopsis "Standard spec's for @code{GenValidity} instances") (description "This haskell library provides validity and validity-based testing for @code{ghc-hspec}.") (license license:expat))) -(define-public ghc-boot-th - (package - (name "ghc-boot-th") - (version "8.10.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "ghc-boot-th" version)) - (sha256 - (base32 "0vhhmsd32p7zn9vhpv4d0k0b55n2dyhzy42xblndrma617kz8gli")))) - (build-system haskell-build-system) - (properties '((upstream-name . "ghc-boot-th"))) - (home-page "https://hackage.haskell.org/package/ghc-boot-th") - (synopsis - "Shared functionality between GHC and Template Haskell") - (description - "This library contains various bits shared between GHC and Template -Haskell. This package exists to ensure that @code{template-haskell} has a -minimal set of transitive dependencies, since it is intended to be depended -upon by user code.") - (license license:bsd-3))) - (define-public ghc-binary-orphans (package (name "ghc-binary-orphans") - (version "1.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "binary-orphans" version)) - (sha256 - (base32 "0gbmn5rpvyxhw5bxjmxwld6918lslv03b2f6hshssaw1il5x86j3")))) + (version "1.0.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "binary-orphans" version)) + (sha256 + (base32 + "0b302hhjaybwbnpzrd8qmdp24g2xj2svib34zfxqqxg67j159rg2")))) (build-system haskell-build-system) (properties '((upstream-name . "binary-orphans"))) - (native-inputs - (list ghc-quickcheck ghc-quickcheck-instances ghc-tagged ghc-tasty - ghc-tasty-quickcheck)) - (arguments - `(#:cabal-revision - ("5" "1h2d37szfrcwn9rphnijn4q9l947b0wwqjs1aqmm62xkhbad7jf6"))) + (native-inputs (list ghc-onetuple + ghc-quickcheck + ghc-quickcheck-instances + ghc-tagged + ghc-tasty + ghc-tasty-quickcheck)) (home-page "https://hackage.haskell.org/package/binary-orphans") (synopsis "Compatibility package for binary") - (description - "This package provides instances defined in later versions of + (description "This package provides instances defined in later versions of @code{ghc-binary} package.") (license license:bsd-3))) @@ -14991,18 +14476,18 @@ (define-public ghc-netlink (define-public ghc-doctest-driver-gen (package (name "ghc-doctest-driver-gen") - (version "0.3.0.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "doctest-driver-gen" version)) - (sha256 - (base32 "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a")))) + (version "0.3.0.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "doctest-driver-gen" version)) + (sha256 + (base32 + "0a4jdg4mzhdgfal7jp60yrlv63iv7d8f7nxc9aqvrl93mairny8l")))) (build-system haskell-build-system) (properties '((upstream-name . "doctest-driver-gen"))) - (arguments `(#:tests? #f)) ; TODO: Fail to open shared library. (native-inputs (list ghc-doctest)) - (home-page "https://github.com/Hexirp/doctest-driver-gen") + (arguments (list #:tests? #f)) ;; XXX: doctest-driver-gen: error while loading shared libraries: libHSdoctest-driver-gen-0.3.0.6-3WJHXaMfGwJFKjjgcmC868-ghc9.2.5.so: cannot open shared object file: No such file or directory + (home-page "https://github.com/Hexirp/doctest-driver-gen#readme") (synopsis "Generate driver file for Doctest's Cabal integration") (description "@code{ghc-doctest-driver-gen} is a Doctest's driver file generator. It @@ -15012,17 +14497,19 @@ (define-public ghc-doctest-driver-gen (define-public ghc-template-haskell-compat-v0208 (package (name "ghc-template-haskell-compat-v0208") - (version "0.1.6") - (source - (origin - (method url-fetch) - (uri (hackage-uri "template-haskell-compat-v0208" version)) - (sha256 - (base32 "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8")))) + (version "0.1.9.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "template-haskell-compat-v0208" version)) + (sha256 + (base32 + "1z87rla4vcbghdrvjkay59b686f0by02102vwrcayn4vbwzn4am1")))) (build-system haskell-build-system) (properties '((upstream-name . "template-haskell-compat-v0208"))) - (home-page "https://github.com/nikita-volkov/template-haskell-compat-v0208") - (synopsis "Backwards compatibility layer for Template Haskell newer than 2.8") + (home-page + "https://github.com/nikita-volkov/template-haskell-compat-v0208") + (synopsis + "Backwards compatibility layer for Template Haskell newer than 2.8") (description "This package provides a backwards compatibility layer for Template Haskell newer than 2.8.") @@ -15084,28 +14571,26 @@ (define-public ghc-blaze-textual (define-public ghc-mysql-simple (package (name "ghc-mysql-simple") - (version "0.4.7") - (source - (origin - (method url-fetch) - (uri (hackage-uri "mysql-simple" version)) - (sha256 - (base32 "1mhmszpq64h8kxr20iaj1laq46wr2gaqc8xxq1k821i7jfxfld6j")))) + (version "0.4.9") + (source (origin + (method url-fetch) + (uri (hackage-uri "mysql-simple" version)) + (sha256 + (base32 + "0hwv1hlr65m5l2zrrj5zmvrjz9y2814jy05l17l5jb4j4j5xw3z2")))) (build-system haskell-build-system) (properties '((upstream-name . "mysql-simple"))) - (arguments `(#:tests? #f)) ; TODO: Fails to connect to server. - (inputs - (list ghc-attoparsec - ghc-base16-bytestring - ghc-blaze-builder - ghc-mysql - ghc-pcre-light - ghc-old-locale - ghc-blaze-textual - ghc-vector - openssl - zlib)) + (inputs (list ghc-attoparsec + ghc-base16-bytestring + ghc-blaze-builder + ghc-mysql + ghc-pcre-light + ghc-old-locale + ghc-vector + openssl + zlib)) (native-inputs (list ghc-hspec)) + (arguments (list #:tests? #f)) ; Fail to build. (home-page "https://github.com/paul-rouse/mysql-simple") (synopsis "Mid-level MySQL client library") (description @@ -15116,27 +14601,25 @@ (define-public ghc-mysql-simple (define-public ghc-persistent-qq (package (name "ghc-persistent-qq") - (version "2.12.0.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "persistent-qq" version)) - (sha256 - (base32 "1dvniapxjaw2vmdqd5cplwxdxiy2l6z6gns8gp3ci3rn3xp0pf6p")))) + (version "2.12.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "persistent-qq" version)) + (sha256 + (base32 + "0pzlhwl4h9q358zc6d0m5zv0ii2yhf2lzw0a3v2spfc1ch4a014a")))) (build-system haskell-build-system) (properties '((upstream-name . "persistent-qq"))) - (inputs - (list ghc-haskell-src-meta ghc-persistent)) - (native-inputs - (list ghc-hunit - ghc-aeson - ghc-fast-logger - ghc-hspec - ghc-monad-logger - ghc-persistent-sqlite - ghc-resourcet - ghc-unliftio)) - (home-page "https://github.com/yesodweb/persistent") + (inputs (list ghc-haskell-src-meta ghc-persistent)) + (native-inputs (list ghc-hunit + ghc-aeson + ghc-fast-logger + ghc-hspec + ghc-monad-logger + ghc-persistent-sqlite + ghc-resourcet + ghc-unliftio)) + (home-page "https://github.com/yesodweb/persistent#readme") (synopsis "Quasi-quoter for raw SQL for @code{ghc-persistent}") (description "This package provides a quasi-quoter for raw @acronym{SQL, Structured Query @@ -15146,39 +14629,36 @@ (define-public ghc-persistent-qq (define-public ghc-persistent-mysql (package (name "ghc-persistent-mysql") - (version "2.13.0.2") - (source - (origin - (method url-fetch) - (uri (hackage-uri "persistent-mysql" version)) - (sha256 - (base32 "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732")))) + (version "2.13.1.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "persistent-mysql" version)) + (sha256 + (base32 + "0fm6agqwawwraw6l6kxm8lq40pm5pnjg093f574a7sdf648q21yc")))) (build-system haskell-build-system) (properties '((upstream-name . "persistent-mysql"))) - (arguments `(#:tests? #f)) ; TODO: Fails to import MaybeFieldDefsTest. - (inputs - (list ghc-persistent - ghc-aeson - ghc-blaze-builder - ghc-conduit - ghc-monad-logger - ghc-mysql - ghc-mysql-simple - ghc-resourcet - ghc-resource-pool - ghc-unliftio-core - openssl - zlib)) - (native-inputs - (list ghc-fast-logger - ghc-hspec - ghc-http-api-data - ghc-hunit - ghc-path-pieces - ghc-persistent-qq - ghc-persistent-test - ghc-quickcheck - ghc-quickcheck-instances)) + (inputs (list ghc-persistent + ghc-aeson + ghc-blaze-builder + ghc-conduit + ghc-monad-logger + ghc-mysql + ghc-mysql-simple + ghc-resourcet + ghc-resource-pool + ghc-unliftio-core + openssl)) + (native-inputs (list ghc-fast-logger + ghc-hspec + ghc-http-api-data + ghc-hunit + ghc-path-pieces + ghc-persistent-qq + ghc-persistent-test + ghc-quickcheck + ghc-quickcheck-instances)) + (arguments (list #:tests? #f)) ; Fails to connect to server. (home-page "http://www.yesodweb.com/book/persistent") (synopsis "Backend for the @code{ghc-persistent} library using MySQL database server") @@ -15246,8 +14726,8 @@ (define-public ghc-postgresql-libpq (build-system haskell-build-system) (properties '((upstream-name . "postgresql-libpq"))) (arguments - `(#:cabal-revision - ("1" "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2"))) + `(#:cabal-revision ("3" + "02cj493a2qxl5hddiq0579079s398hdqqy164pig6d61nl7q66cs"))) (inputs (list postgresql)) (home-page "https://github.com/haskellari/postgresql-libpq") (synopsis "Low-level bindings to @code{libpq}") @@ -15293,8 +14773,8 @@ (define-public ghc-postgresql-simple ghc-tasty-golden ghc-tasty-hunit)) (arguments - `(#:cabal-revision - ("2" "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv"))) + `(#:cabal-revision ("8" + "1qavb3qs1g307pc19k9y3yvqp0c1srwsplijvayn9ldp0bxdy6q8"))) (home-page "https://hackage.haskell.org/package/postgresql-simple") (synopsis "Mid-Level PostgreSQL client library") (description @@ -15305,44 +14785,43 @@ (define-public ghc-postgresql-simple (define-public ghc-persistent-postgresql (package (name "ghc-persistent-postgresql") - (version "2.13.2.1") - (source - (origin - (method url-fetch) - (uri (hackage-uri "persistent-postgresql" version)) - (sha256 - (base32 "07pnr8m0nk43jaz6l293lzx4ivyqgnw94fjypazzm008b4irh7ir")))) + (version "2.13.5.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "persistent-postgresql" version)) + (sha256 + (base32 + "1q9hy49nfrb3azgz5rjz235d7scy27l5axkih7crskaa04hf4k8d")))) (build-system haskell-build-system) (properties '((upstream-name . "persistent-postgresql"))) - (arguments `(#:tests? #f)) ; TODO: Cannot import MaybeFieldDefsTest. - (inputs - (list ghc-persistent - ghc-aeson - ghc-attoparsec - ghc-blaze-builder - ghc-conduit - ghc-monad-logger - ghc-postgresql-simple - ghc-postgresql-libpq - ghc-resourcet - ghc-resource-pool - ghc-string-conversions - ghc-unliftio-core - ghc-unliftio)) - (native-inputs - (list ghc-persistent-qq - ghc-persistent-test - ghc-fast-logger - ghc-hunit - ghc-hspec - ghc-hspec-expectations - ghc-hspec-expectations-lifted - ghc-quickcheck - ghc-quickcheck-instances - ghc-path-pieces - ghc-http-api-data - ghc-unordered-containers - ghc-vector)) + (inputs (list ghc-persistent + ghc-aeson + ghc-attoparsec + ghc-blaze-builder + ghc-conduit + ghc-monad-logger + ghc-postgresql-simple + ghc-postgresql-libpq + ghc-resourcet + ghc-resource-pool + ghc-string-conversions + ghc-unliftio-core + ghc-vault + ghc-unliftio)) + (native-inputs (list ghc-persistent-qq + ghc-persistent-test + ghc-fast-logger + ghc-hunit + ghc-hspec + ghc-hspec-expectations + ghc-hspec-expectations-lifted + ghc-quickcheck + ghc-quickcheck-instances + ghc-path-pieces + ghc-http-api-data + ghc-unordered-containers + ghc-vector)) + (arguments (list #:tests? #f)) ; Fails to connect to server. (home-page "http://www.yesodweb.com/book/persistent") (synopsis "Backend for the @code{ghc-persistent library} using Postgresql") (description @@ -15393,22 +14872,21 @@ (define-public ghc-filelock (define-public ghc-hsyaml-aeson (package (name "ghc-hsyaml-aeson") - (version "0.2.0.0") - (source - (origin - (method url-fetch) - (uri (hackage-uri "HsYAML-aeson" version)) - (sha256 - (base32 "12sxww260pc0bbpiyirm7911haxhljdi2f08a9ddpbgw8d5n7ffg")))) + (version "0.2.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "HsYAML-aeson" version)) + (sha256 + (base32 + "139hqd07hkr8ykvrgmcshh9f3vp9dnrj6ks5nl8hgrpi990jsy5r")))) (build-system haskell-build-system) (properties '((upstream-name . "HsYAML-aeson"))) - (inputs - (list ghc-hsyaml ghc-aeson ghc-scientific ghc-unordered-containers - ghc-vector)) + (inputs (list ghc-hsyaml ghc-aeson ghc-scientific ghc-unordered-containers + ghc-vector)) (arguments - `(#:cabal-revision - ("3" "0vhdndyj5f07vvvnssn5ybdja5wmaydq0n2lfpihvdg4dkhczrx2"))) - (home-page "https://hackage.haskell.org/package/HsYAML-aeson") + `(#:cabal-revision ("5" + "06v8vkn58d67yx4v59rhvxpc0sjrpi6k8krvjrvbyl0fn0v0jd14"))) + (home-page "http://hackage.haskell.org/package/HsYAML-aeson") (synopsis "JSON to YAML adapter") (description "The @uref{https://yaml.org/spec/1.2/spec.html, YAML 1.2} format provides @@ -15443,8 +14921,8 @@ (define-public ghc-lukko ghc-tasty-hunit ghc-temporary)) (arguments - `(#:cabal-revision - ("1" "0mmq1q82mrbayiij0p8wdnkf0j8drmq1iibg8kn4cak3nrn9pd1d"))) + `(#:cabal-revision ("3" + "1a6spmbiv3ias40sjrnsxfgr1d5mwg039a2q7113zb7i9n6c1m7g"))) (home-page "https://hackage.haskell.org/package/lukko") (synopsis "File locking") (description @@ -15465,15 +14943,16 @@ (define-public ghc-lukko (define-public ghc-dec (package (name "ghc-dec") - (version "0.0.4") - (source - (origin - (method url-fetch) - (uri (hackage-uri "dec" version)) - (sha256 - (base32 "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc")))) + (version "0.0.5") + (source (origin + (method url-fetch) + (uri (hackage-uri "dec" version)) + (sha256 + (base32 + "126z70ij9hhy8pajw0d5fl0hrppy5sh22j8nkx46i0g6qz3l7071")))) (build-system haskell-build-system) (properties '((upstream-name . "dec"))) + (inputs (list ghc-boring)) (home-page "https://github.com/phadej/vec") (synopsis "Decidable propositions") (description @@ -15539,27 +15018,1265 @@ (define-public ghc-open-browser (define-public ghc-singleton-bool (package (name "ghc-singleton-bool") - (version "0.1.5") - (source - (origin - (method url-fetch) - (uri (hackage-uri "singleton-bool" version)) - (sha256 - (base32 "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0")))) + (version "0.1.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "singleton-bool" version)) + (sha256 + (base32 + "1pc34dbzx5g3vw5w03zifvqva3whyvxzfy3yh78qkpd05f0g98sw")))) (build-system haskell-build-system) (properties '((upstream-name . "singleton-bool"))) - (inputs (list ghc-dec)) + (inputs (list ghc-boring ghc-dec ghc-some)) (arguments - `(#:cabal-revision - ("3" "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x"))) - (home-page "https://github.com/phadej/singleton-bool") + `(#:cabal-revision ("2" + "1l4nx664awgwzk3ih5idsgnj220jqdr1c55241xjv7fz7lwyhh5r"))) + (home-page "https://github.com/phadej/singleton-bool#readme") (synopsis "Type-level booleans") + (description "This package provides Type-level booleans.") + (license license:bsd-3))) + +(define-public ghc-breakpoint + (package + (name "ghc-breakpoint") + (version "0.1.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "breakpoint" version)) + (sha256 + (base32 + "1hk9mjijxvqjzcfqllzi53rmxiyggbxash05jbb742wrq832h2xw")))) + (build-system haskell-build-system) + (properties '((upstream-name . "breakpoint"))) + (inputs (list ghc-pretty-simple ghc-ansi-terminal)) + (native-inputs (list ghc-tasty ghc-tasty-hunit)) + (home-page "http://hackage.haskell.org/package/breakpoint") + (synopsis "Set breakpoints using a GHC plugin") (description - "This package provides Type-level booleans.") + "This package provides a plugin that allows you to set breakpoints for debugging +purposes. See the +[README](https://github.com/aaronallen8455/breakpoint#breakpoint) for details.") + (license license:expat))) + +(define-public ghc-githash + (package + (name "ghc-githash") + (version "0.1.6.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "githash" version)) + (sha256 + (base32 + "06zg1rif1rcxni1vacmr2bh1nbm6i62rjbikfr4xsyzq1sv7kfpw")))) + (build-system haskell-build-system) + (properties '((upstream-name . "githash"))) + (inputs (list ghc-th-compat git)) + (native-inputs (list ghc-hspec ghc-temporary ghc-unliftio hspec-discover)) + (arguments + (list + #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'patch-git-path + (lambda _ + (substitute* "src/GitHash.hs" + (("\"git\"") (string-append "\"" #$git "/bin/git\"")))))))) + (home-page "https://github.com/snoyberg/githash#readme") + (synopsis "Compile git revision info into Haskell projects") + (description "Please see the README and documentation at +") (license license:bsd-3))) -;;; -;;; Avoid adding new packages to the end of this file. To reduce the chances -;;; of a merge conflict, place them above by existing packages with similar -;;; functionality or similar names. -;;; +(define-public ghc-nothunks + (package + (name "ghc-nothunks") + (version "0.1.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "nothunks" version)) + (sha256 + (base32 + "0lqfhnyxhmhajvsgmz5h428pb5zrdy9zvbc5inzhd83cv31yk4f1")))) + (build-system haskell-build-system) + (properties '((upstream-name . "nothunks"))) + (inputs (list ghc-vector)) + ;(native-inputs (list ghc-hedgehog ghc-random ghc-tasty ghc-tasty-hedgehog)) + (arguments (list #:tests? #f)) ; Fail to compile. + (home-page "http://hackage.haskell.org/package/nothunks") + (synopsis "Examine values for unexpected thunks") + (description + "Long lived application data typically should not contain any thunks. This +library can be used to examine values for unexpected thunks, which can then be +used in assertions. This can be invaluable in avoiding memory leaks, or +tracking down existing ones.") + (license license:expat))) + +(define-public ghc-nothunks-bootstrap + (package + (inherit ghc-nothunks) + (name "ghc-nothunks-bootstrap") + (arguments `(#:tests? #f)) + (native-inputs '()) + (properties '((hidden? #t))))) + +(define-public ghc-barbies + (package + (name "ghc-barbies") + (version "2.0.4.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "barbies" version)) + (sha256 + (base32 + "0v8bckxi58fkqgf1i1xd3100wp792pzd319xlfvmmw8z0ii1g872")))) + (build-system haskell-build-system) + (properties '((upstream-name . "barbies"))) + (inputs (list ghc-distributive)) + (native-inputs (list ghc-quickcheck + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck + ghc-quickcheck + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck)) + (home-page "https://github.com/jcpetruzza/barbies#readme") + (synopsis "Classes for working with types that can change clothes.") + (description + "Types that are parametric on a functor are like Barbies that have an outfit for +each role. This package provides the basic abstractions to work with them +comfortably.") + (license license:bsd-3))) + +(define-public ghc-onetuple + (package + (name "ghc-onetuple") + (version "0.3.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "OneTuple" version)) + (sha256 + (base32 + "1vry21z449ph9k61l5zm7mfmdwkwszxqdlawlhvwrd1gsn13d1cq")))) + (build-system haskell-build-system) + (properties '((upstream-name . "OneTuple"))) + (native-inputs (list ghc-hashable)) + (arguments + `(#:cabal-revision ("3" + "0g4siv8s6dlrdsivap2qy6ig08y5bjbs93jk192zmgkp8iscncpw"))) + (home-page "http://hackage.haskell.org/package/OneTuple") + (synopsis "Singleton Tuple") + (description + "This package is a compatibility package for a singleton data type . > data Solo +a = Solo a . Note: it's not a @@newtype@@ . @@Solo@@ is available in +@@base-4.16@@ (GHC-9.2).") + (license license:bsd-3))) + +(define-public ghc-indexed-traversable-instances + (package + (name "ghc-indexed-traversable-instances") + (version "0.1.1.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "indexed-traversable-instances" version)) + (sha256 + (base32 + "1c60vhf47y8ln33scyvwiffg24dvhm4aavya624vbqjr7l3fapl9")))) + (build-system haskell-build-system) + (properties '((upstream-name . "indexed-traversable-instances"))) + (inputs (list ghc-indexed-traversable ghc-onetuple ghc-tagged + ghc-unordered-containers ghc-vector)) + (native-inputs (list ghc-quickcheck ghc-quickcheck-instances ghc-tasty + ghc-tasty-quickcheck)) + (home-page + "http://hackage.haskell.org/package/indexed-traversable-instances") + (synopsis + "More instances of FunctorWithIndex, FoldableWithIndex, TraversableWithIndex") + (description + "This package provides extra instances for type-classes in the +[indexed-traversable](https://hackage.haskell.org/package/indexed-traversable) +package. . The intention is to keep this package minimal; it provides instances +that formely existed in @@lens@@ or @@optics-extra@@. We recommend putting +other instances directly into their defining packages. The +@@indexed-traversable@@ package is light, having only GHC boot libraries as its +dependencies.") + (license license:bsd-2))) + +(define-public ghc-witherable + (package + (name "ghc-witherable") + (version "0.4.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "witherable" version)) + (sha256 + (base32 + "0121ic4xkv3k568j23zp22a5lrv0k11h94fq7cbijd18fjr2n3br")))) + (build-system haskell-build-system) + (properties '((upstream-name . "witherable"))) + (inputs (list ghc-base-orphans + ghc-hashable + ghc-unordered-containers + ghc-vector + ghc-indexed-traversable + ghc-indexed-traversable-instances)) + (native-inputs (list ghc-quickcheck ghc-quickcheck-instances ghc-tasty + ghc-tasty-quickcheck)) + (arguments + `(#:cabal-revision ("3" + "1f2bvl41by904lnr0dk6qgasqwadq2w48l7fj51bp2h8bqbkdjyc"))) + (home-page "https://github.com/fumieval/witherable") + (synopsis "filterable traversable") + (description + "This package provides a stronger variant of `traverse` which can remove elements +and generalised mapMaybe, catMaybes, filter") + (license license:bsd-3))) + +(define-public ghc-hspec-discover + (package + (name "ghc-hspec-discover") + (version "2.9.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "hspec-discover" version)) + (sha256 + (base32 + "0536kdxjw6p8b6gcwvmr22jbmb6cgzbddi0fkd01b2m847z37sb5")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hspec-discover"))) + (native-inputs (list ghc-quickcheck ghc-hspec-meta ghc-mockery)) + (home-page "http://hspec.github.io/") + (synopsis "Automatically discover and run Hspec tests") + (description "Automatically discover and run Hspec tests . +") + (license license:expat))) + +(define-public ghc-doctest-parallel + (package + (name "ghc-doctest-parallel") + (version "0.2.6") + (source (origin + (method url-fetch) + (uri (hackage-uri "doctest-parallel" version)) + (sha256 + (base32 + "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7")))) + (build-system haskell-build-system) + (properties '((upstream-name . "doctest-parallel"))) + (inputs (list ghc-glob + ghc-base-compat + ghc-code-page + ghc-extra + ghc-paths + ghc-random + ghc-syb + ghc-unordered-containers)) + (native-inputs (list ghc-hunit + ghc-quickcheck + ghc-hspec + ghc-hspec-core + ghc-hspec-discover + ghc-mockery + ghc-setenv + ghc-silently + ghc-stringbuilder)) + (arguments + `(#:haddock? #f)) ; Setup.lhs: internal error when calculating transitive package dependencies. + (home-page "https://github.com/martijnbastiaan/doctest-parallel#readme") + (synopsis "Test interactive Haskell examples") + (description + "The doctest program checks examples in source code comments. It is modeled +after doctest for Python (). . +Documentation is at +.") + (license license:expat))) + +(define-public ghc-pcg-random + (package + (name "ghc-pcg-random") + (version "0.1.3.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "pcg-random" version)) + (sha256 + (base32 + "1l6jq5nvmg1ygk7i7g50s47p6qkh74p9avl1wbcxdl5m85lc5j76")))) + (build-system haskell-build-system) + (properties '((upstream-name . "pcg-random"))) + (inputs (list ghc-primitive ghc-random ghc-entropy)) + (native-inputs (list ghc-doctest)) + (arguments + `(#:tests? #f ; Could not find module ‘Build_doctests’ + #:phases + (modify-phases %standard-phases + ;; Tries to use non-existent doctest API. + (add-after 'unpack 'disable-doctest + (lambda _ + (with-output-to-file "Setup.hs" + (lambda _ + (display + "import Distribution.Simple\nmain = defaultMain\n")))))))) + (home-page "http://github.com/cchalmers/pcg-random") + (synopsis "Haskell bindings to the PCG random number generator.") + (description + "PCG is a family of simple fast space-efficient statistically good algorithms for +random number generation. Unlike many general-purpose RNGs, they are also hard +to predict. . This library implements bindings to the standard C +implementation. This includes the standard, unique, fast and single variants in +the pcg family. There is a pure implementation that can be used as a generator +with the random package as well as a faster primitive api that includes +functions for generating common types. . The generators in this module are +suitable for use in parallel but make sure threads don't share the same +generator or things will go horribly wrong.") + (license license:bsd-3))) + +(define-public ghc-random-bytestring + (package + (name "ghc-random-bytestring") + (version "0.1.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "random-bytestring" version)) + (sha256 + (base32 + "0f4n41gqxxggadysvx3vg2iq89z7i7692ccrfmiajq73lbp6y34j")))) + (build-system haskell-build-system) + (properties '((upstream-name . "random-bytestring"))) + (inputs (list ghc-mwc-random ghc-nats ghc-pcg-random)) + (home-page "https://www.github.com/larskuhtz/random-bytestring") + (synopsis "Efficient generation of random bytestrings") + (description + "__This package is deprecated__. Please, use genByteString from the [random +package (version >=1.2)](https://hackage.haskell.org/package/random) instead. . +Efficient generation of random bytestrings. The implementation populates +uninitialized memory with uniformily distributed random 64 bit words (and 8 bit +words for remaining bytes at the end of the bytestring). . Random words are +generated using the PRNG from the +[mwc-random](https://hackage.haskell.org/package/mwc-random) package or the +[pcg-random](https://hackage.haskell.org/package/pcg-random) package. It is +also possible to use a custom PRNG by providing an instance for the RandomWords +type class and using the function generate from the module +\"Data.ByteString.Random.Internal\". . The generated byte strings are suitable +for statistical applications. They are /not/ suitable for cryptographic +applications. . +![benchmarks](https://hackage.haskell.org/package/random-bytestring-0.1.3.2/src/benchmarks.png) +. ![detailed +benchmarks](https://hackage.haskell.org/package/random-bytestring-0.1.3.2/src/benchmarks-details.png)") + (license license:expat))) + +(define-public ghc-base64 + (package + (name "ghc-base64") + (version "0.4.2.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "base64" version)) + (sha256 + (base32 + "119mpqcv1rwkhwm69ga2b4f7hr825fa5wfm1w3i1szmhzh52s2k4")))) + (build-system haskell-build-system) + (properties '((upstream-name . "base64"))) + (inputs (list ghc-text-short)) + (native-inputs (list ghc-base64-bytestring + ghc-quickcheck + ghc-random-bytestring + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck)) + (arguments + `(#:cabal-revision ("2" + "0cz3zzz9k490w9nfn4hpgdw4zx4w70fwqrwsfx8svcwqssqibqw3"))) + (home-page "https://github.com/emilypi/base64") + (synopsis "A modern RFC 4648-compliant Base64 library") + (description + "RFC 4648-compliant Base64 with an eye towards performance and modernity +(additional support for RFC 7049 standards)") + (license license:bsd-3))) + +(define-public ghc-ordered-containers + (package + (name "ghc-ordered-containers") + (version "0.2.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "ordered-containers" version)) + (sha256 + (base32 + "18w1dasny6xffbjlvmz9861l2xbkqlg2w5qxz9kw6frgfl2rg11n")))) + (build-system haskell-build-system) + (properties '((upstream-name . "ordered-containers"))) + (home-page "http://hackage.haskell.org/package/ordered-containers") + (synopsis + "Set- and Map-like types that remember the order elements were inserted") + (description "") + (license license:bsd-3))) + +(define-public ghc-cabal-syntax + (package + (name "ghc-cabal-syntax") + (version "3.6.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "Cabal-syntax" version)) + (sha256 + (base32 + "0lcj4g55sj5iv727g7k57pscgyj0fx3smwapm1gmd5qkc3yfa9fa")))) + (build-system haskell-build-system) + (properties '((upstream-name . "Cabal-syntax"))) + (home-page "http://www.haskell.org/cabal/") + (synopsis "A library for working with .cabal files") + (description + "This library provides tools for reading and manipulating the .cabal file format. +. Version 3.6 (unlike the following versions) is a dummy package that prevents +module name clases between Cabal and Cabal-syntax if used together with a Cabal +flag as described below. . In Cabal-3.7 this package was split off. To avoid +module name clashes, you can add this to your .cabal file: . > flag Cabal-syntax +> description: Use the new Cabal-syntax package > default: False > manual: False +> > library > -- ... > if flag(Cabal-syntax) > build-depends: Cabal-syntax >= +3.7 > else > build-depends: Cabal < 3.7, Cabal-syntax < 3.7 . This will default +to the older build, but will allow consumers to opt-in to the newer libraries by +requiring Cabal or Cabal-syntax >= 3.7") + (license license:bsd-3))) + +(define-public ghc-tasty-hslua + (package + (name "ghc-tasty-hslua") + (version "1.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "tasty-hslua" version)) + (sha256 + (base32 + "0ibdxwaclghcgcyf9zx4b1dnp4b708ydwli4clmb0a0mp1lwdp98")))) + (build-system haskell-build-system) + (properties '((upstream-name . "tasty-hslua"))) + (inputs (list ghc-hslua-core ghc-tasty ghc-tasty-hunit)) + (home-page "https://hslua.org/") + (synopsis "Tasty helpers to test HsLua.") + (description + "Various tasty helpers and utilities to test HsLua oparations. Built on top of +tasty-hunit.") + (license license:expat))) + +(define-public ghc-hslua-marshalling + (package + (name "ghc-hslua-marshalling") + (version "2.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-marshalling" version)) + (sha256 + (base32 + "1xmix1frfcyv4p51rnshrg02gba7di7nrrc6chsq71d3mbwhyask")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-marshalling"))) + (inputs (list ghc-hslua-core)) + (native-inputs (list ghc-lua-arbitrary + ghc-quickcheck + ghc-quickcheck-instances + ghc-tasty-hslua + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck)) + (home-page "https://hslua.org/") + (synopsis "Marshalling of values between Haskell and Lua.") + (description + "This package provides functions to marshal values from Haskell to Lua, and /vice +versa/. . This package is part of HsLua, a Haskell framework built around the +embeddable scripting language .") + (license license:expat))) + +(define-public ghc-lua-arbitrary + (package + (name "ghc-lua-arbitrary") + (version "1.0.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "lua-arbitrary" version)) + (sha256 + (base32 + "01g2pkvy7yhcrk8p1d9xzmqv279ldgy9z5aa6xj5msbxrpxvbpma")))) + (build-system haskell-build-system) + (properties '((upstream-name . "lua-arbitrary"))) + (inputs (list ghc-lua ghc-quickcheck)) + (home-page "https://hslua.org/") + (synopsis "Arbitrary instances for Lua types.") + (description + "This package provides instances for QuickCheck's \\\"Arbitrary\\\" typeclass.") + (license license:expat))) + +(define-public ghc-lua + (package + (name "ghc-lua") + (version "2.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "lua" version)) + (sha256 + (base32 + "07wni3ji46ndqabwffgwzij2jk34dq2d66z15hcd6jg33sqnym45")))) + (build-system haskell-build-system) + (properties '((upstream-name . "lua"))) + (native-inputs (list ghc-tasty ghc-tasty-hunit)) + (home-page "https://hslua.org/") + (synopsis "Lua, an embeddable scripting language") + (description + "This package provides bindings and types to bridge Haskell and +. . The full Lua interpreter version 5.4.4 is +included. Alternatively, a system-wide Lua installation can be linked instead.") + (license license:expat))) + +(define-public ghc-hslua-core + (package + (name "ghc-hslua-core") + (version "2.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-core" version)) + (sha256 + (base32 + "0hy3a7rn940bcj0shxyk75dndwl23wwmmvbnwnay36py60hy3rbq")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-core"))) + (inputs (list ghc-lua)) + (native-inputs (list ghc-lua-arbitrary + ghc-quickcheck + ghc-quickcheck-instances + ghc-tasty + ghc-tasty-hunit + ghc-tasty-quickcheck)) + (home-page "https://hslua.org/") + (synopsis "Bindings to Lua, an embeddable scripting language") + (description + "Wrappers and helpers to bridge Haskell and . . It +builds upon the /lua/ package, which allows to bundle a Lua interpreter with a +Haskell program.") + (license license:expat))) + +(define-public ghc-hslua-aeson + (package + (name "ghc-hslua-aeson") + (version "2.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-aeson" version)) + (sha256 + (base32 + "0igmkay5bf3wg1n6rqm20kjv1xq36x552lgdvr1vlpwikgsiq8mb")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-aeson"))) + (inputs (list ghc-aeson + ghc-hashable + ghc-hslua-core + ghc-hslua-marshalling + ghc-scientific + ghc-unordered-containers + ghc-vector)) + (native-inputs (list ghc-quickcheck ghc-quickcheck-instances ghc-tasty + ghc-tasty-quickcheck)) + (home-page "https://hslua.org/") + (synopsis "Allow aeson data types to be used with Lua.") + (description + "This package provides instances to push and receive any datatype encodable as +JSON to and from the Lua stack.") + (license license:expat))) + +(define-public ghc-gridtables + (package + (name "ghc-gridtables") + (version "0.0.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "gridtables" version)) + (sha256 + (base32 + "1akix9flnax6dx3s9c7yyzb19nw13y8rmh0kz7y3hpjlkaz659xy")))) + (build-system haskell-build-system) + (properties '((upstream-name . "gridtables"))) + (inputs (list ghc-doclayout)) + (native-inputs (list ghc-tasty ghc-tasty-hunit)) + (arguments + `(#:cabal-revision ("1" + "0m2651z81n8s6hb8id7y6k2kprsgwnj7pcd6p8lmdpkzzz3wwd0c"))) + (home-page "https://github.com/tarleb/gridtables") + (synopsis "Parser for reStructuredText-style grid tables.") + (description + "This package provides a parser for plain-text representations of tables. This +package supports table headers, cells spanning multiple columns or rows, as well +as a way to specfiy column alignments.") + (license license:expat))) + +(define-public ghc-lpeg + (package + (name "ghc-lpeg") + (version "1.0.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "lpeg" version)) + (sha256 + (base32 + "19vvsvdw8l2zjwdcypnzw12vc9ycix92mkd6g3f6kx1i364z9hg1")))) + (build-system haskell-build-system) + (properties '((upstream-name . "lpeg"))) + (inputs (list ghc-lua)) + (native-inputs (list ghc-tasty ghc-tasty-hunit)) + (home-page "https://hslua.org/") + (synopsis "LPeg – Parsing Expression Grammars For Lua") + (description + "This package contains the C sources of LPeg, as well as some tiny Haskell helper +to load the package. . ") + (license license:expat))) + +(define-public ghc-pandoc-lua-marshal + (package + (name "ghc-pandoc-lua-marshal") + (version "0.1.7") + (source (origin + (method url-fetch) + (uri (hackage-uri "pandoc-lua-marshal" version)) + (sha256 + (base32 + "0pn9b7f8dln049k76zb4znscl01qms751y1ln4j8irs50rc1b55j")))) + (build-system haskell-build-system) + (properties '((upstream-name . "pandoc-lua-marshal"))) + (inputs (list ghc-lua ghc-hslua ghc-hslua-marshalling ghc-pandoc-types + ghc-safe)) + (native-inputs (list ghc-quickcheck ghc-tasty ghc-tasty-hunit + ghc-tasty-lua ghc-tasty-quickcheck)) + (home-page "https://github.com/pandoc/pandoc-lua-marshal") + (synopsis "Use pandoc types in Lua") + (description + "This package provides functions to marshal and unmarshal pandoc document types +to and from Lua. . The values of most types are pushed to pandoc as \"userdata\" +objects that wrap a stable pointer to the Haskell value; these objects come with +methods to access and modify their properties. . Sequences are pushed as normal +Lua tables, but are augmented with convenience functions.") + (license license:expat))) + +(define-public ghc-should-not-typecheck + (package + (name "ghc-should-not-typecheck") + (version "2.1.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "should-not-typecheck" version)) + (sha256 + (base32 + "14fmv0mv2v4fqzynamlrmdj6d1l65aw1srf1wv19nrq7rrqaqf7m")))) + (build-system haskell-build-system) + (properties '((upstream-name . "should-not-typecheck"))) + (inputs (list ghc-hunit)) + (native-inputs (list ghc-hspec ghc-hspec-expectations)) + (home-page "http://github.com/CRogers/should-not-typecheck") + (synopsis + "A HUnit/hspec assertion library to verify that an expression does not typecheck") + (description + "For examples and an introduction to the library please take a look at the + +on github.") + (license license:bsd-3))) + +(define-public ghc-hspec-wai + (package + (name "ghc-hspec-wai") + (version "0.11.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hspec-wai" version)) + (sha256 + (base32 + "03wiksic5y9a2g6a86nsxrnajdgdvpv17w02h5qla0zp9zs6pa1j")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hspec-wai"))) + (inputs (list ghc-quickcheck + ghc-base-compat + ghc-case-insensitive + ghc-hspec-core + ghc-hspec-expectations + ghc-http-types + ghc-wai + ghc-wai-extra)) + (native-inputs (list ghc-hspec hspec-discover)) + (home-page "https://github.com/hspec/hspec-wai#readme") + (synopsis "Experimental Hspec support for testing WAI applications") + (description "Experimental Hspec support for testing WAI applications") + (license license:expat))) + +(define-public ghc-http-media + (package + (name "ghc-http-media") + (version "0.8.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "http-media" version)) + (sha256 + (base32 + "0lww5cxrc9jlvzsysjv99lca33i4rb7cll66p3c0rdpmvz8pk0ir")))) + (build-system haskell-build-system) + (properties '((upstream-name . "http-media"))) + (inputs (list ghc-case-insensitive ghc-utf8-string)) + (native-inputs (list ghc-quickcheck ghc-test-framework + ghc-test-framework-quickcheck2)) + (arguments + `(#:cabal-revision ("7" + "1sm8bnrqvwkj7f60x4s8vfsj6lfi0knq38im35x88wk8s9whg6jd") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "http-media.cabal" + (("QuickCheck >= 2.8 && < 2.14") "QuickCheck") + (("base >= 4.7 && < 4.13") "base"))))))) + (home-page "https://github.com/zmthy/http-media") + (synopsis "Processing HTTP Content-Type and Accept headers") + (description + "This library is intended to be a comprehensive solution to parsing and selecting +quality-indexed values in HTTP headers. It is capable of parsing both media +types and language parameters from the Accept and Content header families, and +can be extended to match against other accept headers as well. Selecting the +appropriate header value is achieved by comparing a list of server options +against the quality-indexed values supplied by the client. . In the following +example, the Accept header is parsed and then matched against a list of server +options to serve the appropriate media using mapAcceptMedia': . > getHeader >>= +maybe send406Error sendResourceWith . mapAcceptMedia > [ (\"text/html\", asHtml) +> , (\"application/json\", asJson) > ] . Similarly, the Content-Type header can +be used to produce a parser for request bodies based on the given content type +with mapContentMedia': . > getContentType >>= maybe send415Error +readRequestBodyWith . mapContentMedia > [ (\"application/json\", parseJson) > , +(\"text/plain\", parseText) > ] . The API is agnostic to your choice of server.") + (license license:expat))) + +(define-public ghc-servant + (package + (name "ghc-servant") + (version "0.19.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "servant" version)) + (sha256 + (base32 + "1gk6j39rcjpjacs351lknhrwj86yr4ifyp3qwlmiig27dxqlig3q")))) + (build-system haskell-build-system) + (properties '((upstream-name . "servant"))) + (inputs (list ghc-constraints + ghc-sop-core + ghc-http-api-data + ghc-singleton-bool + ghc-base-compat + ghc-aeson + ghc-attoparsec + ghc-bifunctors + ghc-case-insensitive + ghc-http-media + ghc-http-types + ghc-mmorph + ghc-network-uri + ghc-quickcheck + ghc-string-conversions + ghc-tagged + ghc-vault)) + (native-inputs (list ghc-hspec ghc-quickcheck-instances hspec-discover)) + (home-page "http://docs.servant.dev/") + (synopsis "A family of combinators for defining webservices APIs") + (description + "This package provides a family of combinators for defining webservices APIs and +serving them . You can learn about the basics in the +. . +") + (license license:bsd-3))) + +(define-public ghc-servant-server + (package + (name "ghc-servant-server") + (version "0.19.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "servant-server" version)) + (sha256 + (base32 + "1a7msh8p59v5mgsnj5li9s3jg0jwq2zjsznr0cg7g0fncn7r1axy")))) + (build-system haskell-build-system) + (properties '((upstream-name . "servant-server"))) + (inputs (list ghc-constraints + ghc-servant + ghc-http-api-data + ghc-base-compat + ghc-base64-bytestring + ghc-http-media + ghc-http-types + ghc-network-uri + ghc-monad-control + ghc-network + ghc-sop-core + ghc-string-conversions + ghc-resourcet + ghc-tagged + ghc-transformers-base + ghc-wai + ghc-wai-app-static + ghc-word8 + ghc-aeson + ghc-warp)) + (native-inputs (list ghc-safe + ghc-transformers-compat + ghc-hspec + ghc-hspec-wai + ghc-quickcheck + ghc-should-not-typecheck + ghc-temporary + ghc-wai-extra + hspec-discover)) + (home-page "http://docs.servant.dev/") + (synopsis + "A family of combinators for defining webservices APIs and serving them") + (description + "This package provides a family of combinators for defining webservices APIs and +serving them . You can learn about the basics in the +. . + is a runnable example, with comments, that defines a dummy API and +implements a webserver that serves this API, using this package. . +") + (license license:bsd-3))) + +(define-public ghc-boring + (package + (name "ghc-boring") + (version "0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "boring" version)) + (sha256 + (base32 + "0d2cm9ra69cvaxs5x3lr2rfv7xx6xrbpb3dbcpyd8m77cqxm7b0b")))) + (build-system haskell-build-system) + (properties '((upstream-name . "boring"))) + (inputs (list ghc-tagged)) + (arguments + `(#:cabal-revision ("2" + "04pn94i3mysi7px93k86sf29vw99sf38sl4n0gy2nma0iqsik828"))) + (home-page "https://github.com/phadej/boring") + (synopsis "Boring and Absurd types") + (description + "* @@Boring@@ types are isomorphic to @@()@@. . * @@Absurd@@ types are isomorphic +to @@Void@@. . See [What does () mean in Haskell -answer by Conor +McBride](https://stackoverflow.com/questions/33112439/what-does-mean-in-haskell/33115522#33115522)") + (license license:bsd-3))) + +(define-public ghc-some + (package + (name "ghc-some") + (version "1.0.4.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "some" version)) + (sha256 + (base32 + "1qy840b2f58f0jxmw4q9sfgbx64kypzdlqnwc72md5wwv84b9b1d")))) + (build-system haskell-build-system) + (properties '((upstream-name . "some"))) + (home-page "https://github.com/haskellari/some") + (synopsis "Existential type: Some") + (description + "This library defines an existential type Some'. . @@ data Some f where \\ Some :: +f a -> Some f @@ . in few variants, and utilities to work with it. . If you +are unsure which variant to use, use the one in \"Data.Some\" module.") + (license license:bsd-3))) + +(define-public ghc-hslua-classes + (package + (name "ghc-hslua-classes") + (version "2.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-classes" version)) + (sha256 + (base32 + "1z7ym3whcq16k2cm9jf7sf0vwmp52iv1f0iicvv4jk6xks9d6ia1")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-classes"))) + (inputs (list ghc-hslua-core ghc-hslua-marshalling)) + (native-inputs (list ghc-lua-arbitrary + ghc-quickcheck + ghc-quickcheck-instances + ghc-tasty + ghc-tasty-hslua + ghc-tasty-hunit + ghc-tasty-quickcheck)) + (home-page "https://hslua.org/") + (synopsis "Type classes for HsLua") + (description + "Type classes for convenient marshalling and calling of Lua functions.") + (license license:expat))) + +(define-public ghc-hslua-objectorientation + (package + (name "ghc-hslua-objectorientation") + (version "2.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-objectorientation" version)) + (sha256 + (base32 + "13011yzz6lrgl2gasn9w5ggdqgrdz49hhqk1h259qd9gq29jnq3y")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-objectorientation"))) + (inputs (list ghc-hslua-core ghc-hslua-marshalling)) + (native-inputs (list ghc-lua-arbitrary + ghc-quickcheck + ghc-quickcheck-instances + ghc-tasty + ghc-tasty-hslua + ghc-tasty-hunit + ghc-tasty-quickcheck)) + (home-page "https://hslua.org/") + (synopsis "Object orientation tools for HsLua") + (description + "Expose Haskell objects to Lua with an object oriented interface.") + (license license:expat))) + +(define-public ghc-hslua-packaging + (package + (name "ghc-hslua-packaging") + (version "2.2.1") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-packaging" version)) + (sha256 + (base32 + "1yxfrsxmmsb96lyfihlk9ks53l2z2aln3whfqaha7grs3gx1yaib")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-packaging"))) + (inputs (list ghc-hslua-core ghc-hslua-marshalling + ghc-hslua-objectorientation)) + (native-inputs (list ghc-tasty-hslua ghc-tasty ghc-tasty-hunit)) + (home-page "https://hslua.org/") + (synopsis "Utilities to build Lua modules.") + (description + "Utilities to package up Haskell functions and values into a Lua module. . This +package is part of HsLua, a Haskell framework built around the embeddable +scripting language .") + (license license:expat))) + +(define-public ghc-hslua-module-version + (package + (name "ghc-hslua-module-version") + (version "1.0.3") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-module-version" version)) + (sha256 + (base32 + "1v24lbbagvaz0hacq4525snp6smz8yc5ifrxg89z1y5bbn7v46f5")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-module-version"))) + (inputs (list ghc-hslua-core ghc-hslua-marshalling ghc-hslua-packaging)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua)) + (home-page "https://hslua.org/") + (synopsis "Lua module to work with version specifiers.") + (description "Wrapper for the Data.Version.Version Haskell type.") + (license license:expat))) + +(define-public ghc-recv + (package + (name "ghc-recv") + (version "0.0.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "recv" version)) + (sha256 + (base32 + "1yz9b95m9yxcwbbwdvp288y47ycn4yq9g7ixlw0sf98h5rjp4s2w")))) + (build-system haskell-build-system) + (properties '((upstream-name . "recv"))) + (inputs (list ghc-network)) + (native-inputs (list ghc-hspec hspec-discover)) + (home-page "http://github.com/yesodweb/wai") + (synopsis "Efficient netowrk recv") + (description "Network recv based on buffer pools") + (license license:bsd-3))) + +(define-public ghc-glib + (package + (name "ghc-glib") + (version "0.13.8.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "glib" version)) + (sha256 + (base32 + "09qamkxkpx2paazbh8x225wvwgzgpp0g0a3s708n96q76b4bvd46")))) + (build-system haskell-build-system) + (properties '((upstream-name . "glib"))) + (inputs (list ghc-utf8-string glib)) + (native-inputs (list ghc-gtk2hs-buildtools pkg-config)) + (home-page "https://github.com/gtk2hs/gtk2hs") + (synopsis "GLib bindings for for Gtk2Hs") + (description + "GLib is a collection of C data structures and utility functions for the GObject +system, main loop implementation, for strings and common data structures dealing +with Unicode. This package only binds as much functionality as required to +support the packages that wrap libraries that are themselves based on GLib.") + (license license:lgpl2.1))) + +(define-public ghc-pango + (package + (name "ghc-pango") + (version "0.13.8.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "pango" version)) + (sha256 + (base32 + "1mndcb904vlkqpbmj5np9lxqw2qw3pzawvrgbsbxa9xjayh0ylw5")))) + (build-system haskell-build-system) + (properties '((upstream-name . "pango"))) + (inputs (list ghc-glib ghc-cairo pango)) + (native-inputs (list ghc-gtk2hs-buildtools pkg-config)) + (home-page "https://hackage.haskell.org/package/pango") + (synopsis "Haskell bindings to the Pango text rendering engine") + (description + "This package provides a wrapper around the Pango C library that allows +high-quality rendering of Unicode text. It can be used either with Cairo to +output text in PDF, PS or other documents or with Gtk+ to display text +on-screen.") + (license license:lgpl2.1))) + +(define-public ghc-monoidal-containers + (package + (name "ghc-monoidal-containers") + (version "0.6.3.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "monoidal-containers" version)) + (sha256 + (base32 + "0m41z50r3jvr8vvfry99kamb2h3knm0g7bqfwspchmhwsgqqczh4")))) + (build-system haskell-build-system) + (properties '((upstream-name . "monoidal-containers"))) + (inputs (list ghc-aeson + ghc-hashable + ghc-lens + ghc-newtype + ghc-unordered-containers + ghc-witherable + ghc-semialign + ghc-these)) + (home-page "http://github.com/bgamari/monoidal-containers") + (synopsis "Containers with monoidal accumulation") + (description + "Containers with merging via monoidal accumulation. The Monoid instances +provided by the @code{containers} and @code{unordered-containers} packages merge +structures in a left-biased manner instead of using the underlying monoidal +structure of the value. This package wraps the types provided by these +packages, but provides @code{Monoid} instances implemented in terms of the value +type's mappend'.") + (license license:bsd-3))) + +(define-public ghc-newtype + (package + (name "ghc-newtype") + (version "0.2.2.0") + (source (origin + (method url-fetch) + (uri (hackage-uri "newtype" version)) + (sha256 + (base32 + "1b7bamnd0p8vmxvlg39g5d4a2av49kx10rdyz04ixa28pg8zy01s")))) + (build-system haskell-build-system) + (properties '((upstream-name . "newtype"))) + (arguments + `(#:cabal-revision ("3" + "0yll88ydchd2gqcvdk28fchf2vygpd42ky2bigg4ga08jan2nacx"))) + (home-page "http://hackage.haskell.org/package/newtype") + (synopsis "Typeclass and set of functions for working with newtypes") + (description + "Per Conor McBride, the Newtype typeclass represents the packing and unpacking of +a @code{newtype}, and allows you to operate under that @code{newtype} with functions +such as ala'.") + (license license:bsd-3))) + +(define-public ghc-hspec-hedgehog + (package + (name "ghc-hspec-hedgehog") + (version "0.0.1.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "hspec-hedgehog" version)) + (sha256 + (base32 + "17gbr4ssnzjk7nvpsnh47av6vd9wz27ax92xvr4jwyw0z7h2wn13")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hspec-hedgehog"))) + (inputs (list ghc-hspec + ghc-hspec-core + ghc-hedgehog + ghc-hunit + ghc-quickcheck + ghc-splitmix)) + (arguments + `(#:cabal-revision ("1" + "1qv2gap0775d2zg8wbd3kq4ypziz05qlz5jfisvl3jfd6jzcf2ad"))) + (home-page "https://github.com/parsonsmatt/hspec-hedgehog#readme") + (synopsis "Integrate Hedgehog and Hspec") + (description "An integration library for hspec and hedgehog.") + (license license:bsd-3))) + +(define-public ghc-validation-selective + (package + (name "ghc-validation-selective") + (version "0.1.0.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "validation-selective" version)) + (sha256 + (base32 + "1gsvcm8gjp8kdfprd1i4h9si8f2ym1gj3hqfwz7x1ylsa8qxwvq1")))) + (build-system haskell-build-system) + (properties '((upstream-name . "validation-selective"))) + (inputs (list ghc-selective)) + (native-inputs (list ghc-hedgehog ghc-hspec ghc-hspec-hedgehog ghc-doctest)) + (home-page "https://github.com/kowainik/validation-selective") + (synopsis + "Data validation based on Applicative and Selective functors") + (description + "Lighweight pure data validation based on Applicative and Selective functors.") + (license license:mpl2.0))) + +(define-public ghc-tomland + (package + (name "ghc-tomland") + (version "1.3.3.2") + (source (origin + (method url-fetch) + (uri (hackage-uri "tomland" version)) + (sha256 + (base32 + "152jqjv6n7n2hdysn903wfhpwh6vp8wmjiymzasazprasdcxpywm")))) + (build-system haskell-build-system) + (properties '((upstream-name . "tomland"))) + (inputs (list ghc-hashable ghc-megaparsec ghc-parser-combinators + ghc-unordered-containers ghc-validation-selective)) + (native-inputs (list ghc-hedgehog ghc-hspec ghc-hspec-hedgehog + ghc-hspec-megaparsec)) + (home-page "https://github.com/kowainik/tomland") + (synopsis "Bidirectional TOML serialization") + (description + "Implementation of bidirectional TOML serialization.") + (license license:mpl2.0))) + +(define-public ghc-hslua-module-doclayout + (package + (name "ghc-hslua-module-doclayout") + (version "1.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "hslua-module-doclayout" version)) + (sha256 + (base32 + "14sqffgcrhhrv7k4j8b1l41mn5gqlp8yzggd727746kjl0n56hqq")))) + (build-system haskell-build-system) + (properties '((upstream-name . "hslua-module-doclayout"))) + (inputs (list ghc-doclayout ghc-hslua)) + (native-inputs (list ghc-tasty ghc-tasty-hunit ghc-tasty-lua)) + (home-page "https://github.com/hslua/hslua-module-doclayout") + (synopsis "Lua module wrapping Text.DocLayout") + (description "Lua module wrapping @code{Text.DocLayout}.") + (license license:expat))) + +(define-public ghc-random-shuffle + (package + (name "ghc-random-shuffle") + (version "0.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "random-shuffle" version)) + (sha256 + (base32 + "0586bnlh0g2isc44jbjvafkcl4yw6lp1db8x6vr0pza0y08l8w2j")))) + (build-system haskell-build-system) + (properties '((upstream-name . "random-shuffle"))) + (inputs (list ghc-random ghc-monadrandom)) + (home-page "http://hackage.haskell.org/package/random-shuffle") + (synopsis "Random shuffle implementation") + (description + "Random shuffle implementation, on immutable lists. Based on +@url{http://okmij.org/ftp/Haskell/perfect-shuffle.txt, perfect shuffle +implementation by Oleg Kiselyov}.") + (license license:bsd-3))) + +(define-public ghc-deriving-aeson + (package + (name "ghc-deriving-aeson") + (version "0.2.8") + (source (origin + (method url-fetch) + (uri (hackage-uri "deriving-aeson" version)) + (sha256 + (base32 + "0f59ar4cax7g0h6wrk8ckni7i4gw5wls5ybzbrji2a0qpd7q5lrd")))) + (build-system haskell-build-system) + (properties '((upstream-name . "deriving-aeson"))) + (inputs (list ghc-aeson)) + (arguments + `(#:cabal-revision ("1" + "0pwx7lmdhpipg9ksqkz6xpjzh1aw2hip8y3jsk20ndl4wdzvxak5"))) + (home-page "http://hackage.haskell.org/package/deriving-aeson") + (synopsis "Type driven generic aeson instance customisation") + (description + "This package provides a newtype wrapper with FromJSON/ToJSON instances +customisable via a phantom type parameter. The instances can be rendered to the +original type using DerivingVia.") + (license license:bsd-3))) + +(define-public ghc-leancheck + (package + (name "ghc-leancheck") + (version "0.9.12") + (source (origin + (method url-fetch) + (uri (hackage-uri "leancheck" version)) + (sha256 + (base32 + "15wpklkbr03dciai4mk8bm1yk9svxxmbsl22wsvwk3ns7aiamrkj")))) + (build-system haskell-build-system) + (properties '((upstream-name . "leancheck"))) + (home-page "https://github.com/rudymatela/leancheck#readme") + (synopsis "Enumerative property-based testing") + (description + "LeanCheck is a simple enumerative property-based testing library. Properties +are defined as Haskell functions returning a boolean value which should be true +for all possible choices of argument values. LeanCheck applies enumerated +argument values to these properties in search for a counterexample. Properties +can be viewed as parameterized unit tests. LeanCheck works by producing tiers +of test values: a possibly infinite list of finite sublists of +same-and-increasingly-sized values.") + (license license:bsd-3))) + +(define-public ghc-test-framework-leancheck + (package + (name "ghc-test-framework-leancheck") + (version "0.0.4") + (source (origin + (method url-fetch) + (uri (hackage-uri "test-framework-leancheck" version)) + (sha256 + (base32 + "0aa21r999jj59plzkn1px02k3a87znwhagdjmdsik2xvy5wrzgzv")))) + (build-system haskell-build-system) + (properties '((upstream-name . "test-framework-leancheck"))) + (inputs (list ghc-test-framework ghc-leancheck)) + (home-page "https://github.com/rudymatela/test-framework-leancheck#readme") + (synopsis "LeanCheck support for test-framework") + (description + "LeanCheck support for @code{test-framework}. This package can be used +to incorporate LeanCheck tests into test-framework test suites.") + (license license:bsd-3))) + +;;; +;;; Avoid adding new packages to the end of this file. To reduce the chances +;;; of a merge conflict, place them above by existing packages with similar +;;; functionality or similar names. +;;; + -- cgit v1.2.3