;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com>
;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
+;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
+;;; Copyright © 2020 JoJo <jo@jo.zone>
+;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages haskell-web)
#:use-module (gnu packages libffi)
#:use-module (gnu packages linux)
+ #:use-module (gnu packages llvm)
#:use-module (gnu packages lua)
#:use-module (gnu packages maths)
#:use-module (gnu packages ncurses)
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")
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")
(arguments
`(#:cabal-revision
("1" "15sn2qc8k0hxbb2nai341kkrci98hlhzcj2ci087m0zxcg5jcdbp")))
- (home-page "http://hackage.haskell.org/package/base-compat-batteries")
+ (home-page "https://hackage.haskell.org/package/base-compat-batteries")
(synopsis "base-compat with extra batteries")
(description "This library provides functions available in later
versions of @code{base} to a wider range of compilers, without requiring
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-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)
"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")
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "http://hackage.haskell.org/package/dense-linear-algebra")
+ (home-page "https://hackage.haskell.org/package/dense-linear-algebra")
(synopsis "Simple and incomplete implementation of linear algebra")
(description "This library is simply a collection of linear-algebra
related modules split from the statistics library.")
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")
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
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://hackage.haskell.org/package/errorcall-eq-instance")
+ (home-page "https://hackage.haskell.org/package/errorcall-eq-instance")
(synopsis "Orphan Eq instance for ErrorCall")
(description
"Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}.
(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
("ghc-silently" ,ghc-silently)
("ghc-filemanip" ,ghc-filemanip)))
(home-page
- "http://hackage.haskell.org/package/ghc-exactprint")
+ "https://hackage.haskell.org/package/ghc-exactprint")
(synopsis "ExactPrint for GHC")
(description
"Using the API Annotations available from GHC 7.10.2, this library
(define-public ghc-extra
(package
(name "ghc-extra")
- (version "1.6.18")
+ (version "1.7.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0jvd4l0hi8pf5899pxc32yc638y0mrc357w0rph99k3hm277i0cy"))))
+ "0zshxv9dnd8vksncmb8dj4wvq2wdybzwxyhmy2zp6a81icm4azx4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-clock" ,ghc-clock)
("ghc-semigroups" ,ghc-semigroups)
- ("ghc-quickcheck" ,ghc-quickcheck)))
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
(home-page "https://github.com/ndmitchell/extra")
(synopsis "Extra Haskell functions")
(description "This library provides extra functions for the standard
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 "https://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")
(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)
(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")
`(#:cabal-revision
("2" "006phc5y9rrvsshdcmjmhxzxh8dpgs685mpqbkjm9c40xb1ydjbz")))
(inputs `(("ghc-hashable" ,ghc-hashable)))
- (home-page "http://hackage.haskell.org/package/hashable-time")
+ (home-page "https://hackage.haskell.org/package/hashable-time")
(synopsis "Hashable instances for Data.Time")
(description
"This package provides @code{Hashable} instances for types in
(sha256
(base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/haskell-lexer")
+ (home-page "https://hackage.haskell.org/package/haskell-lexer")
(synopsis "Fully compliant Haskell 98 lexer")
(description
"This package provides a fully compliant Haskell 98 lexer.")
(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)
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")
(base32
"1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/IfElse")
+ (home-page "https://hackage.haskell.org/package/IfElse")
(synopsis "Monadic control flow with anaphoric variants")
(description "This library provides functions for control flow inside of
monads with anaphoric variants on @code{if} and @code{when} and a C-like
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://hackage.haskell.org/package/infer-license")
+ (home-page "https://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.")
("ghc-hspec" ,ghc-hspec)
("ghc-raw-strings-qq" ,ghc-raw-strings-qq)
("ghc-regex-posix" ,ghc-regex-posix)))
- (home-page "http://hackage.haskell.org/package/inline-c")
+ (home-page "https://hackage.haskell.org/package/inline-c")
(synopsis "Write Haskell source files including C code inline")
(description
"inline-c lets you seamlessly call C libraries and embed high-performance
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")
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-zlib" ,ghc-zlib)))
- (home-page "http://hackage.haskell.org/package/io-streams")
+ (home-page "https://hackage.haskell.org/package/io-streams")
(synopsis "Simple and composable stream I/O")
(description "This library contains simple and easy-to-use
primitives for I/O using streams.")
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")
`(#:tests? #f
#:cabal-revision
("1" "10ac9pk4jy75k03j1ns4b5136l4kw8krr2d2nw2fdmpm5jzyghc5")))
- (home-page "http://hackage.haskell.org/package/language-glsl")
+ (home-page "https://hackage.haskell.org/package/language-glsl")
(synopsis "GLSL abstract syntax tree, parser, and pretty-printer")
(description "This package is a Haskell library for the
representation, parsing, and pretty-printing of GLSL 1.50 code.")
(build-system haskell-build-system)
(native-inputs `(("pkg-config" ,pkg-config)))
(inputs `(("libffi" ,libffi)))
- (home-page "http://hackage.haskell.org/package/libffi")
+ (home-page "https://hackage.haskell.org/package/libffi")
(synopsis "Haskell binding to libffi")
(description
"A binding to libffi, allowing C functions of types only known at runtime
can handle infinite lists.")
(license license:bsd-3)))
+(define-public ghc-llvm-hs-pure
+ (package
+ (name "ghc-llvm-hs-pure")
+ (version "9.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/llvm-hs-pure/"
+ "llvm-hs-pure-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0pxb5ah8r5pzpz2ibqw3g9g1isigb4z7pbzfrwr8kmcjn74ab3kf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/llvm-hs/llvm-hs/")
+ (synopsis "Pure Haskell LLVM functionality (no FFI)")
+ (description "llvm-hs-pure is a set of pure Haskell types and functions
+for interacting with LLVM. It includes an algebraic datatype (ADT) to represent
+LLVM IR. The llvm-hs package builds on this one with FFI bindings to LLVM, but
+llvm-hs-pure does not require LLVM to be available.")
+ (license license:bsd-3)))
+
+(define-public ghc-llvm-hs
+ (package
+ (name "ghc-llvm-hs")
+ (version "9.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/llvm-hs/llvm-hs-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0723xgh45h9cyxmmjsvxnsp8bpn1ljy4qgh7a7vqq3sj9d6wzq00"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-llvm-hs-pure" ,ghc-llvm-hs-pure)
+ ("llvm" ,llvm-9)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-pretty-show" ,ghc-pretty-show)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/llvm-hs/llvm-hs/")
+ (synopsis "General purpose LLVM bindings for Haskell")
+ (description "llvm-hs is a set of Haskell bindings for LLVM. Unlike other
+current Haskell bindings, it uses an algebraic datatype (ADT) to represent LLVM
+IR, and so offers two advantages: it handles almost all of the stateful
+complexities of using the LLVM API to build IR; and it supports moving IR not
+only from Haskell into LLVM C++ objects, but the other direction - from LLVM C++
+into Haskell.")
+ (license license:bsd-3)))
+
(define-public ghc-logging-facade
(package
(name "ghc-logging-facade")
(base32
"10p0gjjjwr1dda7hahwrwn5njbfhl67arq3v3nf1jr3vymlkn75j"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/magic")
+ (home-page "https://hackage.haskell.org/package/magic")
(synopsis "Interface to C file/magic library")
(description
"This package provides a full-featured binding to the C libmagic library.
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")
`(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://software.complete.org/missingh")
+ (home-page "https://software.complete.org/missingh")
(synopsis "Large utility library")
(description
"MissingH is a library of all sorts of utility functions for Haskell
(home-page "https://github.com/simonmar/monad-par")
(synopsis "Combinators and extra features for Par monads for Haskell")
(description "This Haskell package provides additional data structures,
-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.")
+and other added capabilities layered on top of the @code{Par} monad.")
(license license:bsd-3)))
(define-public ghc-monadrandom
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")
(build-system haskell-build-system)
(native-inputs
`(("ghc-doctest" ,ghc-doctest)))
- (home-page "http://hackage.haskell.org/package/network-byte-order")
+ (home-page "https://hackage.haskell.org/package/network-byte-order")
(synopsis "Network byte order utilities")
(description "This library provides peek and poke functions for network
byte order.")
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)
command line options in Haskell.")
(license license:bsd-3)))
+(define-public ghc-jira-wiki-markup
+ (package
+ (name "ghc-jira-wiki-markup")
+ (version "1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/jira-wiki-markup/"
+ "jira-wiki-markup-" version ".tar.gz"))
+ (sha256
+ (base32 "1sl2jjcsqg61si33mxjwpf8zdn56kbbgcwqqqzbgifx2qbv4wmf8"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/tarleb/jira-wiki-markup")
+ (synopsis "Handle Jira wiki markup")
+ (description
+ "Parse jira wiki text into an abstract syntax tree for easy transformation
+to other formats.")
+ (license license:expat)))
+
+(define-public ghc-emojis
+ (package
+ (name "ghc-emojis")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/emojis/"
+ "emojis-" version ".tar.gz"))
+ (sha256
+ (base32 "1c6zkj9gmk1y90gbdrn50hyp7mw1mggzhnr2khqd728ryipw60ss"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/jgm/emojis#readme")
+ (synopsis "Conversion between emoji characters and their names.")
+ (description
+ "This package provides functions for converting emoji names to emoji
+characters and vice versa.
+
+How does it differ from the @code{emoji} package?
+@itemize
+@item It supports a fuller range of emojis, including all those supported by
+GitHub
+@item It supports lookup of emoji aliases from emoji
+@item It uses Text rather than String
+@item It has a lighter dependency footprint: in particular, it does not
+require aeson
+@item It does not require TemplateHaskell
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public ghc-text-conversions
+ (package
+ (name "ghc-text-conversions")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/text-conversions/"
+ "text-conversions-" version ".tar.gz"))
+ (sha256
+ (base32 "089c56vdj9xysqfr1hnvbnrghlg83q6w10xk02gflpsidcpvwmhp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-errors" ,ghc-errors)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/cjdev/text-conversions#readme")
+ (synopsis "Safe conversions between textual types")
+ (description "Safe conversions between textual types")
+ (license license:isc)))
+
+(define-public ghc-doclayout
+ (package
+ (name "ghc-doclayout")
+ (version "0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/doclayout/"
+ "doclayout-" version ".tar.gz"))
+ (sha256
+ (base32 "1wmnwq28jcyd6c80srivsnd5znmyl9sgmwwnlk2crwiiwqadbal7"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-safe" ,ghc-safe)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/jgm/doclayout")
+ (synopsis "Pretty-printing library for laying out text documents")
+ (description
+ "doclayout is a pretty-printing library for laying out text documents,
+with several features not present in pretty-printing libraries designed for
+code. It was designed for use in @code{Pandoc}.")
+ (license license:bsd-3)))
+
(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
("ghc-hspec" ,ghc-hspec)
("ghc-validity" ,ghc-validity)))
(home-page
- "http://hackage.haskell.org/package/path")
+ "https://hackage.haskell.org/package/path")
(synopsis "Support for well-typed paths")
(description "This package introduces a type for paths upholding useful
invariants.")
(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)
functions for the ghc-persistent package.")
(license license:expat)))
+(define-public ghc-pipes
+ (package
+ (name "ghc-pipes")
+ (version "4.3.13")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/pipes/"
+ "pipes-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1ch3xr5f5if0psd3lsyrpkwrgh36synnzqcpimghprys68l4zfkn"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-mmorph" ,ghc-mmorph)
+ ("ghc-void" ,ghc-void)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2"
+ ,ghc-test-framework-quickcheck2)))
+ (home-page
+ "https://hackage.haskell.org/package/pipes")
+ (synopsis "Compositional pipelines")
+ (description
+ "A clean and powerful stream processing library that lets you build
+and connect reusable streaming components. Advantages over traditional streaming
+libraries:
+@itemize
+@item Concise API: Use simple commands like @code{for}, (@code{>->}), @code{await},
+and @code{yield}
+@item Blazing fast: Implementation tuned for speed, including shortcut fusion
+@item Lightweight Dependency: pipes is small and compiles very rapidly, including
+dependencies
+@item Elegant semantics: Use practical category theory
+@item ListT: Correct implementation of @code{ListT} that interconverts with pipes
+@item Bidirectionality: Implement duplex channels
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public ghc-pointedlist
+ (package
+ (name "ghc-pointedlist")
+ (version "0.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/pointedlist/"
+ "pointedlist-" version ".tar.gz"))
+ (sha256
+ (base32
+ "16xsrzqql7i4z6a3xy07sqnbyqdmcar1jiacla58y4mvkkwb0g3l"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://hackage.haskell.org/package/pointedlist")
+ (synopsis
+ "Zipper-like comonad which works as a list, tracking a position")
+ (description
+ "A PointedList tracks the position in a non-empty list which works
+similarly to a zipper. A current item is always required, and therefore
+the list may never be empty. A circular PointedList wraps around to the
+other end when progressing past the actual edge.")
+ (license license:bsd-3)))
+
(define-public ghc-polyparse
(package
(name "ghc-polyparse")
(base32
"11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/prettyclass")
+ (home-page "https://hackage.haskell.org/package/prettyclass")
(synopsis "Pretty printing class similar to Show")
(description "This package provides a pretty printing class similar
to @code{Show}, based on the HughesPJ pretty printing library. It
(base32
"0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/refact")
+ (home-page "https://hackage.haskell.org/package/refact")
(synopsis "Specify refactorings to perform with apply-refact")
(description
"This library provides a datatype which can be interpreted by
`(("ghc-regex-base" ,ghc-regex-base)
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
(home-page
- "http://hackage.haskell.org/package/regex-tdfa-text")
+ "https://hackage.haskell.org/package/regex-tdfa-text")
(synopsis "Text interface for regex-tdfa")
(description
"This provides an extra text interface for regex-tdfa.")
(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")
(native-inputs
`(("ghc-weigh" ,ghc-weigh)
("pkg-config" ,pkg-config)))
- (home-page "http://hackage.haskell.org/package/sdl2")
+ (home-page "https://hackage.haskell.org/package/sdl2")
(synopsis "High- and low-level bindings to the SDL library")
(description
"This package contains bindings to the SDL 2 library, in both high- and
("sdl2-image" ,sdl2-image)))
(native-inputs
`(("pkg-config" ,pkg-config)))
- (home-page "http://hackage.haskell.org/package/sdl2-image")
+ (home-page "https://hackage.haskell.org/package/sdl2-image")
(synopsis "Bindings to SDL2_image")
(description "This package provides Haskell bindings to
@code{SDL2_image}.")
("sdl2-mixer" ,sdl2-mixer)))
(native-inputs
`(("pkg-config" ,pkg-config)))
- (home-page "http://hackage.haskell.org/package/sdl2-mixer")
+ (home-page "https://hackage.haskell.org/package/sdl2-mixer")
(synopsis "Bindings to SDL2 mixer")
(description "This package provides Haskell bindings to
@code{SDL2_mixer}.")
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")
(base32
"07ci2mh8cbjvipb576rxsj3iyhkj5c5dnsns4xkdppp2p3pv10d3"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/sop-core")
+ (home-page "https://hackage.haskell.org/package/sop-core")
(synopsis "True Sums of Products")
(description "This package provides an implementation of
@math{n}-ary sums and @math{n}-ary products. The module @code{Data.SOP}
("ghc-base-compat-batteries" ,ghc-base-compat-batteries)
("ghc-tf-random" ,ghc-tf-random)
("ghc-vector" ,ghc-vector)))
- (home-page "http://hackage.haskell.org/package/splitmix")
+ (home-page "https://hackage.haskell.org/package/splitmix")
(synopsis "Fast and splittable pseudorandom number generator")
(description "This package provides a Pure Haskell implementation of the
SplitMix pseudorandom number generator. SplitMix is a \"splittable\"
(build-system haskell-build-system)
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
- (home-page "http://hackage.haskell.org/package/string-qq")
+ (home-page "https://hackage.haskell.org/package/string-qq")
(synopsis
"QuasiQuoter for non-interpolated strings, texts and bytestrings.")
(description
(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")
("1" "0k8ph4sydaiqp8dav4if6hpiaq8h1xsr93khmdr7a1mmfwdxr64r")))
(home-page "https://github.com/phadej/time-compat")
(synopsis "Compatibility package for time")
- (description "This packages tries to compat as many @code{time}
+ (description "This package tries to compat as many @code{time}
features as possible.")
(license license:bsd-3)))
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")
#:cabal-revision
("1"
"09pqi867wskwgc5lpn197f895mbn1174ydgllvcppcsmrz2b6yr6")))
- (home-page "http://hackage.haskell.org/package/unagi-chan")
+ (home-page "https://hackage.haskell.org/package/unagi-chan")
(synopsis "Fast concurrent queues with a Chan-like API, and more")
(description
"This library provides implementations of concurrent FIFO queues (for
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")
(base32
"0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
(build-system haskell-build-system)
- (home-page "http://code.galois.com")
+ (home-page "https://github.com/GaloisInc/xml")
(synopsis "Simple XML library for Haskell")
(description "This package provides a simple XML library for Haskell.")
(license license:bsd-3)))
HCoop / jackhill / guix / guix.git / blobdiff