#:use-module (gnu packages ghostscript)
#:use-module (gnu packages gl)
#:use-module (gnu packages graphviz)
+ #:use-module (gnu packages gtk)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
#:use-module (gnu packages haskell-web)
efficient memo functions using tries.")
(license license:bsd-3)))
+(define-public ghc-tree-diff
+ (package
+ (name "ghc-tree-diff")
+ (version "0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tree-diff/tree-diff-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "049v44c520jy3icxlnrvbdblh3mjmvd7m6qmkzxbzkf02x63xqmz"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("4" "1rqxxyj6hqllahs11693g855cxz8mgnb490s7j1ksd300i5xgjsp")
+ #:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "tree-diff.cabal"
+ (("trifecta >=1\\.7\\.1\\.1 && <1\\.8")
+ "trifecta >=1.7.1.1 && <=2")))))))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-generics-sop" ,ghc-generics-sop)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-memotrie" ,ghc-memotrie)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-parsers" ,ghc-parsers)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-text" ,ghc-text)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-uuid-types" ,ghc-uuid-types)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-trifecta" ,ghc-trifecta)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/phadej/tree-diff")
+ (synopsis "Compute difference between (expression) trees")
+ (description "This Haskell library provides a function for computing
+the difference bewteen (expression) trees. It also provides a way to
+compute the difference between arbitrary abstract datatypes (ADTs) using
+@code{Generics}-derivable helpers.")
+ (license license:bsd-3)))
+
(define-public ghc-haddock-library
(package
(name "ghc-haddock-library")
- (version "1.4.3")
+ (version "1.5.0.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0ns4bpf6whmcfl0cm2gx2c73if416x4q3ac4l4qm8w84h0zpcr7p"))))
+ "1cmbg8l5xrwpliclwy3l057raypjqy0hsg1h1743ahaj8gq10b7z"))
+ (patches (search-patches
+ "ghc-haddock-library-unbundle.patch"))
+ (modules '((guix build utils)))
+ (snippet '(begin
+ (delete-file-recursively "vendor")
+ #t))))
(build-system haskell-build-system)
- (inputs
- `(("ghc-base-compat" ,ghc-base-compat)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'relax-test-suite-dependencies
+ (lambda _
+ (substitute* "haddock-library.cabal"
+ (("base-compat\\s*\\^>= 0\\.9\\.3") "base-compat")
+ (("hspec\\s*\\^>= 2\\.4\\.4") "hspec"))))
+ ;; The release tarball does not contain the "fixtures/examples"
+ ;; directory, which is required for testing. In the upstream
+ ;; repository, the directory exists and is populated. Here, we
+ ;; create an empty directory to placate the tests.
+ (add-before 'check 'add-examples-directory
+ (lambda _
+ (mkdir "fixtures/examples")
+ #t)))))
(native-inputs
- `(("hspec-discover" ,hspec-discover)
+ `(("ghc-base-compat" ,ghc-base-compat)
("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)))
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tree-diff" ,ghc-tree-diff)
+ ("hspec-discover" ,hspec-discover)))
(home-page "https://www.haskell.org/haddock/")
(synopsis "Library exposing some functionality of Haddock")
(description
(define-public ghc-haddock-api
(package
(name "ghc-haddock-api")
- ;; This is the last version to be supported by Cabal < 2.0
- (version "2.17.4")
+ (version "2.19.0.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "00fn6pzgg8xjbaw12d76jdqh2dbc5xy7miyz0x6kidvvar7i35ss"))))
+ "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "haddock-api.cabal"
+ (("Cabal \\^>= 2\\.0\\.0")
+ "Cabal ^>= 2.2.0")
+ (("hspec \\^>= 2\\.4\\.4")
+ "hspec >= 2.4.4 && < 2.6")))))))
(inputs
`(("ghc-paths" ,ghc-paths)
("ghc-haddock-library" ,ghc-haddock-library)))
(define-public ghc-haddock
(package
(name "ghc-haddock")
- (version "2.17.4")
+ (version "2.19.0.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1z3h3v7w84dzsm47iavdppc2w899mr4c1agq9fzghgz902i0a655"))))
+ "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7"))))
(build-system haskell-build-system)
- ;; FIXME: Tests fail with this error:
- ;; driver-test/Main.hs:4:1: error:
- ;; Failed to load interface for ‘ResponseFileSpec’
- (arguments `(#:tests? #f))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; There are four test suites that require the ghc-haddock-test
+ ;; package, which no longer builds with GHC 8.4.3. This phase
+ ;; removes these four test suites from the Cabal file, so that we
+ ;; do not need ghc-haddock-test as an input.
+ (add-before 'configure 'remove-haddock-test-test-suites
+ (lambda _
+ (use-modules (ice-9 rdelim))
+ (with-atomic-file-replacement "haddock.cabal"
+ (lambda (in out)
+ (let loop ((line (read-line in 'concat)) (deleting? #f))
+ (cond
+ ((eof-object? line) #t)
+ ((string-every char-set:whitespace line)
+ (unless deleting? (display line out))
+ (loop (read-line in 'concat) #f))
+ ((member line '("test-suite html-test\n"
+ "test-suite hypsrc-test\n"
+ "test-suite latex-test\n"
+ "test-suite hoogle-test\n"))
+ (loop (read-line in 'concat) #t))
+ (else
+ (unless deleting? (display line out))
+ (loop (read-line in 'concat) deleting?)))))))))))
(inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
(native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-haddock-test" ,ghc-haddock-test)))
+ `(("ghc-hspec" ,ghc-hspec)))
(home-page "https://www.haskell.org/haddock/")
(synopsis
"Documentation-generation tool for Haskell libraries")
(define-public hlint
(package
(name "hlint")
- (version "2.1.1")
+ (version "2.1.10")
(source
(origin
(method url-fetch)
"/" name "-" version ".tar.gz"))
(sha256
(base32
- "0mmfavd158l5ig5wb1b1zbhbraj8hhqvbk4mg85n6c8ndpr4grd4"))))
+ "19as2m9g75cr6n1agzvsij0cvqhb0wbjlk31w4y5d5mns87dki0w"))))
(build-system haskell-build-system)
(inputs
`(("cpphs" ,cpphs)
versions of GHC (i.e., < 6.10).")
(license license:bsd-3)))
+(define-public ghc-echo
+ (package
+ (name "ghc-echo")
+ (version "0.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/echo/echo-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1vw5ykpwhr39wc0hhcgq3r8dh59zq6ib4zxbz1qd2wl21wqhfkvh"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l")))
+ (home-page "https://github.com/RyanGlScott/echo")
+ (synopsis "Echo terminal input portably")
+ (description "The @code{base} library exposes the @code{hGetEcho} and
+@code{hSetEcho} functions for querying and setting echo status, but
+unfortunately, neither function works with MinTTY consoles on Windows.
+This library provides an alternative interface which works with both
+MinTTY and other consoles.")
+ (license license:bsd-3)))
+
+(define-public ghc-hackage-security
+ (package
+ (name "ghc-hackage-security")
+ (version "0.5.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hackage-security/hackage-security-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f)) ; Tests fail because of framework updates.
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256)
+ ("ghc-ed25519" ,ghc-ed25519)
+ ("ghc-network" ,ghc-network)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-tar" ,ghc-tar)
+ ("ghc-zlib" ,ghc-zlib)))
+ (native-inputs
+ `(("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tar" ,ghc-tar)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-zlib" ,ghc-zlib)))
+ (home-page "https://github.com/haskell/hackage-security")
+ (synopsis "Hackage security library")
+ (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
+recommendations developed by security researchers at various universities
+in the US as well as developers on the @uref{https://www.torproject.org/,
+Tor project}.")
+ (license license:bsd-3)))
+
+(define-public ghc-resolv
+ (package
+ (name "ghc-resolv")
+ (version "0.1.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/resolv/resolv-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0wh7wj56l3f2bylz563g5g04a4nydj8acv60hpwa7k3mn792xca9"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "15ay4n3x8c09cb3h4z1nan84yd3n9zpgvi6h114hk98bq10k8mma")
+ #:tests? #f)) ; The required test frameworks are too old.
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)))
+ (home-page "https://github.com/haskell/hackage-security")
+ (synopsis "Domain Name Service (DNS) lookup via @code{libresolv}")
+ (description "This package implements an API for accessing the
+@uref{https://tools.ietf.org/html/rfc1035, Domain Name Service (DNS)}
+resolver service via the standard @code{libresolv} system library (whose
+API is often available directly via the standard @code{libc} C library) on
+Unix systems.")
+ (license license:gpl3)))
+
(define-public cabal-install
(package
(name "cabal-install")
- (version "1.22.6.0")
+ (version "2.2.0.0")
(source
(origin
(method url-fetch)
version
".tar.gz"))
(sha256
- (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx"))))
+ (base32 "1nd3ch7qr4dpfxhgkcq2lnhvszx2kjgnn1kwb44vk9y5jgfs4mn8"))))
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
(build-system haskell-build-system)
(inputs
- `(("ghc-http" ,ghc-http)
+ `(("ghc-async" ,ghc-async)
+ ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256)
+ ("ghc-echo" ,ghc-echo)
+ ("ghc-edit-distance" ,ghc-edit-distance)
+ ("ghc-hackage-security" ,ghc-hackage-security)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-http" ,ghc-http)
("ghc-network-uri" ,ghc-network-uri)
("ghc-network" ,ghc-network)
("ghc-random" ,ghc-random)
+ ("ghc-resolv" ,ghc-resolv)
("ghc-stm" ,ghc-stm)
+ ("ghc-tar" ,ghc-tar)
("ghc-zlib" ,ghc-zlib)))
(home-page "https://www.haskell.org/cabal/")
(synopsis "Command-line interface for Cabal and Hackage")
(base32
"1ly3v41jacc6lrsvg4j3m5a6zs90gr8dyif5m6bf34hj1k5cgg0n"))))
(build-system haskell-build-system)
+ ;; This package needs an older version of tasty.
+ (arguments '(#:tests? #f))
(inputs
`(("ghc-parsec" ,ghc-parsec)
("ghc-concatenative" ,ghc-concatenative)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(home-page "http://patch-tag.com/r/salazar/indents")
(synopsis "Indentation sensitive parser-combinators for parsec")
(description
(base32
"1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
(build-system haskell-build-system)
+ (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
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-hashable" ,ghc-hashable)
(define-public ghc-trifecta
(package
(name "ghc-trifecta")
- (version "1.7.1.1")
+ (version "2")
(source (origin
(method url-fetch)
(uri (string-append
"trifecta-" version ".tar.gz"))
(sha256
(base32
- "13n6a3fdxngnzsjnhfrzigv1c2g0xm6lqkjcnirpc37sd0rpby31"))))
+ "0hznd8i65s81xy13i2qc7cvipw3lfb2yhkv53apbdsh6sbljz5sk"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-doctest" ,ghc-doctest-0.13)
- ("ghc-reducers" ,ghc-reducers)
+ `(("ghc-reducers" ,ghc-reducers)
("ghc-semigroups" ,ghc-semigroups)
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-blaze-markup" ,ghc-blaze-markup)
("ghc-charset" ,ghc-charset)
("ghc-comonad" ,ghc-comonad)
- ("ghc-doctest" ,ghc-doctest)
("ghc-fingertree" ,ghc-fingertree)
("ghc-hashable" ,ghc-hashable)
("ghc-lens" ,ghc-lens)
("ghc-parsers" ,ghc-parsers)
("ghc-profunctors" ,ghc-profunctors)
- ("ghc-quickcheck" ,ghc-quickcheck)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-utf8-string" ,ghc-utf8-string)))
(native-inputs
- `(("cabal-doctest" ,cabal-doctest)))
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/ekmett/trifecta/")
(synopsis "Parser combinator library with convenient diagnostics")
(description "Trifecta is a modern parser combinator library for Haskell,
(define-public ghc-feed
(package
(name "ghc-feed")
- (version "0.3.12.0")
+ (version "1.0.0.0")
(source
(origin
(method url-fetch)
"feed/feed-" version ".tar.gz"))
(sha256
(base32
- "0hkrsinspg70bbm3hwqdrvivws6zya1hyk0a3awpaz82j4xnlbfc"))))
+ "05rgg7x1984mgfhkmz792xj8lhwjgznixhygzr8blf517lns2nck"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("4" "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d")))
(inputs
- `(("ghc-old-locale" ,ghc-old-locale)
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-old-locale" ,ghc-old-locale)
("ghc-old-time" ,ghc-old-time)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-text" ,ghc-text)
("ghc-time-locale-compat" ,ghc-time-locale-compat)
("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-xml" ,ghc-xml)))
+ ("ghc-xml-conduit" ,ghc-xml-conduit)
+ ("ghc-xml-types" ,ghc-xml-types)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
(define-public ghc-base-compat
(package
(name "ghc-base-compat")
- (version "0.9.3")
+ (version "0.10.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0452l6zf6fjhy4kxqwv6i6hhg6yfx4wcg450k3axpyj30l7jnq3x"))))
+ "0ksp990gxs731mq19rzbxrbs43nazfljjc8krlx5bjqblw3kfs8d"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-kan-extensions
(package
(name "ghc-kan-extensions")
- (version "5.0.1")
+ (version "5.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1qm0kf4krmyjbjynn96ab0h3q117vwcia5nin7n2b8b4f3jrzph1"))))
+ "1lyvyiwwh962j2nnnsqzlvp5zq6z8p3spvhmji99cjvldxc7wwkb"))))
(build-system haskell-build-system)
(inputs
`(("ghc-adjunctions" ,ghc-adjunctions)
("ghc-contravariant" ,ghc-contravariant)
("ghc-distributive" ,ghc-distributive)
("ghc-free" ,ghc-free)
+ ("ghc-invariant" ,ghc-invariant)
("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-tagged" ,ghc-tagged)))
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
(home-page "https://github.com/ekmett/kan-extensions/")
(synopsis "Kan extensions library")
(description "This library provides Kan extensions, Kan lifts, various
(define-public ghc-lens
(package
(name "ghc-lens")
- (version "4.15.4")
+ (version "4.16.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1lkwlnhgpgnsz046mw4qs0fa7h4l012gilrr3nf3spllsy3pnbkl"))))
+ "1im4drhbydbawd6i0jsrzpqihnmx4ywpkg7yg94ddwsw3mxwkgpm"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri")))
(inputs
`(("ghc-base-orphans" ,ghc-base-orphans)
("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-doctest" ,ghc-doctest-0.13)
("ghc-distributive" ,ghc-distributive)
("ghc-exceptions" ,ghc-exceptions)
("ghc-free" ,ghc-free)
("hlint" ,hlint)))
(native-inputs
`(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
@uref{https://docs.python.org/library/doctest.html, the Doctest website}.")
(license license:expat)))
-(define-public ghc-doctest-0.12
- (package (inherit ghc-doctest)
- (name "ghc-doctest")
- (version "0.12.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/doctest/doctest-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "13h549cpgcvb7c54c7wif28g5wak84dxc3ais0hlqhzk1q6la91a"))))
- (inputs
- `(("ghc-code-page" ,ghc-code-page)
- ,@(package-inputs ghc-doctest)))))
-
-(define-public ghc-doctest-0.13
- (package (inherit ghc-doctest-0.12)
- (name "ghc-doctest")
- (version "0.13.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "doctest/doctest-" version ".tar.gz"))
- (sha256
- (base32
- "08g3nmpqbnbkxc95d65hkhfabwax10qrq51vlynr342npn40mn2b"))))))
-
(define-public ghc-lifted-base
(package
(name "ghc-lifted-base")
building up, manipulating and serialising @code{Pandoc} structures.")
(license license:bsd-3)))
-(define-public ghc-pandoc-types-for-pandoc-1
- (package (inherit ghc-pandoc-types)
- (version "1.17.0.5")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "pandoc-types/pandoc-types-"
- version ".tar.gz"))
- (sha256
- (base32
- "1csipjdq00iiq77k2wlrg4i7afrzlh8nl585q785xzw7nn45b0n8"))))
- (arguments
- `(#:configure-flags (list "--allow-newer=QuickCheck"
- "--allow-newer=HUnit")))
- (inputs
- `(("ghc-syb" ,ghc-syb)
- ("ghc-aeson" ,ghc-aeson-for-pandoc-1)
- ("ghc-string-qq" ,ghc-string-qq)))))
-
(define-public ghc-texmath
(package
(name "ghc-texmath")
it can parse and apply LaTeX macros.")
(license license:gpl2+)))
-(define-public ghc-texmath-for-pandoc-1
- (package (inherit ghc-texmath)
- (version "0.9.4.4")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "texmath/texmath-" version ".tar.gz"))
- (sha256
- (base32
- "129q33m56diiv35kdwfb07838wrg0mm88kxdqxfyl1zvf9nzkqkd"))))
- (inputs
- `(("ghc-network-uri" ,ghc-network-uri)
- ("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1)
- ("ghc-parsec" ,ghc-parsec)
- ("ghc-split" ,ghc-split)
- ("ghc-syb" ,ghc-syb)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-xml" ,ghc-xml)))))
-
(define-public ghc-regex-pcre-builtin
(package
(name "ghc-regex-pcre-builtin")
(define-public ghc-yaml
(package
(name "ghc-yaml")
- (version "0.8.28")
+ (version "0.8.32")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"yaml/yaml-" version ".tar.gz"))
(sha256
(base32
- "0swgkzkfrwj0ac7lssn8rnrdfmh3lcsdn5fbq2iwv55di6jbc0pp"))))
+ "0cbsyh4ilvjzq1q7pxls43k6pdqxg1l85xzibcwpbvmlvrizh86w"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
"This package provides a library to parse and render YAML documents.")
(license license:bsd-3)))
-(define-public ghc-yaml-for-pandoc-1
- (package (inherit ghc-yaml)
- (inputs
- `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
- ,@(alist-delete "ghc-aeson" (package-inputs ghc-yaml))))))
-
(define-public ghc-filemanip
(package
(name "ghc-filemanip")
described in @url{https://www.lua.org/}.")
(license license:expat)))
-(define-public ghc-hslua-for-pandoc-1
- (package (inherit ghc-hslua)
- (version "0.4.1")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hslua/hslua-" version ".tar.gz"))
- (sha256
- (base32
- "0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid"))))
- (inputs
- `(("lua" ,lua-5.1)
- ("ghc-text" ,ghc-text)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-hspec-contrib" ,ghc-hspec-contrib)
- ("ghc-hunit" ,ghc-hunit)
- ("hspec-discover" ,hspec-discover)))))
-
(define-public ghc-hslua-module-text
(package
(name "ghc-hslua-module-text")
`(("ghc-skylighting-core" ,ghc-skylighting-core)
,@(package-inputs ghc-skylighting-core)))))
-(define-public ghc-skylighting-for-pandoc-1
- (package (inherit ghc-skylighting)
- (version "0.1.1.5")
- (source (origin
- (method git-fetch)
- ;; We take the sources from Github, because the tarball on
- ;; hackage does not include the XML files.
- (uri (git-reference
- (url "https://github.com/jgm/skylighting.git")
- (commit version)))
- (file-name (string-append "ghc-skylighting-" version "-checkout"))
- (sha256
- (base32
- "0z3yv8v2fqqgv6lsf0ff3ld0h2vkg97b2jiry9wn2f1rizwdqmzl"))))
- (arguments
- `(#:configure-flags '("-fbootstrap")
- #:phases
- (modify-phases %standard-phases
- ;; After building the skylighting-extract tool we use it to generate
- ;; syntax source files from the included XML files. These are then
- ;; added to the skylighting.cabal file.
- (add-after 'build 'extract-xml
- (lambda _
- (make-file-writable "skylighting.cabal")
- (apply invoke "./dist/build/skylighting-extract/skylighting-extract"
- (find-files "xml" "\\.xml$"))
- #t))
- ;; Reconfigure without bootstrap flag
- (add-after 'extract-xml 'configure-again
- (lambda* (#:key outputs inputs tests? #:allow-other-keys)
- ((assoc-ref %standard-phases 'configure)
- #:outputs outputs
- #:inputs inputs
- #:tests? tests?
- #:configure-flags '("-f-bootstrap"))))
- (add-after 'configure-again 'build-again
- (assoc-ref %standard-phases 'build)))))
- (inputs
- `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-diff" ,ghc-diff)
- ("ghc-hxt" ,ghc-hxt)
- ("ghc-pretty-show" ,ghc-pretty-show)
- ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
- ("ghc-safe" ,ghc-safe)
- ("ghc-text" ,ghc-text)
- ("ghc-utf8-string" ,ghc-utf8-string)))))
-
(define-public ghc-doctemplates
(package
(name "ghc-doctemplates")
"This package provides a simple text templating system used by pandoc.")
(license license:bsd-3)))
-(define-public ghc-doctemplates-for-pandoc-1
- (package (inherit ghc-doctemplates)
- (version "0.1.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "doctemplates/doctemplates-"
- version ".tar.gz"))
- (sha256
- (base32
- "0swal6rjya1293mwvl63jch5fx9ghpsil7qs4v7rpansa0izalmp"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-text" ,ghc-text)
- ("ghc-vector" ,ghc-vector)
- ("ghc-parsec" ,ghc-parsec)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-scientific" ,ghc-scientific)))))
-
(define-public ghc-pandoc
(package
(name "ghc-pandoc")
(base32
"1dqin92w513l7whg5wdgrngnxsj5mb8gppfvn7kjgyv2pdgpy0zy"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "pandoc.cabal"
+ (("tasty >= 0\\.11 && < 1\\.1")
+ "tasty >= 0.11 && < 1.1.1"))))
+ (add-before 'configure 'patch-tests
+ (lambda _
+ ;; These tests fail benignly and have been adjusted upstream:
+ ;; <https://github.com/commercialhaskell/stackage/issues/3719>.
+ (substitute* "test/Tests/Old.hs"
+ (("lhsWriterTests \"html\"") "[]")))))))
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-aeson-pretty" ,ghc-aeson-pretty)
provided for those who need a drop-in replacement for Markdown.pl.")
(license license:gpl2+)))
-;; This is the last version of Pandoc 1.x, which is preferred for Rmarkdown.
-(define-public ghc-pandoc-1
- (package (inherit ghc-pandoc)
- (version "1.19.2.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
- version ".tar.gz"))
- (sha256
- (base32
- "0mim429mpakrcnm50csxyqk3ljcx2l26r5grk6w9isnggwgqrq5v"))))
- (arguments
- `(#:configure-flags (list "--allow-newer=skylighting")))
- (inputs
- `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-cmark" ,ghc-cmark)
- ("ghc-data-default" ,ghc-data-default)
- ("ghc-deepseq-generics" ,ghc-deepseq-generics)
- ("ghc-diff" ,ghc-diff)
- ("ghc-doctemplates" ,ghc-doctemplates-for-pandoc-1)
- ("ghc-executable-path" ,ghc-executable-path)
- ("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
- ("ghc-filemanip" ,ghc-filemanip)
- ("ghc-haddock-library" ,ghc-haddock-library)
- ("ghc-hslua" ,ghc-hslua-for-pandoc-1)
- ("ghc-http" ,ghc-http)
- ("ghc-http-client" ,ghc-http-client)
- ("ghc-http-client-tls" ,ghc-http-client-tls)
- ("ghc-http-types" ,ghc-http-types)
- ("ghc-juicypixels" ,ghc-juicypixels)
- ("ghc-network" ,ghc-network)
- ("ghc-network-uri" ,ghc-network-uri)
- ("ghc-old-time" ,ghc-old-time)
- ("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1)
- ("ghc-parsec" ,ghc-parsec)
- ("ghc-random" ,ghc-random)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-sha" ,ghc-sha)
- ("ghc-skylighting" ,ghc-skylighting-for-pandoc-1)
- ("ghc-syb" ,ghc-syb)
- ("ghc-tagsoup" ,ghc-tagsoup)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-texmath" ,ghc-texmath-for-pandoc-1)
- ("ghc-text" ,ghc-text)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-xml" ,ghc-xml)
- ("ghc-yaml" ,ghc-yaml-for-pandoc-1)
- ("ghc-zip-archive" ,ghc-zip-archive)
- ("ghc-zlib" ,ghc-zlib)))
- (native-inputs
- `(("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))))
-
-(define-public ghc-hs-bibutils
- (package
- (name "ghc-hs-bibutils")
- (version "6.6.0.0")
+(define-public ghc-hs-bibutils
+ (package
+ (name "ghc-hs-bibutils")
+ (version "6.6.0.0")
(source
(origin
(method url-fetch)
(arguments
`(#:phases
(modify-phases %standard-phases
+ ;; Many YAML tests (44) are failing do to changes in ghc-yaml:
+ ;; <https://github.com/jgm/pandoc-citeproc/issues/342>.
+ (add-before 'configure 'patch-tests
+ (lambda _
+ (substitute* "tests/test-pandoc-citeproc.hs"
+ (("let allTests = citeprocTests \\+\\+ biblio2yamlTests")
+ "let allTests = citeprocTests"))))
;; Tests need to be run after installation.
(delete 'check)
(add-after 'install 'post-install-check
suitable for inclusion in pandoc YAML metadata.")
(license license:bsd-3)))
-(define-public ghc-pandoc-citeproc-with-pandoc-1
- (let ((for-pandoc-1
- (package-input-rewriting
- `((,ghc-aeson . ,ghc-aeson-for-pandoc-1)
- (,ghc-yaml . ,ghc-yaml-for-pandoc-1)
- (,ghc-texmath . ,ghc-texmath-for-pandoc-1)
- (,ghc-pandoc-types . ,ghc-pandoc-types-for-pandoc-1)
- (,ghc-hslua . ,ghc-hslua-for-pandoc-1)
- (,ghc-skylighting . ,ghc-skylighting-for-pandoc-1)
- (,ghc-doctemplates . ,ghc-doctemplates-for-pandoc-1)
- (,ghc-pandoc . ,ghc-pandoc-1)))))
- (for-pandoc-1 ghc-pandoc-citeproc)))
-
(define-public ghc-union-find
(package
(name "ghc-union-find")
("ghc-utility-ht" ,ghc-utility-ht)
("ghc-data-accessor-transformers" ,ghc-data-accessor-transformers)
("ghc-data-accessor" ,ghc-data-accessor)
+ ("ghc-semigroups" ,ghc-semigroups)
("gnuplot" ,gnuplot)))
(arguments
`(#:phases
(define-public ghc-fsnotify
(package
(name "ghc-fsnotify")
- (version "0.2.1")
+ (version "0.3.0.1")
(source (origin
(method url-fetch)
(uri (string-append
"fsnotify-" version ".tar.gz"))
(sha256
(base32
- "0asl313a52qx2w6dw25g845683xsl840bwjh118nkwi5v1xipkzb"))))
+ "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-hinotify" ,ghc-hinotify)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-temporary-rc" ,ghc-temporary-rc)))
+ ("ghc-random" ,ghc-random)
+ ("ghc-shelly" ,ghc-shelly)
+ ("ghc-temporary" ,ghc-temporary)))
(home-page "https://github.com/haskell-fswatch/hfsnotify")
(synopsis "Cross platform library for file change notification.")
(description "Cross platform library for file creation, modification, and
(base32
"03zycmwrchhqvi37fdvlzz2d1vl4hy0i8xyys1zznw38qfq0h2i5"))))
(build-system haskell-build-system)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "wave.cabal"
+ (("temporary.* < 1\\.3")
+ "temporary >= 1.1 && < 1.4")))))))
(inputs
`(("ghc-cereal" ,ghc-cereal)
("ghc-data-default-class"
(license license:bsd-3)))
(define-public ghc-esqueleto
- (package
- (name "ghc-esqueleto")
- (version "2.5.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "esqueleto/esqueleto-" version ".tar.gz"))
- (sha256
- (base32
- "10n49rzqmblky7pwjnysalyy6nacmxfms8dqbsdv6hlyzr8pb69x"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-persistent" ,ghc-persistent)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-text" ,ghc-text)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)
- ("ghc-persistent-template" ,ghc-persistent-template)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (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
+ (let ((version "2.5.3")
+ (revision "1")
+ (commit "b81e0d951e510ebffca03c5a58658ad884cc6fbd"))
+ (package
+ (name "ghc-esqueleto")
+ (version (git-version version revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bitemyapp/esqueleto")
+ (commit commit)))
+ (sha256
+ (base32
+ "0lz1qxms7cfg5p3j37inlych0r2fwhm8xbarcys3df9m7jy9nixa"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:haddock? #f ; Haddock reports an internal error.
+ #:phases
+ (modify-phases %standard-phases
+ ;; This package normally runs tests for the MySQL, PostgreSQL, and
+ ;; SQLite backends. Since we only have Haskell packages for
+ ;; SQLite, we remove the other two test suites. FIXME: Add the
+ ;; other backends and run all three test suites.
+ (add-before 'configure 'remove-non-sqlite-test-suites
+ (lambda _
+ (use-modules (ice-9 rdelim))
+ (with-atomic-file-replacement "esqueleto.cabal"
+ (lambda (in out)
+ (let loop ((line (read-line in 'concat)) (deleting? #f))
+ (cond
+ ((eof-object? line) #t)
+ ((string-every char-set:whitespace line)
+ (unless deleting? (display line out))
+ (loop (read-line in 'concat) #f))
+ ((member line '("test-suite mysql\n"
+ "test-suite postgresql\n"))
+ (loop (read-line in 'concat) #t))
+ (else
+ (unless deleting? (display line out))
+ (loop (read-line in 'concat) deleting?)))))))))))
+ (inputs
+ `(("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-persistent" ,ghc-persistent)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-text" ,ghc-text)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)
+ ("ghc-persistent-template" ,ghc-persistent-template)))
+ (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
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
generated SQL and optimize it for your backend.")
- (license license:bsd-3)))
+ (license license:bsd-3))))
(define-public shellcheck
(package
(name "shellcheck")
- (version "0.4.6")
+ (version "0.5.0")
(source
(origin
(method url-fetch)
- (uri (string-append "https://github.com/koalaman/shellcheck/archive/"
- "v" version ".tar.gz"))
+ (uri (string-append
+ "https://hackage.haskell.org/package/ShellCheck/ShellCheck-"
+ version ".tar.gz"))
(sha256
(base32
- "1qkd69lc34n3l23ss9rq1azvx49bfq4hi4bmaj76rgxybscxhg0w"))
+ "0z1hscbr11hwkq8k1v0vaa947hb9m6k4cm831jk1gpj8dxrk151b"))
(file-name (string-append name "-" version ".tar.gz"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-json" ,ghc-json)
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-quickcheck" ,ghc-quickcheck)
("ghc-parsec" ,ghc-parsec)
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
(home-page "https://github.com/koalaman/shellcheck")
(define-public ghc-simple-sendfile
(package
(name "ghc-simple-sendfile")
- (version "0.2.25")
+ (version "0.2.27")
(source
(origin
(method url-fetch)
"simple-sendfile-" version ".tar.gz"))
(sha256
(base32
- "0k99j9xfcf83c55jmn202hdinhjaa4yn3dal4rvjk2w2rlhqirha"))))
+ "1bwwqzcm56m2w4ymsa054sxmpbj76h9pvb0jf8zxp8lr41cp51gn"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
(base32
"0y27gafkib0x0fn39qfn2rkgsfrm09ng35sbb5dwr7rclhnxz59l"))))
(build-system haskell-build-system)
+ (arguments
+ '(#:cabal-revision
+ ("2" "1bx70yqkn62ii17fjv3pig4hklrzkqd09zj67zzjiyjzmn04fir3")
+ ;; Two tests fail: "Discrete CDF is OK" and "Quantile is CDF inverse".
+ #:tests? #f))
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-base-orphans" ,ghc-base-orphans)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (arguments
- `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
(home-page "https://github.com/bos/mwc-random")
(synopsis "Haskell library of statistical types, data, and functions")
(description "This library provides a number of common functions
(define-public ghc-either
(package
(name "ghc-either")
- (version "4.4.1.1")
+ (version "5.0.1")
(source
(origin
(method url-fetch)
"either-" version ".tar.gz"))
(sha256
(base32
- "1lrlwqqnm6ibfcydlv5qvvssw7bm0c6yypy0rayjzv1znq7wp1xh"))))
+ "064hjfld7dkzs78sy30k5qkiva3hx24rax6dvzz5ygr2c0zypdkc"))))
(build-system haskell-build-system)
(inputs `(("ghc-bifunctors" ,ghc-bifunctors)
("ghc-exceptions" ,ghc-exceptions)
("ghc-semigroups" ,ghc-semigroups)
("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-transformers-base" ,ghc-transformers-base)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(home-page "https://github.com/ekmett/either")
(synopsis "Provides an either monad transformer for Haskell")
(description "This Haskell package provides an either monad transformer.")
(define-public ghc-rebase
(package
(name "ghc-rebase")
- (version "1.1")
+ (version "1.2.4")
(source
(origin
(method url-fetch)
"rebase-" version ".tar.gz"))
(sha256
(base32
- "1qkhnpcc4g2vd6jmbf3b6psqkan6hyawqzrwzqdd931hsb02l6ia"))))
+ "1gah2qwfpzwamnikbc5h4nv6dgvv9h16di9ka7946za3nibyasya"))))
(build-system haskell-build-system)
(inputs `(("ghc-stm" ,ghc-stm)
("ghc-hashable" ,ghc-hashable)
the community, with the missing features being added with pull-requests.")
(license license:expat)))
+(define-public ghc-rerebase
+ (package
+ (name "ghc-rerebase")
+ (version "1.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/rerebase/rerebase-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "11v6rmz7ql2rdx6mhb3lsal952lwihclfhh0m7fcnii5br0906ks"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-rebase" ,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 ``base''. For details and
+documentation please visit @uref{https://github.com/nikita-volkov/rerebase,
+the project's home page}.")
+ (license license:expat)))
+
(define-public ghc-vector-builder
(package
(name "ghc-vector-builder")
- (version "0.3.1")
+ (version "0.3.6")
(source
(origin
(method url-fetch)
"vector-builder-" version ".tar.gz"))
(sha256
(base32
- "1l6sfgd2s107zkp1qd1w6jdjcbznp31769qf99pxar087f697wvp"))))
+ "06d2pa1fb3ydrl7l6rjazqyxv5i73v65x2f5fp0ypjxfbm6jsmn8"))))
(build-system haskell-build-system)
(inputs `(("ghc-vector" ,ghc-vector)
("ghc-semigroups" ,ghc-semigroups)
("ghc-base-prelude" ,ghc-base-prelude)))
- (native-inputs `(("ghc-tasty" ,ghc-tasty)
+ (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
- ("ghc-rebase" ,ghc-rebase)))
+ ("ghc-rerebase" ,ghc-rerebase)))
(home-page "https://github.com/nikita-volkov/vector-builder")
(synopsis "Vector builder for Haskell")
(description "This Haskell package provides an API for constructing vectors.
(define-public ghc-foldl
(package
(name "ghc-foldl")
- (version "1.3.5")
+ (version "1.4.3")
(source
(origin
(method url-fetch)
"foldl-" version ".tar.gz"))
(sha256
(base32
- "10qsp7dj2xsq4q2xm6x6b12y5pq32qf7my41hnkmdwwbccvhdxb2"))))
+ "13n0ca3hw5jzqf6rxsdbhbwkn61a9zlm13f0f205s60j3sc72jzk"))))
(build-system haskell-build-system)
(inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
("ghc-primitive" ,ghc-primitive)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-hashable" ,ghc-hashable)
("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-semigroups" ,ghc-semigroups)
("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-comonad" ,ghc-comonad)
("ghc-vector-builder" ,ghc-vector-builder)))
(home-page "https://github.com/Gabriel439/Haskell-Foldl-Library")
(define-public ghc-aws
(package
(name "ghc-aws")
- (version "0.18")
+ (version "0.20")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"aws-" version "/aws-" version ".tar.gz"))
(sha256 (base32
- "0h7473wkvc5xjzx5fd5k5fp70rjq5gqmn1cpy95mswvvfsq3irxj"))))
+ "0pwpabmypi1w8rni9qfwabgn95jks4h8dyw6889mn8xzsrhdhyf0"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; Tests require AWS credentials.
(inputs
("ghc-data-default" ,ghc-data-default)
("ghc-http-conduit" ,ghc-http-conduit)
("ghc-http-types" ,ghc-http-types)
+ ("ghc-lifted-base" ,ghc-lifted-base)
("ghc-monad-control" ,ghc-monad-control)
("ghc-network" ,ghc-network)
("ghc-old-locale" ,ghc-old-locale)
(define-public ghc-monad-logger
(package
(name "ghc-monad-logger")
- (version "0.3.25.1")
+ (version "0.3.29")
(source
(origin
(method url-fetch)
"monad-logger-" version ".tar.gz"))
(sha256
(base32
- "0yv4fsi566zrn30j2g5l901lyqgmflhvzy4hji7ikcbh5d45m920"))))
+ "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv"))))
(build-system haskell-build-system)
(inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-text" ,ghc-text)
(define-public ghc-persistent
(package
(name "ghc-persistent")
- (version "2.7.3.1")
+ (version "2.8.2")
(source
(origin
(method url-fetch)
"persistent-" version ".tar.gz"))
(sha256
(base32
- "1jbvavdvr9qz5ld7vf6l1jgiadhmxx6zc4vqsdk9ivfq6d5wlg1p"))))
+ "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9"))))
(build-system haskell-build-system)
(inputs `(("ghc-old-locale" ,ghc-old-locale)
("ghc-text" ,ghc-text)
("ghc-silently" ,ghc-silently)
("ghc-fast-logger" ,ghc-fast-logger)
("ghc-scientific" ,ghc-scientific)
- ("ghc-tagged" ,ghc-tagged)))
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-void" ,ghc-void)))
(native-inputs `(("ghc-hspec" ,ghc-hspec)))
(home-page "https://www.yesodweb.com/book/persistent")
(synopsis "Type-safe, multi-backend data serialization for Haskell")
(define-public ghc-persistent-template
(package
(name "ghc-persistent-template")
- (version "2.5.3.1")
+ (version "2.5.4")
(source
(origin
(method url-fetch)
"persistent-template-" version ".tar.gz"))
(sha256
(base32
- "0449piw3n02q7dag7k1pakfmzmf3ms4wk1qmnagczpm1ckajinwd"))))
+ "008afcy7zbw7bzp9jww8gdldb51kfm0fg4p0x4xcp61gx4679bjc"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "03qgwk32krldph3blw5agiqcpccr3649hajyn8wm9k71zz82dpn6")))
(inputs `(("ghc-persistent" ,ghc-persistent)
("ghc-monad-control" ,ghc-monad-control)
("ghc-text" ,ghc-text)
(define-public ghc-persistent-sqlite
(package
(name "ghc-persistent-sqlite")
- (version "2.6.4")
+ (version "2.8.2")
(source
(origin
(method url-fetch)
"persistent-sqlite-" version ".tar.gz"))
(sha256
(base32
- "16mc2ra0hbyyc8ckjlxxc11bpskdymbr8c3g6ih6wzik639xprbm"))))
+ "1chbmvjz46smhgnzhha3bbkhys3fys6dip1jr4v7xp1jf78zbyp6"))))
(build-system haskell-build-system)
(inputs `(("ghc-persistent" ,ghc-persistent)
("ghc-unliftio-core" ,ghc-unliftio-core)
(define-public ghc-chart
(package
(name "ghc-chart")
- (version "1.8.3")
+ (version "1.9")
(source
(origin
(method url-fetch)
"Chart-" version ".tar.gz"))
(sha256
(base32
- "13s64fhb2pmkdmx5bkgbgcn25qjihs364fvr47a1dw25f804kiy1"))))
+ "1f5azj17y8xsb3gjhf7gg1gnnlq12rxkmfjmgcly314d7vghs05z"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-locale" ,ghc-old-locale)
("ghc-attoparsec" ,ghc-attoparsec-bootstrap)))
(properties '(hidden? #t))))
+(define-public ghc-rio
+ (package
+ (name "ghc-rio")
+ (version "0.1.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/rio/rio-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "064h8a4hp53a479d3ak0vmqbx8hi0cpg7zn4wp23rjy26dka8p7g"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'add-setup-script
+ (lambda _
+ ;; The usual "Setup.hs" script is missing from the source.
+ (with-output-to-file "Setup.hs"
+ (lambda ()
+ (format #t "import Distribution.Simple~%")
+ (format #t "main = defaultMain~%"))))))))
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-microlens" ,ghc-microlens)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-text" ,ghc-text)
+ ("ghc-typed-process" ,ghc-typed-process)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/commercialhaskell/rio#readme")
+ (synopsis "A standard library 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
+functions and lazy I/O. The guiding principle here is:
+@itemize
+@item If something is safe to use in general and has no expected naming
+conflicts, expose it.
+@item If something should not always be used, or has naming conflicts,
+expose it from another module in the hierarchy.
+@end itemize")
+ (license license:expat)))
+
+(define-public ghc-cairo
+ (package
+ (name "ghc-cairo")
+ (version "0.13.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/cairo/"
+ "cairo-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:modules ((guix build haskell-build-system)
+ (guix build utils)
+ (ice-9 match)
+ (srfi srfi-26))
+ #:phases
+ (modify-phases %standard-phases
+ ;; FIXME: This is a copy of the standard configure phase with a tiny
+ ;; difference: this package needs the -package-db flag to be passed
+ ;; to "runhaskell" in addition to the "configure" action, because it
+ ;; depends on gtk2hs-buildtools, which provide setup hooks. Without
+ ;; this option the Setup.hs file cannot be evaluated. The
+ ;; haskell-build-system should be changed to pass "-package-db" to
+ ;; "runhaskell" in any case.
+ (replace 'configure
+ (lambda* (#:key outputs inputs tests? (configure-flags '())
+ #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (input-dirs (match inputs
+ (((_ . dir) ...)
+ dir)
+ (_ '())))
+ (ghc-path (getenv "GHC_PACKAGE_PATH"))
+ (params (append `(,(string-append "--prefix=" out))
+ `(,(string-append "--libdir=" out "/lib"))
+ `(,(string-append "--bindir=" out "/bin"))
+ `(,(string-append
+ "--docdir=" out
+ "/share/doc/" ((@@ (guix build haskell-build-system)
+ package-name-version) out)))
+ '("--libsubdir=$compiler/$pkg-$version")
+ '("--package-db=../package.conf.d")
+ '("--global")
+ `(,@(map
+ (cut string-append "--extra-include-dirs=" <>)
+ (search-path-as-list '("include") input-dirs)))
+ `(,@(map
+ (cut string-append "--extra-lib-dirs=" <>)
+ (search-path-as-list '("lib") input-dirs)))
+ (if tests?
+ '("--enable-tests")
+ '())
+ configure-flags)))
+ (unsetenv "GHC_PACKAGE_PATH")
+ (apply invoke "runhaskell" "-package-db=../package.conf.d"
+ "Setup.hs" "configure" params)
+ (setenv "GHC_PACKAGE_PATH" ghc-path)
+ #t))))))
+ (inputs
+ `(("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-text" ,ghc-text)
+ ("cairo" ,cairo)))
+ (native-inputs
+ `(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools)
+ ("pkg-config" ,pkg-config)))
+ (home-page "http://projects.haskell.org/gtk2hs/")
+ (synopsis "Haskell bindings to the Cairo vector graphics library")
+ (description
+ "Cairo is a library to render high quality vector graphics. There exist
+various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG
+documents, amongst others.")
+ (license license:bsd-3)))
+
+(define-public ghc-chart-cairo
+ (package
+ (name "ghc-chart-cairo")
+ (version "1.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/Chart-cairo/"
+ "Chart-cairo-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-cairo" ,ghc-cairo)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-operational" ,ghc-operational)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-chart" ,ghc-chart)))
+ (home-page "https://github.com/timbod7/haskell-chart/wiki")
+ (synopsis "Cairo backend for Charts")
+ (description "This package provides a Cairo vector graphics rendering
+backend for the Charts library.")
+ (license license:bsd-3)))
+
+(define-public ghc-atomic-write
+ (package
+ (name "ghc-atomic-write")
+ (version "0.2.0.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/atomic-write/atomic-write-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1iaq0hprxcv0sl1sgwcgmm87zraf738va1bciwnx2jkk3k1v9iyv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-text" ,ghc-text)))
+ (native-inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-text" ,ghc-text)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/stackbuilders/atomic-write")
+ (synopsis "Atomically write to a file")
+ (description
+ "Atomically write to a file on POSIX-compliant systems while preserving
+permissions. @code{mv} is an atomic operation. This makes it simple to write
+to a file atomically just by using the @code{mv} operation. However, this
+will destroy the permissions on the original file. This library preserves
+permissions while atomically writing to a file.")
+ (license license:expat)))
+
+(define-public ghc-cereal-conduit
+ (package
+ (name "ghc-cereal-conduit")
+ (version "0.8.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cereal-conduit/cereal-conduit-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1srr7agvgfw78q5s1npjq5sgynvhjgllpihiv37ylkwqm4c4ap6r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-cereal" ,ghc-cereal)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/snoyberg/conduit")
+ (synopsis "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits")
+ (description
+ "This package turn @code{Data.Serialize} @code{Gets} and @code{Puts} into
+@code{Sources}, @code{Sinks}, and @code{Conduits}.")
+ (license license:bsd-3)))
+
+(define-public ghc-weigh
+ (package
+ (name "ghc-weigh")
+ (version "0.0.12")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/weigh/"
+ "weigh-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0zw2a997gxgdzqmd7j730kxgynzmjvvlkw84dajmfzf1v9pbij7x"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-split" ,ghc-split)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/fpco/weigh#readme")
+ (synopsis "Measure allocations of a Haskell functions/values")
+ (description "This package provides tools to measure the memory usage of a
+Haskell value or function.")
+ (license license:bsd-3)))
+
+(define-public ghc-linear
+ (package
+ (name "ghc-linear")
+ (version "1.20.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/linear/"
+ "linear-" version ".tar.gz"))
+ (sha256
+ (base32
+ "046vkvxlb0s286qr55s0c6db0rlwbm1cmlmwhrrkqbkzhfcipgay"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-adjunctions" ,ghc-adjunctions)
+ ("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-bytes" ,ghc-bytes)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-reflection" ,ghc-reflection)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-void" ,ghc-void)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-simple-reflect" ,ghc-simple-reflect)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-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
+vector spaces.")
+ (license license:bsd-3)))
+
;;; haskell.scm ends here
HCoop / jackhill / guix / guix.git / blobdiff