#:use-module (gnu packages pcre)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages sdl)
+ #:use-module (gnu packages web)
#:use-module (gnu packages xml)
#:use-module (gnu packages xorg)
#:use-module (guix build-system haskell)
module for more details.")
(license license:bsd-3)))
+(define-public ghc-active
+ (package
+ (name "ghc-active")
+ (version "0.2.0.14")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "active/active-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0x3b4ln6csa554qls28wbxvclkbdz3yi60i1m0q5ing0cs16fifz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-linear" ,ghc-linear)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/active")
+ (synopsis "Abstractions for animation")
+ (description "This package defines an @code{Active} abstraction for
+time-varying values with finite start and end times. It is used for
+describing animations within the
+@url{https://archives.haskell.org/projects.haskell.org/diagrams/,
+diagrams framework}.")
+ (license license:bsd-3)))
+
(define-public ghc-adjunctions
(package
(name "ghc-adjunctions")
(base32
"1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "1yfsjx7dqikg3hvld7i91xfsg5lawmr5980lvfd794sybmgxsf17")))
(inputs
`(("ghc-profunctors" ,ghc-profunctors)
("ghc-comonad" ,ghc-comonad)
ghc-aeson.")
(license license:bsd-3)))
+(define-public ghc-aeson-diff
+ (package
+ (name "ghc-aeson-diff")
+ (version "1.1.0.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "aeson-diff/aeson-diff-" version ".tar.gz"))
+ (sha256
+ (base32
+ "01d48pd7d1mb9cd5yxfajln8rmjdjq8ch91s0lav4qw1azv6vp2r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-edit-distance-vector" ,ghc-edit-distance-vector)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-glob" ,ghc-glob)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-doctest" ,ghc-doctest)
+ ("hlint" ,hlint)))
+ (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
+style of the @command{diff} and @command{patch} commands available on many
+systems.")
+ (license license:bsd-3)))
+
(define-public ghc-alex
(package
(name "ghc-alex")
needed by both alsa-seq and alsa-pcm.")
(license license:bsd-3)))
+(define-public ghc-alsa-mixer
+ (package
+ (name "ghc-alsa-mixer")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "mirror://hackage/package/alsa-mixer/alsa-mixer-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "00ny2p3276jilidjs44npc8zmbhynz3f2lpmlwwl6swwx5yijsnb"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-alsa-core" ,ghc-alsa-core)))
+ (native-inputs `(("ghc-c2hs" ,ghc-c2hs)))
+ (home-page "https://github.com/ttuegel/alsa-mixer")
+ (synopsis "Bindings to the ALSA simple mixer API")
+ (description
+ "This package provides bindings to the ALSA simple mixer API.")
+ (license license:bsd-3)))
+
(define-public ghc-annotated-wl-pprint
(package
(name "ghc-annotated-wl-pprint")
(define-public ghc-atomic-primops
(package
(name "ghc-atomic-primops")
- (version "0.8.2")
+ (version "0.8.3")
(source
(origin
(method url-fetch)
"/atomic-primops-" version ".tar.gz"))
(sha256
(base32
- "0cyr2x6xqz6s233znrz9rnrfj56m9bmnawwnka0lsqqy1hp8gy37"))))
+ "03n5dmyplrqgbyf8dr91izkxci7gkl3i3fnp82i5ld869zrgjfh0"))))
(build-system haskell-build-system)
(inputs `(("ghc-primitive" ,ghc-primitive)))
(home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
functions.")
(license license:bsd-3)))
+(define-public ghc-bitarray
+ (package
+ (name "ghc-bitarray")
+ (version "0.0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "bitarray/bitarray-" version ".tar.gz"))
+ (sha256
+ (base32
+ "00nqd62cbh42qqqvcl6iv1i9kbv0f0mkiygv4j70wfh5cl86yzxj"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "10fk92v9afjqk43zi621jxl0n8kci0xjj32lz3vqa9xbh67zjz45")))
+ (home-page "https://hackage.haskell.org/package/bitarray")
+ (synopsis "Mutable and immutable bit arrays")
+ (description "The package provides mutable and immutable bit arrays.")
+ (license license:bsd-3)))
+
(define-public ghc-blaze-builder
(package
(name "ghc-blaze-builder")
(define-public ghc-bzlib-conduit
(package
(name "ghc-bzlib-conduit")
- (version "0.3.0.1")
+ (version "0.3.0.2")
(source
(origin
(method url-fetch)
"bzlib-conduit-" version ".tar.gz"))
(sha256
(base32
- "0fd2hnr782s7qgipazg2yxwia9qqhkvm9bcm90773c3zkxa13n23"))))
+ "0a21zin5plsl37hkxh2jv8cxwyjrbs2fy7n5cyrzgdaa7lmp6b7b"))))
(build-system haskell-build-system)
(inputs
`(("ghc-bindings-dsl" ,ghc-bindings-dsl)
(define-public ghc-chart
(package
(name "ghc-chart")
- (version "1.9")
+ (version "1.9.1")
(source
(origin
(method url-fetch)
"Chart-" version ".tar.gz"))
(sha256
(base32
- "1f5azj17y8xsb3gjhf7gg1gnnlq12rxkmfjmgcly314d7vghs05z"))))
+ "1pn735k9ifxlb9mdh8xy7wi22cxni8xyr28n8zx9w0j6vprcg89l"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-locale" ,ghc-old-locale)
(define-public ghc-chart-cairo
(package
(name "ghc-chart-cairo")
- (version "1.9")
+ (version "1.9.1")
(source
(origin
(method url-fetch)
"Chart-cairo-" version ".tar.gz"))
(sha256
(base32
- "0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr"))))
+ "0hknj4rsjf2m8p5pyq5zff8ai7v80yvmxb5c6n0bkgxs4317nbl9"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-locale" ,ghc-old-locale)
(define-public ghc-conduit
(package
(name "ghc-conduit")
- (version "1.3.0.3")
+ (version "1.3.1.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"conduit/conduit-" version ".tar.gz"))
(sha256
(base32
- "1sangm0qqi9dzlq95746a3kl14k8b09592a423shxjf2a0b1yx5v"))))
+ "18izjgff4pmrknc8py06yvg3g6x27nx0rzmlwjxcflwm5v4szpw4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-exceptions" ,ghc-exceptions)
(define-public ghc-conduit-algorithms
(package
(name "ghc-conduit-algorithms")
- (version "0.0.8.1")
+ (version "0.0.11.0")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "07gx2q3d1bbfw14q41rmqg0i4m018pci10lswc0k1ij6lw7sb9fd"))))
+ "0c1jwz30kkvimx7lb61782yk0kyfamrf5bqc3g1h7g51lk8bbv9i"))))
(build-system haskell-build-system)
(inputs
`(("ghc-async" ,ghc-async)
("ghc-conduit" ,ghc-conduit)
("ghc-conduit-combinators" ,ghc-conduit-combinators)
("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-conduit-zstd" ,ghc-conduit-zstd)
("ghc-exceptions" ,ghc-exceptions)
("ghc-lzma-conduit" ,ghc-lzma-conduit)
("ghc-monad-control" ,ghc-monad-control)
(define-public ghc-conduit-extra
(package
(name "ghc-conduit-extra")
- (version "1.3.1.1")
+ (version "1.3.4")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0jaj350vv6mbb26gdwcqz4gwzfzrjydv5pis2da49wz1npbakcfw"))))
+ "1d853d39vj5pb8yxfcsnjwdzqzkm34ixzbnba8bslpihb7182wxi"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
@code{haskell-platform} packages and @code{conduit}.")
(license license:expat)))
+(define-public ghc-conduit-zstd
+ (package
+ (name "ghc-conduit-zstd")
+ (version "0.0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "conduit-zstd/conduit-zstd-" version ".tar.gz"))
+ (sha256
+ (base32
+ "04h7w2903hgw4gjcx2pg29yinnmfapawvc19hd3r57rr12fzb0c6"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-zstd" ,ghc-zstd)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-conduit-combinators" ,ghc-conduit-combinators)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-th" ,ghc-test-framework-th)))
+ (home-page "https://github.com/luispedro/conduit-zstd#readme")
+ (synopsis "Conduit-based ZStd Compression")
+ (description "Zstandard compression packaged as a conduit. This is
+a very thin wrapper around the
+@url{https://github.com/facebookexperimental/hs-zstd/, official hs-zstd
+interface}.")
+ (license license:expat)))
+
(define-public ghc-configurator
(package
(name "ghc-configurator")
"This module provides set and multiset operations on ordered lists.")
(license license:bsd-3)))
+(define-public ghc-dbus
+ (package
+ (name "ghc-dbus")
+ (version "1.2.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "mirror://hackage/package/dbus/dbus-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0ypkjlw9fn65g7p28kb3p82glk7qs7p7vyffccw7qxa3z57s12w5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-cereal" ,ghc-cereal)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-network" ,ghc-network)
+ ("ghc-random" ,ghc-random)
+ ("ghc-split" ,ghc-split)
+ ("ghc-th-lift" ,ghc-th-lift)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-xml-conduit" ,ghc-xml-conduit)
+ ("ghc-xml-types" ,ghc-xml-types)))
+ (native-inputs
+ `(("ghc-extra" ,ghc-extra)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ ;; FIXME - Some tests try to talk to network.
+ (arguments `(#:tests? #f))
+ (home-page "https://github.com/rblaze/haskell-dbus")
+ (synopsis "Client library for the D-Bus IPC system")
+ (description
+ "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
+it replaces earlier protocols such as CORBA and DCOP. This library
+is an implementation of the D-Bus protocol in Haskell. It can be used
+to add D-Bus support to Haskell applications, without the awkward
+interfaces common to foreign bindings.")
+ (license license:asl2.0)))
+
(define-public ghc-deepseq-generics
(package
(name "ghc-deepseq-generics")
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
- ("2" "1pnidf8w8x0w5fsqgv8hhrw07slmhxwy5x4fikgk0bd6k76aqicb")))
+ ("4" "0928s2qnbqsjzrm94x88rvmvbigfmhcyp4m73gw6asinp2qg1kii")))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
and parsers with useful semantics.")
(license license:bsd-3)))
+(define-public ghc-diagrams-core
+ (package
+ (name "ghc-diagrams-core")
+ (version "1.4.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "diagrams-core/diagrams-core-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0qgb43vy23g4fxh3nmxfq6jyp34imqvkhgflaa6rz0iq6d60gl43"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-monoid-extras" ,ghc-monoid-extras)
+ ("ghc-dual-tree" ,ghc-dual-tree)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-linear" ,ghc-linear)
+ ("ghc-adjunctions" ,ghc-adjunctions)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-profunctors" ,ghc-profunctors)))
+ (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+ (synopsis "Core libraries for diagrams embedded domain-specific language")
+ (description "This package provides the core modules underlying
+diagrams, an embedded domain-specific language for compositional,
+declarative drawing.")
+ (license license:bsd-3)))
+
+(define-public ghc-diagrams-lib
+ (package
+ (name "ghc-diagrams-lib")
+ (version "1.4.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "diagrams-lib/diagrams-lib-" version ".tar.gz"))
+ (sha256
+ (base32
+ "175yzi5kw4yd8ykdkpf64q85c7j3p89l90m3h6qcsx9ipv6av9r5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-monoid-extras" ,ghc-monoid-extras)
+ ("ghc-dual-tree" ,ghc-dual-tree)
+ ("ghc-diagrams-core" ,ghc-diagrams-core)
+ ("ghc-diagrams-solve" ,ghc-diagrams-solve)
+ ("ghc-active" ,ghc-active)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-fingertree" ,ghc-fingertree)
+ ("ghc-intervals" ,ghc-intervals)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-juicypixels" ,ghc-juicypixels)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-linear" ,ghc-linear)
+ ("ghc-adjunctions" ,ghc-adjunctions)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-fsnotify" ,ghc-fsnotify)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-cereal" ,ghc-cereal)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-numeric-extras" ,ghc-numeric-extras)))
+ (arguments
+ `(#:cabal-revision
+ ("3" "157y2qdsh0aczs81vzlm377mks976mpv6y3aqnchwsnr7apzp8ai")))
+ (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+ (synopsis "Embedded domain-specific language for declarative graphics")
+ (description "Diagrams is a flexible, extensible embedded
+domain-specific language (EDSL) for creating graphics of many types.
+Graphics can be created in arbitrary vector spaces and rendered with
+multiple backends. This package provides a standard library of
+primitives and operations for creating diagrams.")
+ (license license:bsd-3)))
+
+(define-public ghc-diagrams-solve
+ (package
+ (name "ghc-diagrams-solve")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "diagrams-solve/diagrams-solve-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "17agchqkmj14b17sw50kzxq4hm056g5d8yy0wnqn5w8h1d0my7x4"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("5" "1yl8cs05fzqcz49p601am1ij66m9pa70yamhfxgcvya2pf8nimlf")))
+ (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+ (synopsis "Pure Haskell solver routines used by diagrams")
+ (description "This library provides Pure Haskell solver routines for
+use by the
+@url{https://archives.haskell.org/projects.haskell.org/diagrams/,
+diagrams framework}. It currently includes routines for finding real
+roots of low-degree (@math{n < 5}) polynomials, and solving tridiagonal
+and cyclic tridiagonal linear systems.")
+ (license license:bsd-3)))
+
+(define-public ghc-diagrams-svg
+ (package
+ (name "ghc-diagrams-svg")
+ (version "1.4.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "diagrams-svg/diagrams-svg-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1lnyxx45yawqas7hmvvannwaa3ycf1l9g40lsl2m8sl2ja6vcmal"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-diagrams-core" ,ghc-diagrams-core)
+ ("ghc-diagrams-lib" ,ghc-diagrams-lib)
+ ("ghc-monoid-extras" ,ghc-monoid-extras)
+ ("ghc-svg-builder" ,ghc-svg-builder)
+ ("ghc-juicypixels" ,ghc-juicypixels)
+ ("ghc-split" ,ghc-split)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (arguments
+ `(#:cabal-revision
+ ("2" "15sn85xaachw4cj56w61bjcwrbf4qmnkfl8mbgdapxi5k0y4f2qv")))
+ (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/")
+ (synopsis "Scalable Vector Grpahics backend for the diagrams framework")
+ (description "This package provides a modular backend for rendering
+diagrams created with the diagrams embedded domain-specific
+language (EDSL) to Scalable Vector Graphics (SVG) files.")
+ (license license:bsd-3)))
+
+(define-public ghc-dictionary-sharing
+ (package
+ (name "ghc-dictionary-sharing")
+ (version "0.1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "dictionary-sharing/dictionary-sharing-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "00aspv943qdqhlk39mbk00kb1dsa5r0caj8sslrn81fnsn252fwc"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("3" "1mn7jcc7h3b8f1pn9zigqp6mc2n0qb66lms5qnrx4zswdv5w9439")))
+ (home-page "https://hackage.haskell.org/package/dictionary-sharing")
+ (synopsis "Sharing/memoization of class members")
+ (description "This library provides tools for ensuring that class
+members are shared.")
+ (license license:bsd-3)))
+
(define-public ghc-diff
(package
(name "ghc-diff")
between double precision floating point and text.")
(license license:bsd-3)))
+(define-public ghc-dual-tree
+ (package
+ (name "ghc-dual-tree")
+ (version "0.2.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "dual-tree/dual-tree-" version ".tar.gz"))
+ (sha256
+ (base32
+ "17kdfnf0df0z5pkiifxrlmyd1xd7hjjaazd2kzyajl0gd00vbszx"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-newtype-generics" ,ghc-newtype-generics)
+ ("ghc-monoid-extras" ,ghc-monoid-extras)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-testing-feat" ,ghc-testing-feat)))
+ (home-page "https://hackage.haskell.org/package/dual-tree")
+ (synopsis "Rose trees with cached and accumulating monoidal annotations")
+ (description "Rose (@math{n}-ary) trees with both upwards- (i.e.
+cached) and downwards-traveling (i.e. accumulating) monoidal
+annotations. This is used as the core data structure underlying the
+@url{https://archives.haskell.org/projects.haskell.org/diagrams/,
+diagrams framework}, but potentially has other applications as well.")
+ (license license:bsd-3)))
+
(define-public ghc-easy-file
(package
(name "ghc-easy-file")
(lambda _
(substitute* "edit-distance.cabal"
(("QuickCheck >= 2\\.4 && <2\\.9")
- "QuickCheck >= 2.4 && < 2.12")))))))
+ "QuickCheck >= 2.4 && < 2.14")))))))
(inputs
`(("ghc-random" ,ghc-random)
("ghc-test-framework" ,ghc-test-framework)
Damerau-Levenshtein algorithms.")
(license license:bsd-3)))
+(define-public ghc-edit-distance-vector
+ (package
+ (name "ghc-edit-distance-vector")
+ (version "1.0.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "edit-distance-vector/edit-distance-vector-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "07qgc8dyi9kkzkd3xcd78wdlljy0xwhz65b4r2qg2piidpcdvpxp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+ (home-page "https://github.com/thsutton/edit-distance-vector")
+ (synopsis "Calculate edit distances and edit scripts between vectors")
+ (description "This package provides implementation of the
+Wagner-Fischer dynamic programming algorithm to find the optimal edit
+script and cost between two sequences. The implementation in this
+package is specialised to sequences represented with @code{Data.Vector}
+but is otherwise agnostic to:
+@itemize
+@item The type of values in the vectors;
+@item The type representing edit operations; and
+@item The type representing the cost of operations.
+@end itemize")
+ (license license:bsd-3)) )
+
(define-public ghc-either
(package
(name "ghc-either")
(define-public ghc-equivalence
(package
(name "ghc-equivalence")
- (version "0.3.2")
+ (version "0.3.5")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/equivalence"
"/equivalence-" version ".tar.gz"))
(sha256
- (base32 "0a85bdyyvjqs5z4kfhhf758210k9gi9dv42ik66a3jl0z7aix8kx"))))
+ (base32 "167njzd1cf32aa7br90rjafrxy6hw3fxkk8awifqbxjrcwm5maqp"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stmonadtrans" ,ghc-stmonadtrans)
("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/pa-ba/equivalence")
(synopsis "Maintaining an equivalence relation implemented as union-find")
(description
(license license:bsd-3)))
(define-public ghc-esqueleto
- (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)))
- (file-name (git-file-name name version))
- (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-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
+ (package
+ (name "ghc-esqueleto")
+ (version "3.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "esqueleto/esqueleto-" version ".tar.gz"))
+ (sha256
+ (base32
+ "187c098h2xyf2nhifkdy2bqfl6iap7a93mzwd2kirl5yyicpc9zy"))))
+ (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-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 ghc-exactprint
(package
(define-public ghc-feed
(package
(name "ghc-feed")
- (version "1.0.0.0")
+ (version "1.2.0.1")
(source
(origin
(method url-fetch)
"feed/feed-" version ".tar.gz"))
(sha256
(base32
- "05rgg7x1984mgfhkmz792xj8lhwjgznixhygzr8blf517lns2nck"))))
+ "004lwdng4slj6yl8mgscr3cgj0zzc8hzkf4450dby2l6cardg4w0"))))
(build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("4" "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d")))
(inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-old-locale" ,ghc-old-locale)
("ghc-xml-types" ,ghc-xml-types)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
+ ("ghc-markdown-unlit" ,ghc-markdown-unlit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
(home-page "https://github.com/bergmark/feed")
file contents, and more.")
(license license:bsd-3)))
+(define-public ghc-filepath-bytestring
+ (package
+ (name "ghc-filepath-bytestring")
+ (version "1.4.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/filepath-bytestring/"
+ "filepath-bytestring-" version ".tar.gz"))
+ (sha256
+ (base32
+ "06shdskjj391hb9295slm9gg2rbn5fdq5v6fg0mgn3yl5dv8q5dx"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "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
+@code{filepath} library, operating on @code{RawFilePath} values rather than
+@code{FilePath} values to get the speed benefits of using @code{ByteStrings}.")
+ (license license:bsd-3)))
+
(define-public ghc-findbin
(package
(name "ghc-findbin")
(define-public ghc-foldl
(package
(name "ghc-foldl")
- (version "1.4.3")
+ (version "1.4.5")
(source
(origin
(method url-fetch)
"foldl-" version ".tar.gz"))
(sha256
(base32
- "13n0ca3hw5jzqf6rxsdbhbwkn61a9zlm13f0f205s60j3sc72jzk"))))
+ "19qjmzc7gaxfwgqbgy0kq4vhbxvh3qjnwsxnc7pzwws2if5bv80b"))))
(build-system haskell-build-system)
(inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
("ghc-primitive" ,ghc-primitive)
(base32
"0q6kx57ygmznlpf8n499hid4x6mj3180paijx0a8dgi9hh7man61"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; This test is broken. For details, see
+ ;; https://github.com/haskell-foundation/foundation/issues/530
+ (add-after 'unpack 'patch-tests
+ (lambda _
+ (substitute* "tests/Test/Foundation/Number.hs"
+ ((", testDividible proxy") ""))
+ #t)))))
(inputs `(("ghc-basement" ,ghc-basement)))
(home-page "https://github.com/haskell-foundation/foundation")
(synopsis "Alternative prelude with batteries and no dependencies")
(sha256
(base32 "1y0m0bw5zpm1y1y6d9qmxj3swl8j8hlw1shxbr5awycf6k884ssb"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "03fg4vfm1wgq4mylggawdx0bfvbbjmdn700sqx7v3hk1bx0kjfzh")))
(home-page "https://github.com/danr/geniplate")
(synopsis "Use Template Haskell to generate Uniplate-like functions")
(description
properties for functions operating on them.")
(license license:expat)))
+(define-public ghc-getopt-generics
+ (package
+ (name "ghc-getopt-generics")
+ (version "0.13.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "getopt-generics/getopt-generics-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1rszkcn1rg38wf35538ljk5bbqjc57y9sb3a0al7qxm82gy8yigr"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-generics-sop" ,ghc-generics-sop)
+ ("ghc-tagged" ,ghc-tagged)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-silently" ,ghc-silently)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/soenkehahn/getopt-generics")
+ (synopsis "Create command line interfaces with ease")
+ (description "This library provides tools to create command line
+interfaces with ease.")
+ (license license:bsd-3)))
+
(define-public ghc-gitrev
(package
(name "ghc-gitrev")
@end enumerate\n")
(license license:bsd-3)))
+(define-public ghc-groups
+ (package
+ (name "ghc-groups")
+ (version "0.4.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "groups/groups-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0ggkygkyxw5ga4cza82bjvdraavl294k0h6b62d2px7z3nvqhifx"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/groups")
+ (synopsis "Haskell 98 groups")
+ (description "This package provides Haskell 98 groups. A group is a
+monoid with invertibility.")
+ (license license:bsd-3)))
+
(define-public ghc-gtk2hs-buildtools
(package
(name "ghc-gtk2hs-buildtools")
- (version "0.13.4.0")
+ (version "0.13.5.4")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0yg6xmylgpylmnh5g33qwwn5x9bqckdvvv4czqzd9vrr12lnnghg"))))
+ "1flxsacxwmabzzalhn8558kmj95z01c0lmikrn56nxh7p62nxm25"))))
(build-system haskell-build-system)
(inputs
`(("ghc-random" ,ghc-random)
"08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v"))))
(build-system haskell-build-system)
(arguments
- `(#:tests? #f)) ; Tests fail because of framework updates.
+ `(#:cabal-revision
+ ("6" "1xs2nkzlvkdz8g27yzfxbjdbdadfmgiydnlpn5dm77cg18r495ay")
+ #:tests? #f)) ; Tests fail because of framework updates.
(inputs
`(("ghc-base16-bytestring" ,ghc-base16-bytestring)
("ghc-base64-bytestring" ,ghc-base64-bytestring)
(define-public ghc-haddock
(package
(name "ghc-haddock")
- (version "2.19.0.1")
+ (version "2.22.0")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7"))))
+ "1k42z2zh550rl93c8pa9cg2xsanp6wvb031xvan6cmngnplmdib6"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
- ;; There are four test suites that require the ghc-haddock-test
- ;; package, which no longer builds with GHC 8.4.3. This phase
- ;; removes these four test suites from the Cabal file, so that we
- ;; do not need ghc-haddock-test as an input.
- (add-before 'configure 'remove-haddock-test-test-suites
+ ;; The release tarball for 2.22.0 is missing the test data for
+ ;; the Hoogle test, causing it to fail. This is fixed in the
+ ;; next release, but for now we disable it.
+ (add-before 'configure 'remove-hoogle-test
(lambda _
(use-modules (ice-9 rdelim))
(with-atomic-file-replacement "haddock.cabal"
((string-every char-set:whitespace line)
(unless deleting? (display line out))
(loop (read-line in 'concat) #f))
- ((member line '("test-suite html-test\n"
- "test-suite hypsrc-test\n"
- "test-suite latex-test\n"
- "test-suite hoogle-test\n"))
+ ((string=? line "test-suite hoogle-test\n")
(loop (read-line in 'concat) #t))
(else
(unless deleting? (display line out))
- (loop (read-line in 'concat) deleting?)))))))))))
+ (loop (read-line in 'concat) deleting?))))))))
+ (add-before 'check 'add-haddock-to-path
+ (lambda _
+ (setenv "PATH" (string-append (getcwd) "/dist/build/haddock"
+ ":" (getenv "PATH")))
+ #t)))))
(inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
(native-inputs
- `(("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 ghc-haddock-api
(package
(name "ghc-haddock-api")
- (version "2.19.0.1")
+ (version "2.22.0")
(source
(origin
(method url-fetch)
"https://hackage.haskell.org/package/haddock-api/haddock-api-"
version
".tar.gz"))
+ (patches (search-patches "ghc-haddock-api-fix-haddock.patch"))
(sha256
(base32
- "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3"))))
+ "149q4zlf4m7wcrr4af2n2flh0jxjsypshbc229vsj1m0kmz4z014"))))
(build-system haskell-build-system)
(arguments
`(#: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")))))))
+ (("QuickCheck \\^>= 2\\.11")
+ "QuickCheck ^>= 2.13")
+ (("hspec >= 2\\.4\\.4 && < 2\\.6")
+ "hspec >= 2.4.4 && < 2.8")))))))
(inputs
`(("ghc-paths" ,ghc-paths)
("ghc-haddock-library" ,ghc-haddock-library)))
(define-public ghc-haddock-library
(package
(name "ghc-haddock-library")
- (version "1.5.0.1")
+ (version "1.7.0")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1cmbg8l5xrwpliclwy3l057raypjqy0hsg1h1743ahaj8gq10b7z"))
- (patches (search-patches
- "ghc-haddock-library-unbundle.patch"))
- (modules '((guix build utils)))
- (snippet '(begin
- (delete-file-recursively "vendor")
- #t))))
+ "04fhcjk0pvsaqvsgp2w06cv2qvshq1xs1bwc157q4lmkgr57khp7"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
+ ;; Since there is no revised Cabal file upstream, we have to
+ ;; patch it manually.
(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")
+ (("hspec\\s*>= 2.4.4 && < 2.6") "hspec")
+ (("QuickCheck\\s*\\^>= 2.11") "QuickCheck"))
#t)))))
(native-inputs
`(("ghc-base-compat" ,ghc-base-compat)
the ‘haddock’ package.")
(license license:bsd-3)))
+;; This package is needed for testing 'ghc-haddock'. It is no longer
+;; published to Hackage, but it is maintained in the Haddock Git
+;; repository.
+(define ghc-haddock-test
+ (package
+ (name "ghc-haddock-test")
+ (version "2.22.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/haskell/haddock.git")
+ (commit (string-append "haddock-" version "-release"))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1ywxmqqan10gs0ppybdmdgsmvkzkpw7yirj2rw4qylg3x49a9zca"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'change-directory
+ (lambda _
+ (chdir "haddock-test"))))))
+ (inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-xml" ,ghc-xml)))
+ (home-page "http://www.haskell.org/haddock/")
+ (synopsis "Test utilities for Haddock")
+ (description "This package provides test utilities for Haddock.")
+ (license license:bsd-3)
+ (properties '((hidden? #t)))))
+
(define-public ghc-half
(package
(name "ghc-half")
(define-public ghc-hindent
(package
(name "ghc-hindent")
- (version "5.3.0")
+ (version "5.3.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0wkfik7mvqskk23kyh7ybgnlh3j9j1ym7d3ncahsbli9w654b7xg"))))
+ "008s8zm9qs972b7v5kkmr8l3i9kc6zm7yj33mkw6dv69b7h3c01l"))))
(build-system haskell-build-system)
(arguments
`(#:modules ((guix build haskell-build-system)
(define-public ghc-hpack
(package
(name "ghc-hpack")
- (version "0.28.2")
+ (version "0.31.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/hpack/"
"hpack-" version ".tar.gz"))
+ (patches (search-patches "ghc-hpack-fix-tests.patch"))
(sha256
(base32
- "18w0h76jdp3mk9vin8da9iz3cwhcxmw787xy8wlh8bxcpcr16q5r"))))
+ "1l2d6185lawwhsj70swxkvcacm0hvcn9qsrlx4ph4gs6k578603g"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-http-client" ,ghc-http-client)
("ghc-http-client-tls" ,ghc-http-client-tls)
("ghc-http-types" ,ghc-http-types)
+ ("ghc-infer-license" ,ghc-infer-license)
("ghc-scientific" ,ghc-scientific)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
described in @url{https://www.lua.org/}.")
(license license:expat)))
+(define-public ghc-hslua-module-system
+ (package
+ (name "ghc-hslua-module-system")
+ (version "0.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hslua-module-system/hslua-module-system-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1m7wz3g5c34pyizqw5mllzhsy2vziddhlbhjfwdvd7nhd3p4v3hh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hslua" ,ghc-hslua)
+ ("ghc-temporary" ,ghc-temporary)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/hslua/hslua-module-system")
+ (synopsis "Lua module wrapper around Haskell's System module")
+ (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
+already been loaded before the loader can be added.")
+ (license license:expat)))
+
(define-public ghc-hslua-module-text
(package
(name "ghc-hslua-module-text")
@code{lower}, @code{len}, @code{reverse}, and @code{sub}.")
(license license:expat)))
+(define-public ghc-hsyaml
+ (package
+ (name "ghc-hsyaml")
+ (version "0.1.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "HsYAML/HsYAML-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1pajfhj16559v64ixm8j7bvxdqmxg6c3c0z3wz7in8ckswgzfp54"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "0j6qmmcz5yqh89hs2cq453maix50q61vl2h0ahj5lg02bygn42cf")))
+ (home-page "https://github.com/haskell-hvr/HsYAML")
+ (synopsis "Pure Haskell YAML 1.2 parser")
+ (description "This library provides a
+@url{http://yaml.org/spec/1.2/spec.html, YAML 1.2} parser implementation
+for Haskell. Its features include:
+
+@itemize
+@item Pure Haskell implementation with small dependency footprint and
+emphasis on strict compliance with the YAML 1.2 specification.
+
+@item Direct decoding to native Haskell types via (aeson-inspired)
+typeclass-based API (see @code{Data.YAML}).
+
+@item Support for constructing custom YAML node graph
+representation (including support for cyclic YAML data structures).
+
+@item Support for the standard (untyped) @emph{Failsafe}, (strict)
+@emph{JSON}, and (flexible) @emph{Core} ``schemas'' providing implicit
+typing rules as defined in the YAML 1.2 specification (including support
+for user-defined custom schemas).
+
+@item Event-based API resembling LibYAML's Event-based API (see
+@code{Data.YAML.Event}).
+
+@item Low-level API access to lexical token-based scanner (see
+@code{Data.YAML.Token}).
+@end itemize")
+ (license license:gpl2+)))
+
(define-public ghc-http-api-data
(package
(name "ghc-http-api-data")
lines continued at an indented level below.")
(license license:bsd-3)))
+(define-public ghc-infer-license
+ (package
+ (name "ghc-infer-license")
+ (version "0.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "infer-license/infer-license-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0wlfm6bf55kfvm74xar9lmjg5v1103rs9m3grw1rq5bmcmhzxrhj"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-text-metrics" ,ghc-text-metrics)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "http://hackage.haskell.org/package/infer-license")
+ (synopsis "Infer software license from a given license file")
+ (description "This library provides tools to infer a software
+license from a given license file.")
+ (license license:expat)))
+
(define-public ghc-inline-c
(package
(name "ghc-inline-c")
example code on the home page for a quick introduction.")
(license license:bsd-3)))
+(define-public ghc-intervals
+ (package
+ (name "ghc-intervals")
+ (version "0.8.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "intervals/intervals-" version ".tar.gz"))
+ (sha256
+ (base32
+ "00vyxf3ba9d7aas3npfapr53w71fslgh69fczjb25axr66fvzqww"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-distributive" ,ghc-distributive)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("4" "1qx3q0v13l1zaln9zdk8chxpxhshbz5x0vqm0qda7d1kpv7h6a7r")))
+ (home-page "https://github.com/ekmett/intervals")
+ (synopsis "Interval arithmetic")
+ (description "This library provides
+@code{Numeric.Interval.Interval}, which represets a closed, convex set
+of floating point values.")
+ (license license:bsd-3)))
+
(define-public ghc-invariant
(package
(name "ghc-invariant")
removed. Both IPv4 and IPv6 are supported.")
(license license:bsd-3)))
+(define-public ghc-ipynb
+ (package
+ (name "ghc-ipynb")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "ipynb/ipynb-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0daadhzil4q573mqb0rpvjzm0vpkzgzqcimw480qpvlh6rhppwj5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-aeson-diff" ,ghc-aeson-diff)
+ ("ghc-microlens-aeson" ,ghc-microlens-aeson)
+ ("ghc-microlens" ,ghc-microlens)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://hackage.haskell.org/package/ipynb")
+ (synopsis "Data structure for working with Jupyter notebooks")
+ (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)))
+
(define-public ghc-iwlib
(package
(name "ghc-iwlib")
(define-public ghc-lens
(package
(name "ghc-lens")
- (version "4.16.1")
+ (version "4.17.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1im4drhbydbawd6i0jsrzpqihnmx4ywpkg7yg94ddwsw3mxwkgpm"))))
+ "1gpkc53l2cggnfrgg5k4ih82rycjbdvpj9pnbi5cq8ms0dbvs4a7"))))
(build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri")))
(inputs
`(("ghc-base-orphans" ,ghc-base-orphans)
("ghc-bifunctors" ,ghc-bifunctors)
Music Player Daemon.")
(license license:expat)))
+(define-public ghc-lib-parser
+ (package
+ (name "ghc-lib-parser")
+ (version "8.8.0.20190424")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "ghc-lib-parser/ghc-lib-parser-" version ".tar.gz"))
+ (sha256
+ (base32
+ "12gsh994pr13bsybwlravmi21la66dyw74pk74yfw2pnz682wv10"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-alex" ,ghc-alex)
+ ("ghc-happy" ,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
+compiler-provided @code{ghc} package, but it can be loaded on many
+compiler versions.")
+ (license license:bsd-3)))
+
(define-public ghc-libxml
(package
(name "ghc-libxml")
"This library provides minimal Haskell binding to libxml2.")
(license license:bsd-3)))
+(define-public ghc-libyaml
+ (package
+ (name "ghc-libyaml")
+ (version "0.1.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "libyaml/libyaml-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0psznm9c3yjsyj9aj8m2svvv9m2v0x90hnwarcx5sbswyi3l00va"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Delete bundled LibYAML.
+ '(begin
+ (delete-file-recursively "libyaml_src")
+ #t))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags `("--flags=system-libyaml")))
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("libyaml" ,libyaml-2.1)))
+ (home-page "https://github.com/snoyberg/yaml#readme")
+ (synopsis "Low-level, streaming YAML interface.")
+ (description "This package provides a Haskell wrapper over the
+LibYAML C library.")
+ (license license:bsd-3)))
+
(define-public ghc-lifted-async
(package
(name "ghc-lifted-async")
(define-public ghc-linear
(package
(name "ghc-linear")
- (version "1.20.8")
+ (version "1.20.9")
(source
(origin
(method url-fetch)
"linear-" version ".tar.gz"))
(sha256
(base32
- "046vkvxlb0s286qr55s0c6db0rlwbm1cmlmwhrrkqbkzhfcipgay"))))
+ "0h7yqigq593n7wsl7nz6a5f137wznm7y679wsii0ph0zsc4v5af5"))))
(build-system haskell-build-system)
(inputs
`(("ghc-adjunctions" ,ghc-adjunctions)
stripped. As the result, this package has no dependencies.")
(license license:bsd-3)))
+(define-public ghc-microlens-aeson
+ (package
+ (name "ghc-microlens-aeson")
+ (version "2.3.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "microlens-aeson/microlens-aeson-"
+ version ".tar.gz"))
+ (patches (search-patches "ghc-microlens-aeson-fix-tests.patch"))
+ (sha256
+ (base32
+ "0w630kk5bnily1qh41081gqgbwmslrh5ad21899gwnb2r3jripyw"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-microlens" ,ghc-microlens)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/fosskers/microlens-aeson")
+ (synopsis "Law-abiding lenses for Aeson, using microlens")
+ (description "This library provides law-abiding lenses for Aeson, using
+microlens.")
+ (license license:expat)))
+
(define-public ghc-microlens-ghc
(package
(name "ghc-microlens-ghc")
(define-public ghc-monad-logger
(package
(name "ghc-monad-logger")
- (version "0.3.29")
+ (version "0.3.30")
(source
(origin
(method url-fetch)
"monad-logger-" version ".tar.gz"))
(sha256
(base32
- "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv"))))
+ "102l0v75hbvkmrypiyg4ybb6rbc7nij5nxs1aihmqfdpg04rkkp7"))))
(build-system haskell-build-system)
(inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-stm-chans" ,ghc-stm-chans)
and other added capabilities layered on top of the @code{Par} monad.")
(license license:bsd-3)))
-(define-public ghc-monadplus
- (package
- (name "ghc-monadplus")
- (version "1.4.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/monadplus"
- "/monadplus-" version ".tar.gz"))
- (sha256
- (base32 "15b5320wdpmdp5slpphnc1x4rhjch3igw245dp2jxbqyvchdavin"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/monadplus")
- (synopsis "Filtering and folding over arbitrary MonadPlus instances")
- (description
- "This package generalizes many common stream operations such as
-@code{filter}, @code{catMaybes} etc, enabling filtering and folding over
-arbitrary @code{MonadPlus} instances.")
- (license license:bsd-3)))
-
(define-public ghc-monadrandom
(package
(name "ghc-monadrandom")
(define-public ghc-mono-traversable
(package
(name "ghc-mono-traversable")
- (version "1.0.9.0")
+ (version "1.0.13.0")
(source
(origin
(method url-fetch)
"mono-traversable-" version ".tar.gz"))
(sha256
(base32
- "0180ks0dyvpk1r20w5jw2w2n79mjnk69n9vhspaxzlyxqgim5psa"))))
+ "1bqy982lpdb83lacfy76n8kqw5bvd31avxj25kg8gkgycdh0g0ma"))))
(build-system haskell-build-system)
(inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-hashable" ,ghc-hashable)
data structures as non-empty.")
(license license:expat)))
+(define-public ghc-monoid-extras
+ (package
+ (name "ghc-monoid-extras")
+ (version "0.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "monoid-extras/monoid-extras-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0xfrkgqn9d31z54l617m3w3kkd5m9vjb4yl247r3zzql3mpb1f37"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-groups" ,ghc-groups)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "0b8x5d6vh7mpigvjvcd8f38a1nyzn1vfdqypslw7z9fgsr742913")))
+ (home-page "https://hackage.haskell.org/package/monoid-extras")
+ (synopsis "Various extra monoid-related definitions and utilities")
+ (description "This package provides various extra monoid-related
+definitions and utilities, such as monoid actions, monoid coproducts,
+semi-direct products, \"deletable\" monoids, \"split\" monoids, and
+\"cut\" monoids.")
+ (license license:bsd-3)))
+
(define-public ghc-murmur-hash
(package
(name "ghc-murmur-hash")
of Peano numbers).")
(license license:gpl3+)))
+(define-public ghc-numeric-extras
+ (package
+ (name "ghc-numeric-extras")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "numeric-extras/numeric-extras-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1mk11c0gz1yjy5b8dvq6czfny57pln0bs7x28fz38qyr44872067"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/ekmett/numeric-extras")
+ (synopsis "Useful tools from the C standard library")
+ (description "This library provides some useful tools from the C
+standard library.")
+ (license license:bsd-3)))
+
(define-public ghc-objectname
(package
(name "ghc-objectname")
(base32
"0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "options.cabal"
+ (("chell >= 0\\.4 && < 0\\.5") "chell >= 0.4 && < 0.6"))
+ #t)))))
(inputs
`(("ghc-monads-tf" ,ghc-monads-tf)
("ghc-chell" ,ghc-chell)
(define-public ghc-pandoc
(package
(name "ghc-pandoc")
- (version "2.2.1")
+ (version "2.7.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
version ".tar.gz"))
+ (patches (search-patches "ghc-pandoc-fix-html-tests.patch"
+ "ghc-pandoc-fix-latex-test.patch"))
(sha256
(base32
- "1dqin92w513l7whg5wdgrngnxsj5mb8gppfvn7kjgyv2pdgpy0zy"))))
+ "0dpjrr40h54cljzhvixyym07z792a9izg6b9dmqpjlgcg4rj0xx8"))))
(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)
("ghc-blaze-markup" ,ghc-blaze-markup)
("ghc-cmark-gfm" ,ghc-cmark-gfm)
("ghc-data-default" ,ghc-data-default)
- ("ghc-deepseq-generics" ,ghc-deepseq-generics)
("ghc-diff" ,ghc-diff)
("ghc-doctemplates" ,ghc-doctemplates)
("ghc-executable-path" ,ghc-executable-path)
("ghc-glob" ,ghc-glob)
("ghc-haddock-library" ,ghc-haddock-library)
("ghc-hslua" ,ghc-hslua)
+ ("ghc-hslua-module-system" ,ghc-hslua-module-system)
("ghc-hslua-module-text" ,ghc-hslua-module-text)
+ ("ghc-hsyaml" ,ghc-hsyaml)
("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-ipynb" ,ghc-ipynb)
("ghc-juicypixels" ,ghc-juicypixels)
("ghc-network" ,ghc-network)
("ghc-network-uri" ,ghc-network-uri)
- ("ghc-old-locale" ,ghc-old-locale)
("ghc-pandoc-types" ,ghc-pandoc-types)
("ghc-random" ,ghc-random)
("ghc-scientific" ,ghc-scientific)
("ghc-tagsoup" ,ghc-tagsoup)
("ghc-temporary" ,ghc-temporary)
("ghc-texmath" ,ghc-texmath)
+ ("ghc-unicode-transforms" ,ghc-unicode-transforms)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
("ghc-xml" ,ghc-xml)
- ("ghc-yaml" ,ghc-yaml)
("ghc-zip-archive" ,ghc-zip-archive)
("ghc-zlib" ,ghc-zlib)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-golden" ,ghc-tasty-golden)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-lua" ,ghc-tasty-lua)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)))
(define-public ghc-pandoc-citeproc
(package
(name "ghc-pandoc-citeproc")
- (version "0.14.3.1")
+ (version "0.16.2")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0yj6rckwsc9vig40cm15ry0j3d01xpk04qma9n4byhal6v4b5h22"))))
+ "15mm17awgi1b5yazwhr5nh8b59qml1qk6pz6gpyijks70fq2arsv"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(define-public ghc-persistent
(package
(name "ghc-persistent")
- (version "2.8.2")
+ (version "2.9.2")
(source
(origin
(method url-fetch)
"persistent-" version ".tar.gz"))
(sha256
(base32
- "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9"))))
+ "1wsa3kn427v88a6r0vwr6mz23snik2krbsgc8zqp18xajqn5szj9"))))
(build-system haskell-build-system)
(inputs `(("ghc-old-locale" ,ghc-old-locale)
("ghc-conduit" ,ghc-conduit)
(define-public ghc-persistent-sqlite
(package
(name "ghc-persistent-sqlite")
- (version "2.8.2")
+ (version "2.9.3")
(source
(origin
(method url-fetch)
"persistent-sqlite-" version ".tar.gz"))
(sha256
(base32
- "1chbmvjz46smhgnzhha3bbkhys3fys6dip1jr4v7xp1jf78zbyp6"))))
+ "13wbn88ixv4d4dfjl1gabm1q60fbcnygbmixz57pi3z84drrynwq"))))
(build-system haskell-build-system)
(inputs `(("ghc-persistent" ,ghc-persistent)
("ghc-unliftio-core" ,ghc-unliftio-core)
(define-public ghc-persistent-template
(package
(name "ghc-persistent-template")
- (version "2.5.4")
+ (version "2.6.0")
(source
(origin
(method url-fetch)
"persistent-template-" version ".tar.gz"))
(sha256
(base32
- "008afcy7zbw7bzp9jww8gdldb51kfm0fg4p0x4xcp61gx4679bjc"))))
+ "0wr1z2nfrl6jv1lprxb0d2jw4izqfcbcwvkdrhryzg95gjz8ryjv"))))
(build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "03qgwk32krldph3blw5agiqcpccr3649hajyn8wm9k71zz82dpn6")))
(inputs `(("ghc-persistent" ,ghc-persistent)
("ghc-monad-control" ,ghc-monad-control)
("ghc-aeson" ,ghc-aeson)
(define-public ghc-resolv
(package
(name "ghc-resolv")
- (version "0.1.1.1")
+ (version "0.1.1.2")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0wh7wj56l3f2bylz563g5g04a4nydj8acv60hpwa7k3mn792xca9"))))
+ "0wczdy3vmpfcfwjn1m95bygc5d83m97xxmavhdvy5ayn8c402fp4"))))
(build-system haskell-build-system)
(arguments
- `(#:cabal-revision
- ("1" "15ay4n3x8c09cb3h4z1nan84yd3n9zpgvi6h114hk98bq10k8mma")
- #:tests? #f)) ; The required test frameworks are too old.
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "resolv.cabal"
+ (("tasty >= 1\\.1 && < 1\\.2")
+ "tasty >= 1.1 && < 1.3"))
+ #t)))))
(inputs
`(("ghc-base16-bytestring" ,ghc-base16-bytestring)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(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
(define-public ghc-sandi
(package
(name "ghc-sandi")
- (version "0.4.2")
+ (version "0.5")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0dvkpk91n9kz2ha04rvp231ra9sgd1ilyc1qkzf9l03iir7zrh9b"))))
+ "1ndgai8idlxyccvkz5zsgq06v58blc30i6hkky5b1sf5x6gs2h29"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stringsearch" ,ghc-stringsearch)
(description "Reasonably fast data encoding library.")
(license license:bsd-3)))
+(define-public ghc-say
+ (package
+ (name "ghc-say")
+ (version "0.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/say/say-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1r5kffjfwpas45g74sip8glrj1m9nygrnxjm7xgw898rq9pnafgn"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-unliftio" ,ghc-unliftio)))
+ (home-page "https://github.com/fpco/say")
+ (synopsis
+ "Send textual messages to a Handle in a thread-friendly way")
+ (description
+ "A thread safe API to write a line of textual data to a Handle, such
+as sending some messages to the terminal - that has the following properties:
+@itemize
+@item Properly handle character encoding settings on the Handle
+@item For reasonably sized messages, ensure that the entire message is written
+ in one chunk to avoid interleaving data with other threads
+@item Avoid unnecessary memory allocations and copies
+@item Minimize locking.
+@end itemize")
+ (license license:expat)))
+
(define-public ghc-scientific
(package
(name "ghc-scientific")
(define-public ghc-sdl2
(package
(name "ghc-sdl2")
- (version "2.4.1.0")
+ (version "2.5.0.0")
(source
(origin
(method url-fetch)
"sdl2/sdl2-" version ".tar.gz"))
(sha256
(base32
- "0p4b12fmxps0sbnkqdfy0qw19s355yrkw7fgw6xz53wzq706k991"))))
+ "1x368yhdd55b3cvx8dvj1sj6nzygzigbhrwhssjs4k0rcxlwqfw8"))))
(build-system haskell-build-system)
(arguments '(#:tests? #f)) ; tests require graphical environment
(inputs
(define-public ghc-simple-sendfile
(package
(name "ghc-simple-sendfile")
- (version "0.2.27")
+ (version "0.2.30")
(source
(origin
(method url-fetch)
"simple-sendfile-" version ".tar.gz"))
(sha256
(base32
- "1bwwqzcm56m2w4ymsa054sxmpbj76h9pvb0jf8zxp8lr41cp51gn"))))
+ "112j0qfsjazf9wg1zywf7hjybgsiywk9wkm27yi8xzv27hmlv1mn"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
are the bottleneck of web servers.")
(license license:bsd-3)))
+(define-public ghc-size-based
+ (package
+ (name "ghc-size-based")
+ (version "0.1.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "size-based/size-based-" version ".tar.gz"))
+ (sha256
+ (base32
+ "06hmlic0n73ncwlkpx49xlv09bzsrr27ncnp5byhzlknak2gd7vp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-dictionary-sharing" ,ghc-dictionary-sharing)
+ ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "0kax1ypjyglkn6iff1x4yz12y7f2n249m95xvdhrc63hsa4xlcqv")))
+ (home-page "https://hackage.haskell.org/package/size-based")
+ (synopsis "Sized functors for size-based enumerations")
+ (description "This library provides a framework for size-based
+enumerations.")
+ (license license:bsd-3)))
+
(define-public ghc-skylighting-core
(package
(name "ghc-skylighting-core")
(define-public ghc-stm-conduit
(package
(name "ghc-stm-conduit")
- (version "4.0.0")
+ (version "4.0.1")
(source
(origin
(method url-fetch)
"stm-conduit-" version ".tar.gz"))
(sha256
(base32
- "0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z"))))
+ "0hhlxvpp7mah8dcvkknh6skx44jfk3092zz2w52zlr255bkmn3p8"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stm-chans" ,ghc-stm-chans)
(base32
"1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "stylish-haskell.cabal"
+ (("haskell-src-exts >= 1\\.18 && < 1\\.21,")
+ "haskell-src-exts >= 1.18 && < 1.22,"))
+ #t)))))
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-file-embed" ,ghc-file-embed)
@end itemize")
(license license:bsd-3)))
+(define-public ghc-svg-builder
+ (package
+ (name "ghc-svg-builder")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "svg-builder/svg-builder-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1k420f497lzkymmxin88ql6ib8dziic43avykv31yq65rgrf7l2g"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1bhp9gvid2iis411k1vvyj5krzc4ahxcqcd9cwx9h37jxg180xw1")))
+ (home-page "https://github.com/diagrams/svg-builder.git")
+ (synopsis "Domain-specific language for building Scalable Vector Graphics")
+ (description "Easy-to-write domain-specific language (DSL) for
+building Scalable Vector Graphics (SVG).")
+ (license license:bsd-3)))
+
(define-public ghc-syb
(package
(name "ghc-syb")
an index.")
(license license:bsd-3)))
+(define-public ghc-tar-conduit
+ (package
+ (name "ghc-tar-conduit")
+ (version "0.3.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tar-conduit/tar-conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0bgn3hyf20g1gfnzy8f41s7nj54kfcyjk2izw99svrw8f3dphi80"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-combinators" ,ghc-conduit-combinators)
+ ("ghc-safe-exceptions" ,ghc-safe-exceptions)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-weigh" ,ghc-weigh)))
+ (home-page "https://github.com/snoyberg/tar-conduit#readme")
+ (synopsis "Extract and create tar files using conduit for streaming")
+ (description "This library provides a conduit-based, streaming
+interface for extracting and creating tar files.")
+ (license license:expat)))
+
(define-public ghc-temporary
(package
(name "ghc-temporary")
text package.")
(license license:bsd-2)))
+(define-public ghc-text-metrics
+ (package
+ (name "ghc-text-metrics")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "text-metrics/text-metrics-" version ".tar.gz"))
+ (sha256
+ (base32
+ "18mzxwkdvjp31r720ai9bnxr638qq8x3a2v408bz0d8f0rsayx1q"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)))
+ (arguments
+ `(#:cabal-revision
+ ("4" "017drxq9x56b345d8w5m8xdsi1zzs0z16pbdx8j35cd1lsnh3kf1")))
+ (home-page "https://github.com/mrkkrp/text-metrics")
+ (synopsis "Calculate various string metrics efficiently")
+ (description "This library provides tools to calculate various
+string metrics efficiently.")
+ (license license:bsd-3)))
+
(define-public ghc-tf-random
(package
(name "ghc-tf-random")
@code{TimeLocale}.")
(license license:bsd-3)))
+(define-public ghc-time-manager
+ (package
+ (name "ghc-time-manager")
+ (version "0.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "time-manager/time-manager-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1nzwj0fxz370ks6vr1sylcidx33rnqq45y3q9yv9n4dj43nid9lh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-auto-update" ,ghc-auto-update)))
+ (home-page "https://github.com/yesodweb/wai")
+ (synopsis "Scalable timer")
+ (description "This library contains scalable timer functions provided by a
+timer manager.")
+ (license license:expat)))
+
(define-public ghc-timeit
(package
(name "ghc-timeit")
used CPU time of monadic computation with an IO base.")
(license license:bsd-3)))
+(define-public ghc-timezone-series
+ (package
+ (name "ghc-timezone-series")
+ (version "0.1.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "mirror://hackage/package/timezone-series/timezone-series-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1blwgnyzqn917rgqkl4dncv9whv3xmk0lav040qq0214vksmvlz5"))))
+ (build-system haskell-build-system)
+ (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
+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)))
+
+(define-public ghc-timezone-olson
+ (package
+ (name "ghc-timezone-olson")
+ (version "0.1.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "mirror://hackage/package/timezone-olson/timezone-olson-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "05abywx1nrcaz0nqzfy4zw62bc5qd7pdfnjvv4drxkwv084ha8rj"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-timezone-series" ,ghc-timezone-series)
+ ("ghc-extensible-exceptions" ,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
+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)))
+
(define-public ghc-tldr
(package
(name "ghc-tldr")
(define-public ghc-tree-diff
(package
(name "ghc-tree-diff")
- (version "0.0.1")
+ (version "0.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "049v44c520jy3icxlnrvbdblh3mjmvd7m6qmkzxbzkf02x63xqmz"))))
+ "1156nbqn0pn9lp4zjsy4vv5g5wmy4zxwmbqdgvq349rydynh3ng3"))))
(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-bytestring-builder" ,ghc-bytestring-builder)
("ghc-hashable" ,ghc-hashable)
- ("ghc-memotrie" ,ghc-memotrie)
("ghc-parsers" ,ghc-parsers)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-scientific" ,ghc-scientific)
(base32
"0hznd8i65s81xy13i2qc7cvipw3lfb2yhkv53apbdsh6sbljz5sk"))))
(build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; doctest suite fails to build on i686
+ (arguments
+ `(#:tests? #f ; doctest suite fails to build on i686
+ #:cabal-revision
+ ("4" "0xbwyvwl6f2zylk60f2akwgq03qv49113xil7b1z1s3vlwbn5aj1")))
(inputs
`(("ghc-reducers" ,ghc-reducers)
("ghc-semigroups" ,ghc-semigroups)
handled safely, this is what you're left with.")
(license license:isc)))
+(define-public ghc-unicode-transforms
+ (package
+ (name "ghc-unicode-transforms")
+ (version "0.3.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "unicode-transforms/unicode-transforms-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1akscvyssif4hki3g6hy0jmjyr8cqly1whzvzj0km2b3qh0x09l3"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-bitarray" ,ghc-bitarray)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-getopt-generics" ,ghc-getopt-generics)
+ ("ghc-split" ,ghc-split)))
+ (home-page "https://github.com/composewell/unicode-transforms")
+ (synopsis "Unicode normalization")
+ (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)))
+
(define-public ghc-union-find
(package
(name "ghc-union-find")
(define-public ghc-validation
(package
(name "ghc-validation")
- (version "1")
+ (version "1.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "08drmdvyzg2frbb26icy1mlz52xv0l6gi3v8gb7xp0vrcci5libh"))))
+ "1acj7mh3581ks405xswxw6667z7y1y0slisg6jvp6chc191ji9l5"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
- ("1" "1x1g4nannz81j1h64l1m3ancc96zc57d1bjhj1wk7bwn1xxbi5h3")))
+ ("1" "1rrjg9z399k6pb55nv85mlr5bkmdqbjwkvl1cy7ydccdx6ks4syp")))
(inputs
`(("ghc-semigroups" ,ghc-semigroups)
("ghc-semigroupoids" ,ghc-semigroupoids)
(define-public ghc-yaml
(package
(name "ghc-yaml")
- (version "0.8.32")
+ (version "0.11.1.2")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"yaml/yaml-" version ".tar.gz"))
(sha256
(base32
- "0cbsyh4ilvjzq1q7pxls43k6pdqxg1l85xzibcwpbvmlvrizh86w"))))
+ "028pz77n92l6kjgjv263h4b6yhw1iibdbf3a3dkn5qnz537xpzhc"))))
(build-system haskell-build-system)
- ;; The tests are broken on i686. They are fixed in 0.10.3.0.
- ;; See https://github.com/snoyberg/yaml/issues/158
- (arguments `(#:tests? #f))
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-resourcet" ,ghc-resourcet)
("ghc-semigroups" ,ghc-semigroups)
("ghc-temporary" ,ghc-temporary)
("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
- ("ghc-base-compat" ,ghc-base-compat)))
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-libyaml" ,ghc-libyaml)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-hunit" ,ghc-hunit)
("hspec-discover" ,hspec-discover)
- ("ghc-mockery" ,ghc-mockery)))
+ ("ghc-mockery" ,ghc-mockery)
+ ("ghc-raw-strings-qq" ,ghc-raw-strings-qq)))
(home-page "https://github.com/snoyberg/yaml/")
(synopsis "Parsing and rendering YAML documents")
(description
(description "This package provides low-level bindings to the
@code{zlib} package.")
(license license:bsd-3)))
+
+(define-public ghc-zstd
+ (package
+ (name "ghc-zstd")
+ (version "0.1.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "zstd/zstd-" version ".tar.gz"))
+ (sha256
+ (base32
+ "147s496zvw13akxqzg65mgfvk3bvhrcilxgf8n786prxg5cm4jz2"))))
+ (build-system haskell-build-system)
+ (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/luispedro/hs-zstd")
+ (synopsis "Haskell bindings to the Zstandard compression algorithm")
+ (description "This library provides Haskell bindings to the
+Zstandard compression algorithm, a fast lossless compression algorithm
+targeting real-time compression scenarios at zlib-level and better
+compression ratios.")
+ (license license:bsd-3)))
HCoop / jackhill / guix / guix.git / blobdiff