summaryrefslogtreecommitdiff
path: root/gnu/packages
diff options
context:
space:
mode:
Diffstat (limited to 'gnu/packages')
-rw-r--r--gnu/packages/agda.scm2
-rw-r--r--gnu/packages/bioconductor.scm2
-rw-r--r--gnu/packages/bioinformatics.scm2
-rw-r--r--gnu/packages/cran.scm2
-rw-r--r--gnu/packages/emacs-xyz.scm2
-rw-r--r--gnu/packages/games.scm1
-rw-r--r--gnu/packages/graphics.scm2
-rw-r--r--gnu/packages/haskell-apps.scm1
-rw-r--r--gnu/packages/haskell-check.scm2
-rw-r--r--gnu/packages/haskell-xyz.scm11097
-rw-r--r--gnu/packages/haskell.scm11076
-rw-r--r--gnu/packages/idris.scm2
-rw-r--r--gnu/packages/statistics.scm2
-rw-r--r--gnu/packages/wm.scm2
14 files changed, 11109 insertions, 11086 deletions
diff --git a/gnu/packages/agda.scm b/gnu/packages/agda.scm
index c085bfac2e..931f1e8ef7 100644
--- a/gnu/packages/agda.scm
+++ b/gnu/packages/agda.scm
@@ -22,9 +22,9 @@
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (gnu packages agda)
- #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-web)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (guix build-system emacs)
#:use-module (guix build-system gnu)
#:use-module (guix build-system haskell)
diff --git a/gnu/packages/bioconductor.scm b/gnu/packages/bioconductor.scm
index b7bc58d507..89aea8d9c0 100644
--- a/gnu/packages/bioconductor.scm
+++ b/gnu/packages/bioconductor.scm
@@ -31,7 +31,7 @@
#:use-module (gnu packages compression)
#:use-module (gnu packages gcc)
#:use-module (gnu packages graph)
- #:use-module (gnu packages haskell)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages image)
#:use-module (gnu packages maths)
#:use-module (gnu packages netpbm)
diff --git a/gnu/packages/bioinformatics.scm b/gnu/packages/bioinformatics.scm
index 62f368c139..779a972520 100644
--- a/gnu/packages/bioinformatics.scm
+++ b/gnu/packages/bioinformatics.scm
@@ -77,9 +77,9 @@
#:use-module (gnu packages groff)
#:use-module (gnu packages guile)
#:use-module (gnu packages guile-xyz)
- #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-web)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages image)
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages java)
diff --git a/gnu/packages/cran.scm b/gnu/packages/cran.scm
index 458b141f91..6ba7c295cf 100644
--- a/gnu/packages/cran.scm
+++ b/gnu/packages/cran.scm
@@ -53,7 +53,7 @@
#:use-module (gnu packages gnome)
#:use-module (gnu packages graph)
#:use-module (gnu packages gtk)
- #:use-module (gnu packages haskell)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages icu4c)
#:use-module (gnu packages image)
#:use-module (gnu packages imagemagick)
diff --git a/gnu/packages/emacs-xyz.scm b/gnu/packages/emacs-xyz.scm
index 9e94d3fc8e..6af5d43c27 100644
--- a/gnu/packages/emacs-xyz.scm
+++ b/gnu/packages/emacs-xyz.scm
@@ -137,7 +137,7 @@
#:use-module (gnu packages sqlite)
#:use-module (gnu packages gnupg)
#:use-module (gnu packages video)
- #:use-module (gnu packages haskell)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages wordnet)
#:use-module (guix utils)
#:use-module (srfi srfi-1)
diff --git a/gnu/packages/games.scm b/gnu/packages/games.scm
index 870becc50b..f9d7331f5b 100644
--- a/gnu/packages/games.scm
+++ b/gnu/packages/games.scm
@@ -112,6 +112,7 @@
#:use-module (gnu packages guile)
#:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-crypto)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages icu4c)
#:use-module (gnu packages image)
#:use-module (gnu packages imagemagick)
diff --git a/gnu/packages/graphics.scm b/gnu/packages/graphics.scm
index ee56dae54e..b06a369325 100644
--- a/gnu/packages/graphics.scm
+++ b/gnu/packages/graphics.scm
@@ -49,7 +49,7 @@
#:use-module (gnu packages gnome)
#:use-module (gnu packages graphviz)
#:use-module (gnu packages gtk)
- #:use-module (gnu packages haskell)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages image)
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages jemalloc)
diff --git a/gnu/packages/haskell-apps.scm b/gnu/packages/haskell-apps.scm
index ecc097ceb6..df8417ce3f 100644
--- a/gnu/packages/haskell-apps.scm
+++ b/gnu/packages/haskell-apps.scm
@@ -39,6 +39,7 @@
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
#:use-module (gnu packages haskell-web)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages ncurses)
#:use-module (gnu packages perl)
#:use-module (gnu packages pkg-config)
diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm
index 1a32382281..e0951d489c 100644
--- a/gnu/packages/haskell-check.scm
+++ b/gnu/packages/haskell-check.scm
@@ -28,8 +28,8 @@
(define-module (gnu packages haskell-check)
#:use-module (gnu packages)
- #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-crypto)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module ((guix licenses) #:prefix license:)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 53c4dcc5ff..46e5153906 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -1,5 +1,24 @@
;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2015, 2016 Federico Beffa <beffa@fbengineering.ch>
+;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
+;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
+;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
+;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
+;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
+;;; Copyright © 2017 Peter Mikkelsen <petermikkelsen10@gmail.com>
+;;; Copyright © 2017, 2018 Alex Vong <alexvong1995@gmail.com>
+;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
+;;; Copyright © 2017, 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2018 Tonton <tonton@riseup.net>
+;;; Copyright © 2018, 2019 Timothy Sample <samplet@ngyro.com>
+;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
+;;; Copyright © 2018, 2019 Gabriel Hondet <gabrielhondet@gmail.com>
;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
+;;; Copyright © 2019 Jacob MacDonald <jaccarmac@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
@@ -18,13 +37,1804 @@
(define-module (gnu packages haskell-xyz)
#:use-module (gnu packages)
- #:use-module (gnu packages haskell)
+ #:use-module (gnu packages base)
+ #:use-module (gnu packages compression)
+ #:use-module (gnu packages emacs)
+ #:use-module (gnu packages gcc)
+ #:use-module (gnu packages gl)
+ #:use-module (gnu packages graphviz)
+ #:use-module (gnu packages gtk)
+ #:use-module (gnu packages haskell-apps)
#:use-module (gnu packages haskell-check)
+ #:use-module (gnu packages haskell-crypto)
+ #:use-module (gnu packages haskell-web)
+ #:use-module (gnu packages libffi)
+ #:use-module (gnu packages linux)
+ #:use-module (gnu packages lua)
+ #:use-module (gnu packages maths)
+ #:use-module (gnu packages pcre)
+ #:use-module (gnu packages pkg-config)
+ #:use-module (gnu packages sdl)
+ #:use-module (gnu packages xml)
+ #:use-module (gnu packages xorg)
#:use-module (guix build-system haskell)
#:use-module (guix download)
+ #:use-module (guix git-download)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages))
+(define-public ghc-abstract-deque
+ (package
+ (name "ghc-abstract-deque")
+ (version "0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "abstract-deque-" version "/"
+ "abstract-deque-" version ".tar.gz"))
+ (sha256
+ (base32
+ "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-random" ,ghc-random)))
+ (home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
+ (synopsis "Abstract, parameterized interface to mutable Deques for Haskell")
+ (description "This Haskell package provides an abstract interface to
+highly-parameterizable queues/deques.
+
+Background: There exists a feature space for queues that extends between:
+
+@itemize
+@item Simple, single-ended, non-concurrent, bounded queues
+
+@item Double-ended, thread-safe, growable queues with important points
+in between (such as the queues used for work stealing).
+@end itemize
+
+This package includes an interface for Deques that allows the programmer
+to use a single API for all of the above, while using the type system to
+select an efficient implementation given the requirements (using type families).
+
+This package also includes a simple reference implementation based on
+@code{IORef} and @code{Data.Sequence}.")
+ (license license:bsd-3)))
+
+(define-public ghc-abstract-par
+ (package
+ (name "ghc-abstract-par")
+ (version "0.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "abstract-par-" version "/"
+ "abstract-par-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/simonmar/monad-par")
+ (synopsis "Abstract parallelization interface for Haskell")
+ (description "This Haskell package is an abstract interface
+only. It provides a number of type clasess, but not an
+implementation. The type classes separate different levels
+of @code{Par} functionality. See the @code{Control.Monad.Par.Class}
+module for more details.")
+ (license license:bsd-3)))
+
+(define-public ghc-adjunctions
+ (package
+ (name "ghc-adjunctions")
+ (version "4.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/adjunctions/adjunctions-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-free" ,ghc-free)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-void" ,ghc-void)))
+ (native-inputs
+ `(("ghc-generic-deriving" ,ghc-generic-deriving)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/ekmett/adjunctions/")
+ (synopsis "Adjunctions and representable functors")
+ (description "This library provides adjunctions and representable functors
+for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-aeson-compat
+ (package
+ (name "ghc-aeson-compat")
+ (version "0.3.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "aeson-compat-" version "/"
+ "aeson-compat-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0j4v13pgk21zy8hqkbx8hw0n05jdl17qphxz9rj4h333pr547r3i"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Tests require QuickCheck >= 2.10
+ (inputs `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-attoparsec" ,ghc-attoparsec-iso8601)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-nats" ,ghc-nats)))
+ (home-page "https://github.com/phadej/aeson-compat")
+ (synopsis "Compatibility layer for ghc-aeson")
+ (description "This Haskell package provides compatibility layer for
+ghc-aeson.")
+ (license license:bsd-3)))
+
+(define-public ghc-alex
+ (package
+ (name "ghc-alex")
+ (version "3.2.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/alex/alex-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0cpjixgsr0b2x4s6hz4aa6gnmjw9i7xd9nlfi8m37zqlidq4v3nm"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'check 'set-check-variables
+ (lambda _
+ (setenv "PATH" (string-append (getcwd) "/dist/build/alex:"
+ (getenv "PATH")))
+ (setenv "alex_datadir" (string-append (getcwd) "/data"))
+ #t)))))
+ (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (native-inputs
+ `(("which" ,which)))
+ (home-page "https://www.haskell.org/alex/")
+ (synopsis
+ "Tool for generating lexical analysers in Haskell")
+ (description
+ "Alex is a tool for generating lexical analysers in Haskell. It takes a
+description of tokens based on regular expressions and generates a Haskell
+module containing code for scanning text efficiently. It is similar to the
+tool lex or flex for C/C++.")
+ (license license:bsd-3)))
+
+(define-public ghc-alsa-core
+ (package
+ (name "ghc-alsa-core")
+ (version "0.5.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/alsa-core/alsa-core-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1avh4a419h9d2zsslg6j8hm87ppgsgqafz8ll037rk2yy1g4jl7b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+ ("alsa-lib" ,alsa-lib)))
+ (native-inputs
+ `(("pkg-config" ,pkg-config)))
+ (home-page "http://www.haskell.org/haskellwiki/ALSA")
+ (synopsis "Binding to the ALSA Library API (Exceptions)")
+ (description "This package provides access to ALSA infrastructure, that is
+needed by both alsa-seq and alsa-pcm.")
+ (license license:bsd-3)))
+
+(define-public ghc-annotated-wl-pprint
+ (package
+ (name "ghc-annotated-wl-pprint")
+ (version "0.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/annotated-wl-pprint"
+ "/annotated-wl-pprint-" version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/david-christiansen/annotated-wl-pprint")
+ (synopsis
+ "The Wadler/Leijen Pretty Printer, with annotation support")
+ (description "This is a modified version of wl-pprint, which was based on
+Wadler's paper \"A Prettier Printer\". This version allows the library user
+to annotate the text with semantic information, which can later be rendered in
+a variety of ways.")
+ (license license:bsd-3)))
+
+(define-public ghc-ansi-terminal
+ (package
+ (name "ghc-ansi-terminal")
+ (version "0.8.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0428gq8m3fdnb7ldcsyk97qcch76hcxbgh2666p6f76fs2qbhg7b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-colour" ,ghc-colour)))
+ (home-page "https://github.com/feuerbach/ansi-terminal")
+ (synopsis "ANSI terminal support for Haskell")
+ (description "This package provides ANSI terminal support for Haskell. It
+allows cursor movement, screen clearing, color output showing or hiding the
+cursor, and changing the title.")
+ (license license:bsd-3)))
+
+(define-public ghc-ansi-wl-pprint
+ (package
+ (name "ghc-ansi-wl-pprint")
+ (version "0.6.8.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "ansi-wl-pprint/ansi-wl-pprint-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0gnb4mkqryv08vncxnj0bzwcnd749613yw3cxfzw6y3nsldp4c56"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
+ (home-page "https://github.com/ekmett/ansi-wl-pprint")
+ (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
+ (description "This is a pretty printing library based on Wadler's paper
+\"A Prettier Printer\". It has been enhanced with support for ANSI terminal
+colored output using the ansi-terminal package.")
+ (license license:bsd-3)))
+
+(define-public ghc-appar
+ (package
+ (name "ghc-appar")
+ (version "0.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/appar/appar-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://hackage.haskell.org/package/appar")
+ (synopsis "Simple applicative parser")
+ (description "This package provides a simple applicative parser in Parsec
+style.")
+ (license license:bsd-3)))
+
+(define-public ghc-async
+ (package
+ (name "ghc-async")
+ (version "2.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/async/async-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "09whscli1q5z7lzyq9rfk0bq1ydplh6pjmc6qv0x668k5818c2wg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://github.com/simonmar/async")
+ (synopsis "Library to run IO operations asynchronously")
+ (description "Async provides a library to run IO operations
+asynchronously, and wait for their results. It is a higher-level interface
+over threads in Haskell, in which @code{Async a} is a concurrent thread that
+will eventually deliver a value of type @code{a}.")
+ (license license:bsd-3)))
+
+(define-public ghc-atomic-write
+ (package
+ (name "ghc-atomic-write")
+ (version "0.2.0.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/atomic-write/atomic-write-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1iaq0hprxcv0sl1sgwcgmm87zraf738va1bciwnx2jkk3k1v9iyv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-unix-compat" ,ghc-unix-compat)))
+ (native-inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/stackbuilders/atomic-write")
+ (synopsis "Atomically write to a file")
+ (description
+ "Atomically write to a file on POSIX-compliant systems while preserving
+permissions. @code{mv} is an atomic operation. This makes it simple to write
+to a file atomically just by using the @code{mv} operation. However, this
+will destroy the permissions on the original file. This library preserves
+permissions while atomically writing to a file.")
+ (license license:expat)))
+
+(define-public ghc-attoparsec
+ (package
+ (name "ghc-attoparsec")
+ (version "0.13.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/attoparsec/attoparsec-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0j6qcwd146yzlkc9mcvzvnixsyl65n2a68l28322q5v9p4g4g4yx"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-for-newer-quickcheck
+ (lambda _
+ (substitute* "attoparsec.cabal"
+ (("QuickCheck >= 2\\.7 && < 2\\.10")
+ "QuickCheck >= 2.7 && < 2.12"))
+ ;; This test fails because of the newer QuickCheck:
+ ;; <https://github.com/bos/attoparsec/issues/134>.
+ (substitute* "tests/QC/ByteString.hs"
+ ((", testProperty \"satisfyWith\" satisfyWith")
+ "")))))))
+ (inputs
+ `(("ghc-scientific" ,ghc-scientific)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/bos/attoparsec")
+ (synopsis "Fast combinator parsing for bytestrings and text")
+ (description "This library provides a fast parser combinator library,
+aimed particularly at dealing efficiently with network protocols and
+complicated text/binary file formats.")
+ (license license:bsd-3)))
+
+(define-public ghc-attoparsec-bootstrap
+ (package
+ (inherit ghc-attoparsec)
+ (name "ghc-attoparsec-bootstrap")
+ (arguments `(#:tests? #f))
+ (inputs
+ `(("ghc-scientific" ,ghc-scientific-bootstrap)))
+ (native-inputs '())
+ (properties '(hidden? #t))))
+
+(define-public ghc-attoparsec-iso8601
+ (package
+ (name "ghc-attoparsec-iso8601")
+ (version "1.0.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "attoparsec-iso8601-" version "/"
+ "attoparsec-iso8601-" version ".tar.gz"))
+ (sha256
+ (base32
+ "12l55b76bhya9q89mfmqmy6sl5v39b6gzrw5rf3f70vkb23nsv5a"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4")))
+ (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-base-compat" ,ghc-base-compat)))
+ (home-page "https://github.com/bos/aeson")
+ (synopsis "Parse ISO 8601 dates")
+ (description "Haskell library for parsing of ISO 8601 dates, originally
+from aeson.")
+ (license license:bsd-3)))
+
+(define-public ghc-auto-update
+ (package
+ (name "ghc-auto-update")
+ (version "0.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/auto-update/auto-update-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "09dlh2alsx2mw5kvj931yhbj0aw7jmly2cm9xbscm2sf098w35jy"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/yesodweb/wai")
+ (synopsis "Efficiently run periodic, on-demand actions")
+ (description "This library provides mechanisms to efficiently run
+periodic, on-demand actions in Haskell.")
+ (license license:expat)))
+
+(define-public ghc-aws
+ (package
+ (name "ghc-aws")
+ (version "0.20")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "aws-" version "/aws-" version ".tar.gz"))
+ (sha256 (base32
+ "0pwpabmypi1w8rni9qfwabgn95jks4h8dyw6889mn8xzsrhdhyf0"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; Tests require AWS credentials.
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-byteable" ,ghc-byteable)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-data-default" ,ghc-data-default)
+ ("ghc-http-conduit" ,ghc-http-conduit)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-network" ,ghc-network)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-xml-conduit" ,ghc-xml-conduit)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-errors" ,ghc-errors)
+ ("ghc-http-client" ,ghc-http-client)
+ ("ghc-http-client-tls" ,ghc-http-client-tls)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-conduit-combinators" ,ghc-conduit-combinators)))
+ (home-page "https://github.com/aristidb/aws")
+ (synopsis "Amazon Web Services for Haskell")
+ (description "This package attempts to provide support for using
+Amazon Web Services like S3 (storage), SQS (queuing) and others to
+Haskell programmers. The ultimate goal is to support all Amazon
+Web Services.")
+ (license license:bsd-3)))
+
+(define-public ghc-base16-bytestring
+ (package
+ (name "ghc-base16-bytestring")
+ (version "0.1.1.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/base16-bytestring/"
+ "base16-bytestring-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/bos/base16-bytestring")
+ (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings")
+ (description
+ "This package provides a Haskell library for working with base16-encoded
+data quickly and efficiently, using the ByteString type.")
+ (license license:bsd-3)))
+
+(define-public ghc-base64-bytestring
+ (package
+ (name "ghc-base64-bytestring")
+ (version "1.0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "13305brzlac24pifiqd5a2z10c6k6amhpdy9cc0z5ryrkgnm8dhr"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+ (home-page "https://github.com/bos/base64-bytestring")
+ (synopsis "Base64 encoding and decoding for ByteStrings")
+ (description "This library provides fast base64 encoding and decoding for
+Haskell @code{ByteString}s.")
+ (license license:bsd-3)))
+
+(define-public ghc-base-compat
+ (package
+ (name "ghc-base-compat")
+ (version "0.10.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/base-compat/base-compat-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0ksp990gxs731mq19rzbxrbs43nazfljjc8krlx5bjqblw3kfs8d"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/base-compat")
+ (synopsis "Haskell compiler compatibility library")
+ (description "This library provides functions available in later versions
+of base to a wider range of compilers, without requiring the use of CPP
+pragmas in your code.")
+ (license license:bsd-3)))
+
+(define-public ghc-basement
+ (package
+ (name "ghc-basement")
+ (version "0.0.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "basement/basement-" version ".tar.gz"))
+ (sha256
+ (base32
+ "194jw567di4q2758943q9rrwkbf9gl261my7qc21i9xhyabipx67"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/haskell-foundation/foundation")
+ (synopsis "Basic primitives for Foundation starter pack")
+ (description
+ "This package contains basic primitives for the Foundation set of
+packages.")
+ (license license:bsd-3)))
+
+(define-public ghc-base-orphans
+ (package
+ (name "ghc-base-orphans")
+ (version "0.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/base-orphans/base-orphans-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "057f9npnqk71ccfh95djfkpd54dzazphj06grwxa3fyhwcwxrb8a"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/base-orphans")
+ (synopsis "Orphan instances for backwards compatibility")
+ (description "This package defines orphan instances that mimic instances
+available in later versions of base to a wider (older) range of compilers.")
+ (license license:bsd-3)))
+
+(define-public ghc-base-prelude
+ (package
+ (name "ghc-base-prelude")
+ (version "1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "base-prelude-" version "/"
+ "base-prelude-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1zk728sd09hh2r4xwz4lazsrrgg5cshydn64932sm0vckplndk73"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/nikita-volkov/base-prelude")
+ (synopsis "The most complete prelude formed solely from the Haskell's base
+package")
+ (description "This Haskell package aims to reexport all the non-conflicting
+and most general definitions from the \"base\" package.
+
+This includes APIs for applicatives, arrows, monoids, foldables, traversables,
+exceptions, generics, ST, MVars and STM.
+
+This package will never have any dependencies other than \"base\".
+
+Versioning policy:
+
+The versioning policy of this package deviates from PVP in the sense
+that its exports in part are transitively determined by the version of \"base\".
+Therefore it's recommended for the users of @code{ghc-base-prelude} to specify
+the bounds of \"base\" as well.")
+ (license license:expat)))
+
+(define-public ghc-base-unicode-symbols
+ (package
+ (name "ghc-base-unicode-symbols")
+ (version "0.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/base-unicode-symbols/base-unicode-symbols-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ia6li7qjg1zkak4gf6mnbshw45mq9bfjr0jch58ds0lscmvwyzf"))))
+ (build-system haskell-build-system)
+ (home-page "http://www.haskell.org/haskellwiki/Unicode-symbols")
+ (synopsis "Unicode alternatives for common functions and operators")
+ (description "This package defines new symbols for a number of functions,
+operators and types in the base package. All symbols are documented with
+their actual definition and information regarding their Unicode code point.
+They should be completely interchangeable with their definitions. For
+further Unicode goodness you can enable the @code{UnicodeSyntax}
+@url{https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exs.html#unicode-syntax,
+language extension}. This extension enables Unicode characters to be used to
+stand for certain ASCII character sequences, i.e. → instead of @code{->},
+∀ instead of @code{forall} and many others.")
+ (license license:bsd-3)))
+
+(define-public ghc-bifunctors
+ (package
+ (name "ghc-bifunctors")
+ (version "5.5.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/bifunctors/bifunctors-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1jn9rxg643xnlhrknmjz88nblcpsr45xwjkwwnn5nxpasa7m4d6l"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-th-abstraction" ,ghc-th-abstraction)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/ekmett/bifunctors/")
+ (synopsis "Bifunctors for Haskell")
+ (description "This package provides bifunctors for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-bindings-dsl
+ (package
+ (name "ghc-bindings-dsl")
+ (version "1.0.25")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/bindings-DSL/"
+ "bindings-DSL-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0kqrd78nspl3lk4a0fqn47d8dirjg3b24dkvkigcrlb81hw35pk3"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/jwiegley/bindings-dsl/wiki")
+ (synopsis "FFI domain specific language, on top of hsc2hs")
+ (description
+ "This is a set of macros to be used when writing Haskell FFI. They were
+designed to be able to fully describe C interfaces, so that @code{hsc2hs} can
+extract from them all Haskell code needed to mimic such interfaces. All
+Haskell names used are automatically derived from C names, structures are
+mapped to Haskell instances of @code{Storable}, and there are also macros you
+can use with C code to help write bindings to inline functions or macro
+functions.")
+ (license license:bsd-3)))
+
+(define-public ghc-blaze-builder
+ (package
+ (name "ghc-blaze-builder")
+ (version "0.4.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/blaze-builder/blaze-builder-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "05681dih2d8s96an945wkbwl05w8ddbcfx8n3r3ck79ydyb8pz4i"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Missing test libraries.
+ (inputs
+ `(("ghc-utf8-string" ,ghc-utf8-string)))
+ (home-page "https://github.com/lpsmith/blaze-builder")
+ (synopsis "Efficient buffered output")
+ (description "This library provides an implementation of the older
+@code{blaze-builder} interface in terms of the new builder that shipped with
+@code{bytestring-0.10.4.0}. This implementation is mostly intended as a
+bridge to the new builder, so that code that uses the old interface can
+interoperate with code that uses the new implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-blaze-markup
+ (package
+ (name "ghc-blaze-markup")
+ (version "0.8.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "blaze-markup/blaze-markup-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0ih1c3qahkdgzbqihdhny5s313l2m66fbb88w8jbx7yz56y7rawh"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "blaze-markup.cabal"
+ (("tasty >= 1\\.0 && < 1\\.1")
+ "tasty >= 1.0 && < 1.2")))))))
+ (inputs
+ `(("ghc-blaze-builder" ,ghc-blaze-builder)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://jaspervdj.be/blaze")
+ (synopsis "Fast markup combinator library for Haskell")
+ (description "This library provides core modules of a markup combinator
+library for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-bloomfilter
+ (package
+ (name "ghc-bloomfilter")
+ (version "2.0.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "bloomfilter/bloomfilter-" version ".tar.gz"))
+ (sha256
+ (base32
+ "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-random" ,ghc-random)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/bos/bloomfilter")
+ (synopsis "Pure and impure Bloom filter implementations")
+ (description "This package provides both mutable and immutable Bloom
+filter data types, along with a family of hash functions and an easy-to-use
+interface.")
+ (license license:bsd-3)))
+
+(define-public ghc-boxes
+ (package
+ (name "ghc-boxes")
+ (version "0.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/boxes/boxes-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1hsnmw95i58d4bkpxby3ddsj1cawypw4mdyb18m393s5i8p7iq9q"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-split" ,ghc-split)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/boxes")
+ (synopsis "2D text pretty-printing library")
+ (description
+ "Boxes is a pretty-printing library for laying out text in two dimensions,
+using a simple box model.")
+ (license license:bsd-3)))
+
+(define-public ghc-byteable
+ (package
+ (name "ghc-byteable")
+ (version "0.1.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "byteable/byteable-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/vincenthz/hs-byteable")
+ (synopsis "Type class for sequence of bytes")
+ (description
+ "This package provides an abstract class to manipulate sequence of bytes.
+The use case of this class is abstracting manipulation of types that are just
+wrapping a bytestring with stronger and more meaniful name.")
+ (license license:bsd-3)))
+
+(define-public ghc-byteorder
+ (package
+ (name "ghc-byteorder")
+ (version "1.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/byteorder/byteorder-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://community.haskell.org/~aslatter/code/byteorder")
+ (synopsis
+ "Exposes the native endianness of the system")
+ (description
+ "This package is for working with the native byte-ordering of the
+system.")
+ (license license:bsd-3)))
+
+(define-public ghc-bytes
+ (package
+ (name "ghc-bytes")
+ (version "0.15.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append "https://hackage.haskell.org/package/bytes-"
+ version "/bytes-"
+ version ".tar.gz"))
+ (file-name (string-append name "-" version ".tar.gz"))
+ (sha256
+ (base32
+ "063il2vrn0p88r9gzndh4ijs0mxj37khkc9ym9bqdsv7ngk3b683"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-cereal" ,ghc-cereal)
+ ("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-void" ,ghc-void)
+ ("ghc-vector" ,ghc-vector)))
+ (synopsis "Serialization between @code{binary} and @code{cereal}")
+ (description "This package provides a simple compatibility shim that lets
+you work with both @code{binary} and @code{cereal} with one chunk of
+serialization code.")
+ (home-page "https://hackage.haskell.org/package/bytes")
+ (license license:bsd-3)))
+
+(define-public ghc-bytestring-builder
+ (package
+ (name "ghc-bytestring-builder")
+ (version "0.10.8.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/bytestring-builder"
+ "/bytestring-builder-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1hnvjac28y44yn78c9vdp1zvrknvlw98ky3g4n5vivr16rvh8x3d"))))
+ (build-system haskell-build-system)
+ (arguments `(#:haddock? #f)) ; Package contains no documentation.
+ (home-page "https://hackage.haskell.org/package/bytestring-builder")
+ (synopsis "The new bytestring builder, packaged outside of GHC")
+ (description "This package provides the bytestring builder that is
+debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
+Compatibility package for older packages.")
+ (license license:bsd-3)))
+
+(define-public ghc-bytestring-handle
+ (package
+ (name "ghc-bytestring-handle")
+ (version "0.1.0.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/bytestring-handle/bytestring-handle-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "bytestring-handle.cabal"
+ (("QuickCheck >= 2\\.1\\.2 && < 2\\.11")
+ "QuickCheck >= 2.1.2 && < 2.12")
+ (("base >= 4\\.2 && < 4\\.11")
+ "base >= 4.2 && < 4.12")))))))
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://hub.darcs.net/ganesh/bytestring-handle")
+ (synopsis "ByteString-backed Handles")
+ (description "ByteString-backed Handles") ; There is no description
+ (license license:bsd-3)))
+
+(define-public ghc-bytestring-lexing
+ (package
+ (name "ghc-bytestring-lexing")
+ (version "0.5.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "bytestring-lexing/bytestring-lexing-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0wrzniawhgpphc6yx1v972gyqxdbv0pizaz9bafahrshyb9svy81"))))
+ (build-system haskell-build-system)
+ (home-page "http://code.haskell.org/~wren/")
+ (synopsis "Parse and produce literals from strict or lazy bytestrings")
+ (description
+ "This package provides tools to parse and produce literals efficiently
+from strict or lazy bytestrings.")
+ (license license:bsd-2)))
+
+(define-public ghc-bzlib-conduit
+ (package
+ (name "ghc-bzlib-conduit")
+ (version "0.3.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/bzlib-conduit/"
+ "bzlib-conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0fd2hnr782s7qgipazg2yxwia9qqhkvm9bcm90773c3zkxa13n23"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-bindings-dsl" ,ghc-bindings-dsl)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-resourcet" ,ghc-resourcet)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-random" ,ghc-random)))
+ (home-page "https://github.com/snoyberg/bzlib-conduit")
+ (synopsis "Streaming compression/decompression via conduits")
+ (description
+ "This package provides Haskell bindings to bzlib and Conduit support for
+streaming compression and decompression.")
+ (license license:bsd-3)))
+
+(define-public ghc-c2hs
+ (package
+ (name "ghc-c2hs")
+ (version "0.28.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/c2hs/c2hs-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1nplgxfin139x12sb656f5870rpdclrhzi8mq8pry035qld15pci"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-language-c" ,ghc-language-c)
+ ("ghc-dlist" ,ghc-dlist)))
+ (native-inputs
+ `(("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-shelly" ,ghc-shelly)
+ ("gcc" ,gcc)))
+ (arguments
+ `(;; XXX: Test failures are induced by a parse error in <bits/floatn.h>
+ ;; of glibc 2.28.
+ #:tests? #f
+
+ #:phases
+ (modify-phases %standard-phases
+ (add-before 'check 'set-cc
+ ;; add a cc executable in the path, needed for some tests to pass
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((gcc (assoc-ref inputs "gcc"))
+ (tmpbin (tmpnam))
+ (curpath (getenv "PATH")))
+ (mkdir-p tmpbin)
+ (symlink (which "gcc") (string-append tmpbin "/cc"))
+ (setenv "PATH" (string-append tmpbin ":" curpath)))
+ #t))
+ (add-after 'check 'remove-cc
+ ;; clean the tmp dir made in 'set-cc
+ (lambda _
+ (let* ((cc-path (which "cc"))
+ (cc-dir (dirname cc-path)))
+ (delete-file-recursively cc-dir)
+ #t))))))
+ (home-page "https://github.com/haskell/c2hs")
+ (synopsis "Create Haskell bindings to C libraries")
+ (description "C->Haskell assists in the development of Haskell bindings to
+C libraries. It extracts interface information from C header files and
+generates Haskell code with foreign imports and marshaling. Unlike writing
+foreign imports by hand (or using hsc2hs), this ensures that C functions are
+imported with the correct Haskell types.")
+ (license license:gpl2)))
+
+(define-public ghc-cairo
+ (package
+ (name "ghc-cairo")
+ (version "0.13.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/cairo/"
+ "cairo-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:modules ((guix build haskell-build-system)
+ (guix build utils)
+ (ice-9 match)
+ (srfi srfi-26))
+ #:phases
+ (modify-phases %standard-phases
+ ;; FIXME: This is a copy of the standard configure phase with a tiny
+ ;; difference: this package needs the -package-db flag to be passed
+ ;; to "runhaskell" in addition to the "configure" action, because it
+ ;; depends on gtk2hs-buildtools, which provide setup hooks. Without
+ ;; this option the Setup.hs file cannot be evaluated. The
+ ;; haskell-build-system should be changed to pass "-package-db" to
+ ;; "runhaskell" in any case.
+ (replace 'configure
+ (lambda* (#:key outputs inputs tests? (configure-flags '())
+ #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (name-version (strip-store-file-name out))
+ (input-dirs (match inputs
+ (((_ . dir) ...)
+ dir)
+ (_ '())))
+ (ghc-path (getenv "GHC_PACKAGE_PATH"))
+ (params (append `(,(string-append "--prefix=" out))
+ `(,(string-append "--libdir=" out "/lib"))
+ `(,(string-append "--bindir=" out "/bin"))
+ `(,(string-append
+ "--docdir=" out
+ "/share/doc/" name-version))
+ '("--libsubdir=$compiler/$pkg-$version")
+ '("--package-db=../package.conf.d")
+ '("--global")
+ `(,@(map
+ (cut string-append "--extra-include-dirs=" <>)
+ (search-path-as-list '("include") input-dirs)))
+ `(,@(map
+ (cut string-append "--extra-lib-dirs=" <>)
+ (search-path-as-list '("lib") input-dirs)))
+ (if tests?
+ '("--enable-tests")
+ '())
+ configure-flags)))
+ (unsetenv "GHC_PACKAGE_PATH")
+ (apply invoke "runhaskell" "-package-db=../package.conf.d"
+ "Setup.hs" "configure" params)
+ (setenv "GHC_PACKAGE_PATH" ghc-path)
+ #t))))))
+ (inputs
+ `(("ghc-utf8-string" ,ghc-utf8-string)
+ ("cairo" ,cairo)))
+ (native-inputs
+ `(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools)
+ ("pkg-config" ,pkg-config)))
+ (home-page "http://projects.haskell.org/gtk2hs/")
+ (synopsis "Haskell bindings to the Cairo vector graphics library")
+ (description
+ "Cairo is a library to render high quality vector graphics. There exist
+various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG
+documents, amongst others.")
+ (license license:bsd-3)))
+
+(define-public ghc-call-stack
+ (package
+ (name "ghc-call-stack")
+ (version "0.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "call-stack/call-stack-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1qmihf5jafmc79sk52l6gpx75f5bnla2lp62kh3p34x3j84mwpzj"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-nanospec" ,ghc-nanospec)))
+ (home-page "https://github.com/sol/call-stack#readme")
+ (synopsis "Use GHC call-stacks in a backward compatible way")
+ (description "This package provides a compatibility layer for using GHC
+call stacks with different versions of the compiler.")
+ (license license:expat)))
+
+;; This is used as an input to ghc-hunit. We cannot use ghc-call-stack there,
+;; because it depends on ghc-nanospec, which depends on ghc-hunit.
+(define-public ghc-call-stack-boot
+ (hidden-package
+ (package
+ (inherit ghc-call-stack)
+ (arguments '(#:tests? #f))
+ (inputs '()))))
+
+(define-public ghc-case-insensitive
+ (package
+ (name "ghc-case-insensitive")
+ (version "1.2.0.11")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/case-insensitive/case-insensitive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1qrpxfirsxckg7jv28f5ah2qc8lh95hp7rnqkbqs1ahcwlbnvkm7"))))
+ (build-system haskell-build-system)
+ ;; these inputs are necessary to use this library
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page
+ "https://github.com/basvandijk/case-insensitive")
+ (synopsis "Case insensitive string comparison")
+ (description
+ "The module @code{Data.CaseInsensitive} provides the @code{CI} type
+constructor which can be parameterised by a string-like type like:
+@code{String}, @code{ByteString}, @code{Text}, etc. Comparisons of values of
+the resulting type will be insensitive to cases.")
+ (license license:bsd-3)))
+
+(define-public ghc-cereal
+ (package
+ (name "ghc-cereal")
+ (version "0.5.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/cereal/cereal-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1j7imh2mzqcljld7sx0av69699955rpy3hzivi5723i6a9nszgbs"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://hackage.haskell.org/package/cereal")
+ (synopsis "Binary serialization library")
+ (description "This package provides a binary serialization library,
+similar to @code{binary}, that introduces an @code{isolate} primitive for
+parser isolation, and labeled blocks for better error messages.")
+ (license license:bsd-3)))
+
+(define-public ghc-cereal-conduit
+ (package
+ (name "ghc-cereal-conduit")
+ (version "0.8.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cereal-conduit/cereal-conduit-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1srr7agvgfw78q5s1npjq5sgynvhjgllpihiv37ylkwqm4c4ap6r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-cereal" ,ghc-cereal)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/snoyberg/conduit")
+ (synopsis "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits")
+ (description
+ "This package turn @code{Data.Serialize} @code{Gets} and @code{Puts} into
+@code{Sources}, @code{Sinks}, and @code{Conduits}.")
+ (license license:bsd-3)))
+
+(define-public ghc-cgi
+ (package
+ (name "ghc-cgi")
+ (version "3001.3.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/cgi/cgi-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1hbpplss1m4rdpm4ibip6fpimlhssqa14fl338kl2jbc463i64cj"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "cgi.cabal"
+ (("exceptions < 0\\.9")
+ "exceptions < 0.11")
+ (("time >= 1\\.5 && < 1\\.7")
+ "time >= 1.5 && < 1.9")
+ (("doctest >= 0\\.8 && < 0\\.12")
+ "doctest >= 0.8 && < 0.17")
+ (("QuickCheck >= 2\\.8\\.1 && < 2\\.10")
+ "QuickCheck >= 2.8.1 && < 2.12")))))))
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-multipart" ,ghc-multipart)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-network" ,ghc-network)))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page
+ "https://github.com/cheecheeo/haskell-cgi")
+ (synopsis "Library for writing CGI programs")
+ (description
+ "This is a Haskell library for writing CGI programs.")
+ (license license:bsd-3)))
+
+(define-public ghc-charset
+ (package
+ (name "ghc-charset")
+ (version "0.3.7.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/charset/charset-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (home-page "https://github.com/ekmett/charset")
+ (synopsis "Fast unicode character sets for Haskell")
+ (description "This package provides fast unicode character sets for
+Haskell, based on complemented PATRICIA tries.")
+ (license license:bsd-3)))
+
+(define-public ghc-chart
+ (package
+ (name "ghc-chart")
+ (version "1.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/Chart/"
+ "Chart-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1f5azj17y8xsb3gjhf7gg1gnnlq12rxkmfjmgcly314d7vghs05z"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-operational" ,ghc-operational)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/timbod7/haskell-chart/wiki")
+ (synopsis "Library for generating 2D charts and plots")
+ (description
+ "This package provides a library for generating 2D charts and plots, with
+backends provided by the @code{Cairo} and @code{Diagrams} libraries.")
+ (license license:bsd-3)))
+
+(define-public ghc-chart-cairo
+ (package
+ (name "ghc-chart-cairo")
+ (version "1.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/Chart-cairo/"
+ "Chart-cairo-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-cairo" ,ghc-cairo)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-operational" ,ghc-operational)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-chart" ,ghc-chart)))
+ (home-page "https://github.com/timbod7/haskell-chart/wiki")
+ (synopsis "Cairo backend for Charts")
+ (description "This package provides a Cairo vector graphics rendering
+backend for the Charts library.")
+ (license license:bsd-3)))
+
+(define-public ghc-chasingbottoms
+ (package
+ (name "ghc-chasingbottoms")
+ (version "1.3.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/ChasingBottoms/"
+ "ChasingBottoms-" version ".tar.gz"))
+ (sha256
+ (base32
+ "06cynx6hcbfpky7qq3b3mjjgwbnaxkwin3znbwq4b9ikiw0ng633"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-random" ,ghc-random)
+ ("ghc-syb" ,ghc-syb)))
+ (home-page "https://hackage.haskell.org/package/ChasingBottoms")
+ (synopsis "Testing of partial and infinite values in Haskell")
+ (description
+ ;; FIXME: There should be a @comma{} in the uref text, but it is not
+ ;; rendered properly.
+ "This is a library for testing code involving bottoms or infinite values.
+For the underlying theory and a larger example involving use of QuickCheck,
+see the article
+@uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
+\"Chasing Bottoms A Case Study in Program Verification in the Presence of
+Partial and Infinite Values\"}.")
+ (license license:expat)))
+
+(define-public ghc-cheapskate
+ (package
+ (name "ghc-cheapskate")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/cheapskate/cheapskate-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1hiqi7h76shjzs2zj0j8g6wnq2hbiq1hmfafdazr97fba2zl2432"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-xss-sanitize" ,ghc-xss-sanitize)
+ ("ghc-data-default" ,ghc-data-default)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-uniplate" ,ghc-uniplate)))
+ (home-page "https://github.com/jgm/cheapskate")
+ (synopsis "Experimental markdown processor")
+ (description "Cheapskate is an experimental Markdown processor in pure
+Haskell. It aims to process Markdown efficiently and in the most forgiving
+possible way. It is designed to deal with any input, including garbage, with
+linear performance. Output is sanitized by default for protection against
+cross-site scripting (@dfn{XSS}) attacks.")
+ (license license:bsd-3)))
+
+(define-public ghc-chell
+ (package
+ (name "ghc-chell")
+ (version "0.4.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/chell/chell-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "10ingy9qnbmc8cqh4i9pskcw43l0mzk8f3d76b3qz3fig5ary3j9"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-options-bootstrap" ,ghc-options-bootstrap)
+ ("ghc-patience" ,ghc-patience)
+ ("ghc-random" ,ghc-random)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)))
+ (home-page "https://john-millikin.com/software/chell/")
+ (synopsis "Simple and intuitive library for automated testing")
+ (description
+ "Chell is a simple and intuitive library for automated testing.
+It natively supports assertion-based testing, and can use companion
+libraries such as @code{chell-quickcheck} to support more complex
+testing strategies.")
+ (license license:expat)))
+
+(define-public ghc-chell-quickcheck
+ (package
+ (name "ghc-chell-quickcheck")
+ (version "0.2.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/chell-quickcheck/"
+ "chell-quickcheck-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "chell-quickcheck.cabal"
+ (("QuickCheck >= 2\\.3 && < 2\\.11")
+ "QuickCheck >= 2.3 && < 2.12")))))))
+ (inputs
+ `(("ghc-chell" ,ghc-chell)
+ ("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap)
+ ("ghc-random" ,ghc-random)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://john-millikin.com/software/chell/")
+ (synopsis "QuickCheck support for the Chell testing library")
+ (description "More complex tests for @code{chell}.")
+ (license license:expat)))
+
+(define ghc-chell-quickcheck-bootstrap
+ (package
+ (name "ghc-chell-quickcheck-bootstrap")
+ (version "0.2.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/chell-quickcheck/"
+ "chell-quickcheck-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-chell" ,ghc-chell)
+ ("ghc-random" ,ghc-random)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "chell-quickcheck.cabal"
+ (("QuickCheck >= 2\\.3 && < 2\\.11")
+ "QuickCheck >= 2.3 && < 2.12")))))))
+ (home-page "https://john-millikin.com/software/chell/")
+ (synopsis "QuickCheck support for the Chell testing library")
+ (description "More complex tests for @code{chell}.")
+ (license license:expat)))
+
+(define-public ghc-chunked-data
+ (package
+ (name "ghc-chunked-data")
+ (version "0.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "chunked-data-" version "/"
+ "chunked-data-" version ".tar.gz"))
+ (sha256
+ (base32
+ "16m7y7fwrirbjbqqcsfmr4yxa9qvfax6r7pw0zl9ky71ms0wa47p"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-vector" ,ghc-vector)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://github.com/snoyberg/mono-traversable")
+ (synopsis "Typeclasses for dealing with various chunked data
+representations for Haskell")
+ (description "This Haskell package was originally present in
+classy-prelude.")
+ (license license:expat)))
+
+(define-public ghc-clock
+ (package
+ (name "ghc-clock")
+ (version "0.7.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "clock/"
+ "clock-" version ".tar.gz"))
+ (sha256
+ (base32 "07v91s20halsqjmziqb1sqjp2sjpckl9by7y28aaklwqi2bh2rl8"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/clock")
+ (synopsis "High-resolution clock for Haskell")
+ (description "A package for convenient access to high-resolution clock and
+timer functions of different operating systems via a unified API.")
+ (license license:bsd-3)))
+
+;; This package builds `clock` without tests, since the tests rely on tasty
+;; and tasty-quickcheck, which in turn require clock to build.
+(define-public ghc-clock-bootstrap
+ (package
+ (inherit ghc-clock)
+ (name "ghc-clock-bootstrap")
+ (arguments '(#:tests? #f))
+ (inputs '())
+ (properties '((hidden? #t)))))
+
+(define-public ghc-cmark
+ (package
+ (name "ghc-cmark")
+ (version "0.5.6")
+ (source (origin
+ (method url-fetch)
+ ;; XXX As of version 0.5.6, this package bundles libcmark 0.28.0.
+ ;; See cbits/cmark_version.h.
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cmark/cmark-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1c1j3a8b9qx5zk9myqm3gap8ymz7fipwrdmyfsq9wkkdr9x4np45"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/jgm/commonmark-hs")
+ (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
+ (description
+ "This package provides Haskell bindings for
+@uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
+CommonMark, a fully specified variant of Markdown. It includes bundled libcmark
+sources, and does not require prior installation of the C library.")
+ (license license:bsd-3)))
+
+(define-public ghc-cmark-gfm
+ (package
+ (name "ghc-cmark-gfm")
+ (version "0.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cmark-gfm/cmark-gfm-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "13b0mqks5c1q989slgsa3ixr5vvkfyic4ynzgv00kgl5qrs7hqk7"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/kivikakk/cmark-gfm-hs")
+ (synopsis
+ "Fast, accurate GitHub Flavored Markdown parser and renderer")
+ (description
+ "This package provides Haskell bindings for libcmark-gfm, the reference
+parser for GitHub Flavored Markdown, a fully specified variant of Markdown.
+It includes sources for libcmark-gfm and does not require prior installation
+of the C library.")
+ (license license:bsd-3)))
+
+(define-public ghc-cmdargs
+ (package
+ (name "ghc-cmdargs")
+ (version "0.10.20")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/cmdargs/cmdargs-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://community.haskell.org/~ndm/cmdargs/")
+ (synopsis "Command line argument processing")
+ (description
+ "This library provides an easy way to define command line parsers.")
+ (license license:bsd-3)))
+
+(define-public ghc-code-page
+ (package
+ (name "ghc-code-page")
+ (version "0.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/code-page/code-page-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1491frk4jx6dlhifky9dvcxbsbcfssrz979a5hp5zn061rh8cp76"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/RyanGlScott/code-page")
+ (synopsis "Windows code page library for Haskell")
+ (description "A cross-platform library with functions for adjusting
+code pages on Windows. On all other operating systems, the library does
+nothing.")
+ (license license:bsd-3)))
+
+(define-public ghc-colour
+(package
+ (name "ghc-colour")
+ (version "2.3.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/colour/colour-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1sy51nz096sv91nxqk6yk7b92b5a40axv9183xakvki2nc09yhqg"))))
+ (arguments
+ ;; The tests for this package have the following dependency cycle:
+ ;; ghc-test-framework -> ghc-ansi-terminal -> ghc-colour.
+ `(#:tests? #f))
+ (build-system haskell-build-system)
+ (home-page "https://www.haskell.org/haskellwiki/Colour")
+ (synopsis "Model for human colour perception")
+ (description
+ "This package provides a data type for colours and transparency.
+Colours can be blended and composed. Various colour spaces are
+supported. A module of colour names (\"Data.Colour.Names\") is provided.")
+ (license license:expat)))
+
+(define-public ghc-comonad
+ (package
+ (name "ghc-comonad")
+ (version "5.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/comonad/comonad-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "09g870c4flp4k3fgbibsd0mmfjani1qcpbcl685v8x89kxzrva3q"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)))
+ (inputs
+ `(("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/ekmett/comonad/")
+ (synopsis "Comonads for Haskell")
+ (description "This library provides @code{Comonad}s for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-concatenative
+ (package
+ (name "ghc-concatenative")
+ (version "1.0.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/concatenative/concatenative-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty")
+ (synopsis "Library for postfix control flow")
+ (description
+ "Concatenative gives Haskell Factor-style combinators and arrows for
+postfix notation. For more information on stack based languages, see
+@uref{https://concatenative.org}.")
+ (license license:bsd-3)))
+
(define-public ghc-concurrent-extra
(package
(name "ghc-concurrent-extra")
@@ -76,6 +1886,3384 @@ This package was inspired by the concurrency libraries of Java and
Python.")
(license license:bsd-3)))
+(define-public ghc-concurrent-output
+ (package
+ (name "ghc-concurrent-output")
+ (version "1.10.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/concurrent-output/concurrent-output-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0mwf155w89nbbkjln7hhbn8k3f8p0ylcvgrg31cm7ijpx4499i4c"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-terminal-size" ,ghc-terminal-size)))
+ (home-page
+ "https://hackage.haskell.org/package/concurrent-output")
+ (synopsis
+ "Ungarble output from several threads or commands")
+ (description
+ "Lets multiple threads and external processes concurrently output to the
+console, without it getting all garbled up.
+
+Built on top of that is a way of defining multiple output regions, which are
+automatically laid out on the screen and can be individually updated by
+concurrent threads. Can be used for progress displays etc.")
+ (license license:bsd-2)))
+
+(define-public ghc-conduit
+ (package
+ (name "ghc-conduit")
+ (version "1.3.0.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "conduit/conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1sangm0qqi9dzlq95746a3kl14k8b09592a423shxjf2a0b1yx5v"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-mono-traversable" ,ghc-mono-traversable)
+ ("ghc-mmorph" ,ghc-mmorph)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-void" ,ghc-void)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-split" ,ghc-split)))
+ (home-page "https://github.com/snoyberg/conduit")
+ (synopsis "Streaming data library ")
+ (description
+ "The conduit package is a solution to the streaming data problem,
+allowing for production, transformation, and consumption of streams of data
+in constant memory. It is an alternative to lazy I/O which guarantees
+deterministic resource handling, and fits in the same general solution
+space as enumerator/iteratee and pipes.")
+ (license license:expat)))
+
+(define-public ghc-conduit-algorithms
+ (package
+ (name "ghc-conduit-algorithms")
+ (version "0.0.8.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "conduit-algorithms/conduit-algorithms-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "07gx2q3d1bbfw14q41rmqg0i4m018pci10lswc0k1ij6lw7sb9fd"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-bzlib-conduit" ,ghc-bzlib-conduit)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-combinators" ,ghc-conduit-combinators)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-lzma-conduit" ,ghc-lzma-conduit)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-pqueue" ,ghc-pqueue)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-stm-conduit" ,ghc-stm-conduit)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("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-algorithms#readme")
+ (synopsis "Conduit-based algorithms")
+ (description
+ "This package provides algorithms on @code{Conduits}, including higher
+level asynchronous processing and some other utilities.")
+ (license license:expat)))
+
+(define-public ghc-conduit-combinators
+ (package
+ (name "ghc-conduit-combinators")
+ (version "1.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "conduit-combinators-" version "/"
+ "conduit-combinators-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1lz70vwp4y4lpsivxl0cshq7aq3968rh48r6rjvpyaj2l0bdj5wp"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-void" ,ghc-void)
+ ("ghc-mwc-random" ,ghc-mwc-random)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-chunked-data" ,ghc-chunked-data)
+ ("ghc-mono-traversable" ,ghc-mono-traversable)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/snoyberg/mono-traversable")
+ (synopsis "Commonly used conduit functions, for both chunked and
+unchunked data")
+ (description "This Haskell package provides a replacement for Data.Conduit.List,
+as well as a convenient Conduit module.")
+ (license license:expat)))
+
+(define-public ghc-conduit-extra
+ (package
+ (name "ghc-conduit-extra")
+ (version "1.3.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "conduit-extra/conduit-extra-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0jaj350vv6mbb26gdwcqz4gwzfzrjydv5pis2da49wz1npbakcfw"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-typed-process" ,ghc-typed-process)
+ ("ghc-async" ,ghc-async)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-network" ,ghc-network)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (native-inputs
+ `(("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/snoyberg/conduit")
+ (synopsis "Conduit adapters for common libraries")
+ (description
+ "The @code{conduit} package itself maintains relative small dependencies.
+The purpose of this package is to collect commonly used utility functions
+wrapping other library dependencies, without depending on heavier-weight
+dependencies. The basic idea is that this package should only depend on
+@code{haskell-platform} packages and @code{conduit}.")
+ (license license:expat)))
+
+(define-public ghc-configurator
+ (package
+ (name "ghc-configurator")
+ (version "0.3.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "configurator/configurator-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "http://github.com/bos/configurator")
+ (synopsis "Configuration management")
+ (description
+ "This package provides a configuration management library for programs
+and daemons. The features include:
+
+@enumerate
+@item Automatic, dynamic reloading in response to modifications to
+ configuration files.
+@item A simple, but flexible, configuration language, supporting several of
+ the most commonly needed types of data, along with interpolation of strings
+ from the configuration or the system environment (e.g. @code{$(HOME)}).
+@item Subscription-based notification of changes to configuration properties.
+@item An @code{import} directive allows the configuration of a complex
+ application to be split across several smaller files, or common configuration
+ data to be shared across several applications.
+@end enumerate\n")
+ (license license:bsd-3)))
+
+(define-public ghc-connection
+ (package
+ (name "ghc-connection")
+ (version "0.2.8")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "connection/connection-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1swkb9w5vx9ph7x55y51dc0srj2z27nd9ibgn8c0qcl6hx7g9cbh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-network" ,ghc-network)
+ ("ghc-tls" ,ghc-tls)
+ ("ghc-socks" ,ghc-socks)
+ ("ghc-x509" ,ghc-x509)
+ ("ghc-x509-store" ,ghc-x509-store)
+ ("ghc-x509-system" ,ghc-x509-system)
+ ("ghc-x509-validation" ,ghc-x509-validation)))
+ (home-page "https://github.com/vincenthz/hs-connection")
+ (synopsis "Simple and easy network connections API")
+ (description
+ "This package provides a simple network library for all your connection
+needs. It provides a very simple API to create sockets to a destination with
+the choice of SSL/TLS, and SOCKS.")
+ (license license:bsd-3)))
+
+(define-public ghc-constraints
+ (package
+ (name "ghc-constraints")
+ (version "0.10.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/constraints/constraints-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1xy3vv78jxc17hm0z7qqspxjwv7l2jbcbj670yrl2f053qkfr02q"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/ekmett/constraints/")
+ (synopsis "Constraint manipulation")
+ (description
+ "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
+They stopped crashing the compiler in GHC 7.6. This package provides
+a vocabulary for working with them.")
+ (license license:bsd-3)))
+
+(define-public ghc-contravariant
+ (package
+ (name "ghc-contravariant")
+ (version "1.4.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/contravariant/contravariant-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1vfhk8c5cxmmakx7rflap1ipkx5q0j5vnlrcz7yz6y53kxhksgf9"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-void" ,ghc-void)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-statevar" ,ghc-statevar)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page
+ "https://github.com/ekmett/contravariant/")
+ (synopsis "Contravariant functors")
+ (description "Contravariant functors for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-contravariant-extras
+ (package
+ (name "ghc-contravariant-extras")
+ (version "0.3.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "contravariant-extras-" version "/"
+ "contravariant-extras-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0gg62ccl94kvh7mnvdq09pifqxjx2kgs189si90nmg44bafj7a9n"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-tuple-th" ,ghc-tuple-th)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-base-prelude" ,ghc-base-prelude)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://github.com/nikita-volkov/contravariant-extras")
+ (synopsis "Extras for the @code{ghc-contravariant} Haskell package")
+ (description "This Haskell package provides extras for the
+@code{ghc-contravariant} package.")
+ (license license:expat)))
+
+(define-public ghc-convertible
+ (package
+ (name "ghc-convertible")
+ (version "1.1.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/convertible/"
+ "convertible-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-time" ,ghc-old-time)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (home-page "https://hackage.haskell.org/package/convertible")
+ (synopsis "Typeclasses and instances for converting between types")
+ (description
+ "This package provides a typeclass with a single function that is
+designed to help convert between different types: numeric values, dates and
+times, and the like. The conversions perform bounds checking and return a
+pure @code{Either} value. This means that you need not remember which specific
+function performs the conversion you desire.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-accessor
+ (package
+ (name "ghc-data-accessor")
+ (version "0.2.2.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/data-accessor/data-accessor-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1vf2g1gac3rm32g97rl0fll51m88q7ry4m6khnl5j47qsmx24r9l"))))
+ (build-system haskell-build-system)
+ (home-page "https://www.haskell.org/haskellwiki/Record_access")
+ (synopsis
+ "Haskell utilities for accessing and manipulating fields of records")
+ (description "This package provides Haskell modules for accessing and
+manipulating fields of records.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-accessor-transformers
+ (package
+ (name "ghc-data-accessor-transformers")
+ (version "0.2.1.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/data-accessor-transformers/"
+ "data-accessor-transformers-" version ".tar.gz"))
+ (sha256
+ (base32 "0yp030vafbpddl27m606aibbbr5ar5j5bsv4bksscz3cq4yq5j10"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-data-accessor" ,ghc-data-accessor)))
+ (home-page "https://www.haskell.org/haskellwiki/Record_access")
+ (synopsis "Use Accessor to access state in transformers State monad")
+ (description "This package provides Haskell modules to allow use of
+Accessor to access state in transformers State monad.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-default
+ (package
+ (name "ghc-data-default")
+ (version "0.7.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/data-default/data-default-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "04d5n8ybmcxba9qb6h389w9zfq1lvj81b82jh6maqp6pkhkmvydh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-data-default-class"
+ ,ghc-data-default-class)
+ ("ghc-data-default-instances-base"
+ ,ghc-data-default-instances-base)
+ ("ghc-data-default-instances-containers"
+ ,ghc-data-default-instances-containers)
+ ("ghc-data-default-instances-dlist"
+ ,ghc-data-default-instances-dlist)
+ ("ghc-data-default-instances-old-locale"
+ ,ghc-data-default-instances-old-locale)))
+ (home-page "https://hackage.haskell.org/package/data-default")
+ (synopsis "Types with default values")
+ (description
+ "This package defines a class for types with a default value, and
+provides instances for types from the base, containers, dlist and old-locale
+packages.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-default-class
+ (package
+ (name "ghc-data-default-class")
+ (version "0.1.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/data-default-class/"
+ "data-default-class-" version ".tar.gz"))
+ (sha256
+ (base32 "0miyjz8d4jyvqf2vp60lyfbnflx6cj2k8apmm9ly1hq0y0iv80ag"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/data-default-class")
+ (synopsis "Types with default values")
+ (description
+ "This package defines a class for types with default values.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-base
+ (package
+ (name "ghc-data-default-instances-base")
+ (version "0.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "data-default-instances-base/"
+ "data-default-instances-base-" version ".tar.gz"))
+ (sha256
+ (base32 "0ym1sw3ssdzzifxxhh76qlv8kkmb2iclc158incv1dklyr9y8kw4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-data-default-class" ,ghc-data-default-class)))
+ (home-page "https://hackage.haskell.org/package/data-default-instances-base")
+ (synopsis "Default instances for types in base")
+ (description
+ "This package provides default instances for types from the base
+package.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-containers
+ (package
+ (name "ghc-data-default-instances-containers")
+ (version "0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "data-default-instances-containers/"
+ "data-default-instances-containers-" version ".tar.gz"))
+ (sha256
+ (base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-data-default-class" ,ghc-data-default-class)))
+ (home-page "https://hackage.haskell.org/package/data-default-instances-containers")
+ (synopsis "Default instances for types in containers")
+ (description "Provides default instances for types from the containers
+package.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-dlist
+ (package
+ (name "ghc-data-default-instances-dlist")
+ (version "0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "data-default-instances-dlist/"
+ "data-default-instances-dlist-" version ".tar.gz"))
+ (sha256
+ (base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-dlist" ,ghc-dlist)))
+ (home-page "https://hackage.haskell.org/package/data-default-instances-dlist")
+ (synopsis "Default instances for types in dlist")
+ (description "Provides default instances for types from the dlist
+package.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-default-instances-old-locale
+ (package
+ (name "ghc-data-default-instances-old-locale")
+ (version "0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "data-default-instances-old-locale/"
+ "data-default-instances-old-locale-" version ".tar.gz"))
+ (sha256
+ (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (home-page
+ "https://hackage.haskell.org/package/data-default-instances-old-locale")
+ (synopsis "Default instances for types in old-locale")
+ (description "Provides Default instances for types from the old-locale
+ package.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-hash
+ (package
+ (name "ghc-data-hash")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/data-hash"
+ "/data-hash-" version ".tar.gz"))
+ (sha256
+ (base32 "1ghbqvc48gf9p8wiy71hdpaj7by3b9cw6wgwi3qqz8iw054xs5wi"))))
+ (build-system haskell-build-system)
+ (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/data-hash")
+ (synopsis "Combinators for building fast hashing functions")
+ (description
+ "This package provides combinators for building fast hashing functions.
+It includes hashing functions for all basic Haskell98 types.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-ordlist
+ (package
+ (name "ghc-data-ordlist")
+ (version "0.4.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/data-ordlist/data-ordlist-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/data-ordlist")
+ (synopsis "Set and bag operations on ordered lists")
+ (description
+ "This module provides set and multiset operations on ordered lists.")
+ (license license:bsd-3)))
+
+(define-public ghc-deepseq-generics
+ (package
+ (name "ghc-deepseq-generics")
+ (version "0.2.0.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "deepseq-generics/deepseq-generics-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "17bwghc15mc9pchfd1w46jh2p3wzc86aj6a537wqwxn08rayzcxh"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "1pnidf8w8x0w5fsqgv8hhrw07slmhxwy5x4fikgk0bd6k76aqicb")))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://github.com/hvr/deepseq-generics")
+ (synopsis "Generic RNF implementation")
+ (description
+ "This package provides a @code{GHC.Generics}-based
+@code{Control.DeepSeq.Generics.genericRnf} function which can be used for
+providing an @code{rnf} implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-descriptive
+ (package
+ (name "ghc-descriptive")
+ (version "0.9.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/descriptive/descriptive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0y5693zm2kvqjilybbmrcv1g6n6x2p6zjgi0k0axjw1sdhh1g237"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page
+ "https://github.com/chrisdone/descriptive")
+ (synopsis
+ "Self-describing consumers/parsers: forms, cmd-line args, JSON, etc.")
+ (description
+ "This package provides datatypes and functions for creating consumers
+and parsers with useful semantics.")
+ (license license:bsd-3)))
+
+(define-public ghc-diff
+ (package
+ (name "ghc-diff")
+ (version "0.3.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "Diff/Diff-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0bqcdvhxx8dmqc3793m6axg813wv9ldz2j37f1wygbbrbbndmdvp"))))
+ (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://hub.darcs.net/sterlingclover/Diff")
+ (synopsis "O(ND) diff algorithm in Haskell")
+ (description
+ "This package provides an implementation of the standard diff algorithm,
+and utilities for pretty printing.")
+ (license license:bsd-3)))
+
+(define-public ghc-disk-free-space
+ (package
+ (name "ghc-disk-free-space")
+ (version "0.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "disk-free-space/disk-free-space-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "07rqj8k1vh3cykq9yidpjxhgh1f7vgmjs6y1nv5kq2217ff4yypi"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/redneb/disk-free-space")
+ (synopsis "Retrieve information about disk space usage")
+ (description "A cross-platform library for retrieving information about
+disk space usage.")
+ (license license:bsd-3)))
+
+(define-public ghc-distributive
+ (package
+ (name "ghc-distributive")
+ (version "0.5.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/distributive/distributive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0y566r97sfyvhsmd4yxiz4ns2mqgwf5bdbp56wgxl6wlkidq0wwi"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("6" "06bd38rf31yrvvy989r44pm0id3dsxwcp6nxg7wk6ccj3n2b8rzk")))
+ (inputs
+ `(("ghc-tagged" ,ghc-tagged)
+ ("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-generic-deriving" ,ghc-generic-deriving)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/ekmett/distributive/")
+ (synopsis "Distributive functors for Haskell")
+ (description "This package provides distributive functors for Haskell.
+Dual to @code{Traversable}.")
+ (license license:bsd-3)))
+
+(define-public ghc-dlist
+ (package
+ (name "ghc-dlist")
+ (version "0.8.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/dlist/dlist-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0yirrh0s6acjy9hhvf5fqg2d6q5y6gm9xs04v6w1imndh1xqdwdc"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/spl/dlist")
+ (synopsis "Difference lists")
+ (description
+ "Difference lists are a list-like type supporting O(1) append. This is
+particularly useful for efficient logging and pretty printing (e.g. with the
+Writer monad), where list append quickly becomes too expensive.")
+ (license license:bsd-3)))
+
+(define-public ghc-doctemplates
+ (package
+ (name "ghc-doctemplates")
+ (version "0.2.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "doctemplates/doctemplates-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1gyckfg3kgvzhxw14i7iwrw0crygvsp86sy53bbr1yn7bxbgn33b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-scientific" ,ghc-scientific)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/jgm/doctemplates#readme")
+ (synopsis "Pandoc-style document templates")
+ (description
+ "This package provides a simple text templating system used by pandoc.")
+ (license license:bsd-3)))
+
+(define-public ghc-doctest
+ (package
+ (name "ghc-doctest")
+ (version "0.16.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/doctest/doctest-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0hkccch65s3kp0b36h7bqhilnpi4bx8kngncm7ma9vbd3dwacjdv"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: missing test framework
+ (inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-paths" ,ghc-paths)
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-code-page" ,ghc-code-page)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-stringbuilder" ,ghc-stringbuilder)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-setenv" ,ghc-setenv)))
+ (home-page
+ "https://github.com/sol/doctest#readme")
+ (synopsis "Test interactive Haskell examples")
+ (description "The doctest program checks examples in source code comments.
+It is modeled after doctest for Python, see
+@uref{https://docs.python.org/library/doctest.html, the Doctest website}.")
+ (license license:expat)))
+
+(define-public ghc-double-conversion
+ (package
+ (name "ghc-double-conversion")
+ (version "2.0.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "double-conversion/double-conversion-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/bos/double-conversion")
+ (synopsis "Fast conversion between double precision floating point and text")
+ (description
+ "This package provides a library that performs fast, accurate conversion
+between double precision floating point and text.")
+ (license license:bsd-3)))
+
+(define-public ghc-easy-file
+ (package
+ (name "ghc-easy-file")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/easy-file/easy-file-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0zmlcz723051qpn8l8vi51c5rx1blwrw4094jcshkmj8p9r2xxaj"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/kazu-yamamoto/easy-file")
+ (synopsis "File handling library for Haskell")
+ (description "This library provides file handling utilities for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-easyplot
+ (package
+ (name "ghc-easyplot")
+ (version "1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/easyplot/easyplot-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "18kndgvdj2apjpfga6fp7m16y1gx8zrwp3c5vfj03sx4v6jvciqk"))))
+ (build-system haskell-build-system)
+ (propagated-inputs `(("gnuplot" ,gnuplot)))
+ (arguments
+ `(#:phases (modify-phases %standard-phases
+ (add-after 'unpack 'fix-setup-suffix
+ (lambda _ (rename-file "Setup.lhs" "Setup.hs") #t)))))
+ (home-page "https://hub.darcs.net/scravy/easyplot")
+ (synopsis "Haskell plotting library based on gnuplot")
+ (description "This package provides a plotting library for
+Haskell, using gnuplot for rendering.")
+ (license license:expat)))
+
+(define-public ghc-echo
+ (package
+ (name "ghc-echo")
+ (version "0.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/echo/echo-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1vw5ykpwhr39wc0hhcgq3r8dh59zq6ib4zxbz1qd2wl21wqhfkvh"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l")))
+ (home-page "https://github.com/RyanGlScott/echo")
+ (synopsis "Echo terminal input portably")
+ (description "The @code{base} library exposes the @code{hGetEcho} and
+@code{hSetEcho} functions for querying and setting echo status, but
+unfortunately, neither function works with MinTTY consoles on Windows.
+This library provides an alternative interface which works with both
+MinTTY and other consoles.")
+ (license license:bsd-3)))
+
+(define-public ghc-edisonapi
+ (package
+ (name "ghc-edisonapi")
+ (version "1.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/EdisonAPI"
+ "/EdisonAPI-" version ".tar.gz"))
+ (sha256
+ (base32 "0vmmlsj8ggbpwx6fkf5fvb6jp0zpx6iba6b28m80lllr2p8bi8wm"))))
+ (build-system haskell-build-system)
+ (home-page "http://rwd.rdockins.name/edison/home/")
+ (synopsis "Library of efficient, purely-functional data structures (API)")
+ (description
+ "Edison is a library of purely functional data structures written by
+Chris Okasaki. It is named after Thomas Alva Edison and for the mnemonic
+value EDiSon (Efficient Data Structures). Edison provides several families of
+abstractions, each with multiple implementations. The main abstractions
+provided by Edison are: Sequences such as stacks, queues, and dequeues;
+Collections such as sets, bags and heaps; and Associative Collections such as
+finite maps and priority queues where the priority and element are distinct.")
+ (license license:expat)))
+
+(define-public ghc-edisoncore
+ (package
+ (name "ghc-edisoncore")
+ (version "1.3.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/EdisonCore"
+ "/EdisonCore-" version ".tar.gz"))
+ (sha256
+ (base32 "0fgj5iwiv3v2gdgx7kjcr15dcs4x1kvmjspp3p99wyhh0x6h3ikk"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-edisonapi" ,ghc-edisonapi)))
+ (home-page "http://rwd.rdockins.name/edison/home/")
+ (synopsis "Library of efficient, purely-functional data structures")
+ (description
+ "This package provides the core Edison data structure implementations,
+including multiple sequence, set, bag, and finite map concrete implementations
+with various performance characteristics.")
+ (license license:expat)))
+
+(define-public ghc-edit-distance
+ (package
+ (name "ghc-edit-distance")
+ (version "0.2.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/edit-distance"
+ "/edit-distance-" version ".tar.gz"))
+ (sha256
+ (base32 "0jkca97zyv23yyilp3jydcrzxqhyk27swhzh82llvban5zp8b21y"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "edit-distance.cabal"
+ (("QuickCheck >= 2\\.4 && <2\\.9")
+ "QuickCheck >= 2.4 && < 2.12")))))))
+ (inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/phadej/edit-distance")
+ (synopsis "Levenshtein and restricted Damerau-Levenshtein edit distances")
+ (description
+ "This package provides optimized functions to determine the edit
+distances for fuzzy matching, including Levenshtein and restricted
+Damerau-Levenshtein algorithms.")
+ (license license:bsd-3)))
+
+(define-public ghc-either
+ (package
+ (name "ghc-either")
+ (version "5.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "either-" version "/"
+ "either-" version ".tar.gz"))
+ (sha256
+ (base32
+ "064hjfld7dkzs78sy30k5qkiva3hx24rax6dvzz5ygr2c0zypdkc"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-free" ,ghc-free)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-manodrandom" ,ghc-monadrandom)
+ ("ghc-mmorph" ,ghc-mmorph)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-transformers-base" ,ghc-transformers-base)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/ekmett/either")
+ (synopsis "Provides an either monad transformer for Haskell")
+ (description "This Haskell package provides an either monad transformer.")
+ (license license:bsd-3)))
+
+(define-public ghc-email-validate
+ (package
+ (name "ghc-email-validate")
+ (version "2.3.2.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "email-validate/email-validate-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0chgylvc8xmhp933rdbmpg5sv4y7yg2h6kbf0ip1dzmbd5p55pa5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-doctest" ,ghc-doctest)))
+ (home-page
+ "https://github.com/Porges/email-validate-hs")
+ (synopsis "Email address validator for Haskell")
+ (description
+ "This Haskell package provides a validator that can validate an email
+address string against RFC 5322.")
+ (license license:bsd-3)))
+
+(define-public ghc-enclosed-exceptions
+ (package
+ (name "ghc-enclosed-exceptions")
+ (version "1.0.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "enclosed-exceptions/enclosed-exceptions-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1fghjj7nkiddrf03ks8brjpr5x25yi9fs7xg6adbi4mc2gqr6vdg"))))
+ (build-system haskell-build-system)
+ ;; FIXME: one of the tests blocks forever:
+ ;; "thread blocked indefinitely in an MVar operation"
+ (arguments '(#:tests? #f))
+ (inputs
+ `(("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-async" ,ghc-async)
+ ("ghc-transformers-base" ,ghc-transformers-base)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/jcristovao/enclosed-exceptions")
+ (synopsis "Catch all exceptions from within an enclosed computation")
+ (description
+ "This library implements a technique to catch all exceptions raised
+within an enclosed computation, while remaining responsive to (external)
+asynchronous exceptions.")
+ (license license:expat)))
+
+(define-public ghc-equivalence
+ (package
+ (name "ghc-equivalence")
+ (version "0.3.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/equivalence"
+ "/equivalence-" version ".tar.gz"))
+ (sha256
+ (base32 "0a85bdyyvjqs5z4kfhhf758210k9gi9dv42ik66a3jl0z7aix8kx"))))
+ (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)))
+ (home-page "https://github.com/pa-ba/equivalence")
+ (synopsis "Maintaining an equivalence relation implemented as union-find")
+ (description
+ "This is an implementation of Tarjan's Union-Find algorithm (Robert E.@:
+Tarjan. \"Efficiency of a Good But Not Linear Set Union Algorithm\",JACM
+22(2), 1975) in order to maintain an equivalence relation. This
+implementation is a port of the @code{union-find} package using the @code{ST}
+monad transformer (instead of the IO monad).")
+ (license license:bsd-3)))
+
+(define-public ghc-erf
+ (package
+ (name "ghc-erf")
+ (version "2.0.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "erf-" version "/"
+ "erf-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/erf")
+ (synopsis "The error function, erf, and related functions for Haskell")
+ (description "This Haskell library provides a type class for the
+error function, erf, and related functions. Instances for Float and
+Double.")
+ (license license:bsd-3)))
+
+(define-public ghc-errorcall-eq-instance
+ (package
+ (name "ghc-errorcall-eq-instance")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "errorcall-eq-instance/errorcall-eq-instance-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0hqw82m8bbrxy5vgdwb83bhzdx070ibqrm9rshyja7cb808ahijm"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "http://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}.
+This package provides an orphan instance.")
+ (license license:expat)))
+
+(define-public ghc-errors
+ (package
+ (name "ghc-errors")
+ (version "2.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "errors-" version "/"
+ "errors-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0x8znwn31qcx6kqx99wp7bc86kckfb39ncz3zxvj1s07kxlfawk7"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unexceptionalio" ,ghc-unexceptionalio)
+ ("ghc-safe" ,ghc-safe)))
+ (home-page "https://github.com/gabriel439/haskell-errors-library")
+ (synopsis "Error handling library for Haskell")
+ (description "This library encourages an error-handling style that
+directly uses the type system, rather than out-of-band exceptions.")
+ (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
+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))))
+
+(define-public ghc-exactprint
+ (package
+ (name "ghc-exactprint")
+ (version "0.5.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "ghc-exactprint/ghc-exactprint-" version ".tar.gz"))
+ (sha256
+ (base32
+ "141k6qiys0m0r4br7ikp4i546vs3xcil9cwglzcdfcbnb5nj1z87"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-paths" ,ghc-paths)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-free" ,ghc-free)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-diff" ,ghc-diff)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-filemanip" ,ghc-filemanip)))
+ (home-page
+ "http://hackage.haskell.org/package/ghc-exactprint")
+ (synopsis "ExactPrint for GHC")
+ (description
+ "Using the API Annotations available from GHC 7.10.2, this library
+provides a means to round-trip any code that can be compiled by GHC, currently
+excluding @file{.lhs} files.")
+ (license license:bsd-3)))
+
+(define-public ghc-exceptions
+ (package
+ (name "ghc-exceptions")
+ (version "0.10.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/exceptions/exceptions-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ms9zansv0pwzwdjncvx4kf18lnkjy2p61hvjhvxmjx5bqp93p8y"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (inputs
+ `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/ekmett/exceptions/")
+ (synopsis "Extensible optionally-pure exceptions")
+ (description "This library provides extensible optionally-pure exceptions
+for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-executable-path
+ (package
+ (name "ghc-executable-path")
+ (version "0.0.3.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "executable-path/executable-path-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0vxwmnsvx13cawcyhbyljkds0l1vr996ijldycx7nj0asjv45iww"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/executable-path")
+ (synopsis "Find out the full path of the executable")
+ (description
+ "The documentation of @code{System.Environment.getProgName} says that
+\"However, this is hard-to-impossible to implement on some non-Unix OSes, so
+instead, for maximum portability, we just return the leafname of the program
+as invoked.\" This library tries to provide the missing path.")
+ (license license:public-domain)))
+
+(define-public ghc-extensible-exceptions
+ (package
+ (name "ghc-extensible-exceptions")
+ (version "0.1.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "extensible-exceptions/extensible-exceptions-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/extensible-exceptions")
+ (synopsis "Extensible exceptions for Haskell")
+ (description
+ "This package provides extensible exceptions for both new and old
+versions of GHC (i.e., < 6.10).")
+ (license license:bsd-3)))
+
+(define-public ghc-extra
+ (package
+ (name "ghc-extra")
+ (version "1.6.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/extra/extra-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0xxcpb00pgwi9cmy6a7ghh6rblxry42p8pz5ssfgj20fs1xwzj1b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-clock" ,ghc-clock)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/ndmitchell/extra")
+ (synopsis "Extra Haskell functions")
+ (description "This library provides extra functions for the standard
+Haskell libraries. Most functions are simple additions, filling out missing
+functionality. A few functions are available in later versions of GHC, but
+this package makes them available back to GHC 7.2.")
+ (license license:bsd-3)))
+
+(define-public ghc-fail
+ (package
+ (name "ghc-fail")
+ (version "4.9.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/fail/fail-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "18nlj6xvnggy61gwbyrpmvbdkq928wv0wx2zcsljb52kbhddnp3d"))))
+ (build-system haskell-build-system)
+ (arguments `(#:haddock? #f)) ; Package contains no documentation.
+ (home-page "https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail")
+ (synopsis "Forward-compatible MonadFail class")
+ (description
+ "This package contains the @code{Control.Monad.Fail} module providing the
+@uref{https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail, MonadFail}
+class that became available in
+@uref{https://hackage.haskell.org/package/base-4.9.0.0, base-4.9.0.0} for
+older @code{base} package versions. This package turns into an empty package
+when used with GHC versions which already provide the
+@code{Control.Monad.Fail} module.")
+ (license license:bsd-3)))
+
+(define-public ghc-fast-logger
+ (package
+ (name "ghc-fast-logger")
+ (version "2.4.11")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/fast-logger/fast-logger-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ad2vq4nifdxshqk9yrmghqizhkgybfz134kpr6padglb2mxxrdv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-auto-update" ,ghc-auto-update)
+ ("ghc-easy-file" ,ghc-easy-file)
+ ("ghc-unix-time" ,ghc-unix-time)))
+ (native-inputs
+ `(("hspec-discover" ,hspec-discover)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://hackage.haskell.org/package/fast-logger")
+ (synopsis "Fast logging system")
+ (description "This library provides a fast logging system for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-feed
+ (package
+ (name "ghc-feed")
+ (version "1.0.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "feed/feed-" version ".tar.gz"))
+ (sha256
+ (base32
+ "05rgg7x1984mgfhkmz792xj8lhwjgznixhygzr8blf517lns2nck"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("4" "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d")))
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-old-time" ,ghc-old-time)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-xml-conduit" ,ghc-xml-conduit)
+ ("ghc-xml-types" ,ghc-xml-types)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://github.com/bergmark/feed")
+ (synopsis "Haskell package for handling various syndication formats")
+ (description "This Haskell package includes tools for generating and
+consuming feeds in both RSS (Really Simple Syndication) and Atom format.")
+ (license license:bsd-3)))
+
+(define-public ghc-fgl
+ (package
+ (name "ghc-fgl")
+ (version "5.6.0.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/fgl/fgl-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1i6cp4b3w7sjk7y1dq3fh6bci2sm5h3lnbbaw9ln19nwncg2wwll"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "fgl.cabal"
+ (("QuickCheck >= 2\\.8 && < 2\\.10")
+ "QuickCheck >= 2.8 && < 2.12")
+ (("hspec >= 2\\.1 && < 2\\.5")
+ "hspec >= 2.1 && < 2.6")))))))
+ (inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell")
+ (synopsis
+ "Martin Erwig's Functional Graph Library")
+ (description "The functional graph library, FGL, is a collection of type
+and function definitions to address graph problems. The basis of the library
+is an inductive definition of graphs in the style of algebraic data types that
+encourages inductive, recursive definitions of graph algorithms.")
+ (license license:bsd-3)))
+
+(define-public ghc-fgl-arbitrary
+ (package
+ (name "ghc-fgl-arbitrary")
+ (version "0.2.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/fgl-arbitrary/fgl-arbitrary-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0ln1szgfy8fa78l3issq4fx3aqnnd54w3cb4wssrfi48vd5rkfjm"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "fgl-arbitrary.cabal"
+ (("QuickCheck >= 2\\.3 && < 2\\.10")
+ "QuickCheck >= 2.3 && < 2.12")
+ (("hspec >= 2\\.1 && < 2\\.5")
+ "hspec >= 2.1 && < 2.6")))))))
+ (inputs
+ `(("ghc-fgl" ,ghc-fgl)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://hackage.haskell.org/package/fgl-arbitrary")
+ (synopsis "QuickCheck support for fgl")
+ (description
+ "Provides Arbitrary instances for fgl graphs to avoid adding a
+QuickCheck dependency for fgl whilst still making the instances
+available to others. Also available are non-fgl-specific functions
+for generating graph-like data structures.")
+ (license license:bsd-3)))
+
+(define-public ghc-file-embed
+ (package
+ (name "ghc-file-embed")
+ (version "0.0.10.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/file-embed/"
+ "file-embed-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0lj164cnzqyd487mli91nnr7137a4h4qsasfwsnsh77sx12fpk9k"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/snoyberg/file-embed")
+ (synopsis "Use Template Haskell to embed file contents directly")
+ (description
+ "This package allows you to use Template Haskell to read a file or all
+the files in a directory, and turn them into @code{(path, bytestring)} pairs
+embedded in your Haskell code.")
+ (license license:bsd-3)))
+
+(define-public ghc-filemanip
+ (package
+ (name "ghc-filemanip")
+ (version "0.3.6.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "filemanip/filemanip-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-unix-compat" ,ghc-unix-compat)))
+ (home-page "https://github.com/bos/filemanip")
+ (synopsis "File and directory manipulation for Haskell")
+ (description
+ "This package provides a Haskell library for working with files and
+directories. It includes code for pattern matching, finding files, modifying
+file contents, and more.")
+ (license license:bsd-3)))
+
+(define-public ghc-findbin
+ (package
+ (name "ghc-findbin")
+ (version "0.0.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/FindBin/FindBin-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/audreyt/findbin")
+ (synopsis "Get the absolute path of the running program")
+ (description
+ "This module locates the full directory of the running program, to allow
+the use of paths relative to it. FindBin supports invocation of Haskell
+programs via \"ghci\", via \"runhaskell/runghc\", as well as compiled as
+an executable.")
+ (license license:bsd-3)))
+
+(define-public ghc-fingertree
+ (package
+ (name "ghc-fingertree")
+ (version "0.1.4.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/fingertree/fingertree-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "192fyzv0pn1437wdpqg1l80rswkk4rw3w61r4bq7dhv354bdqy4p"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://hackage.haskell.org/package/fingertree")
+ (synopsis "Generic finger-tree structure")
+ (description "This library provides finger trees, a general sequence
+representation with arbitrary annotations, for use as a base for
+implementations of various collection types. It includes examples, as
+described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
+simple general-purpose data structure\".")
+ (license license:bsd-3)))
+
+(define-public ghc-fixed
+ (package
+ (name "ghc-fixed")
+ (version "0.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/fixed/fixed-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1qhmwx8iqshns0crmr9d2f8hm65jxbcp3dvv0c39v34ra7if3a94"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/ekmett/fixed")
+ (synopsis "Signed 15.16 precision fixed point arithmetic")
+ (description
+ "This package provides functions for signed 15.16 precision fixed point
+arithmetic.")
+ (license license:bsd-3)))
+
+(define-public ghc-foldl
+ (package
+ (name "ghc-foldl")
+ (version "1.4.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "foldl-" version "/"
+ "foldl-" version ".tar.gz"))
+ (sha256
+ (base32
+ "13n0ca3hw5jzqf6rxsdbhbwkn61a9zlm13f0f205s60j3sc72jzk"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-vector-builder" ,ghc-vector-builder)))
+ (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library")
+ (synopsis "Composable, streaming, and efficient left folds for Haskell")
+ (description "This Haskell library provides strict left folds that stream
+in constant memory, and you can combine folds using @code{Applicative} style
+to derive new folds. Derived folds still traverse the container just once
+and are often as efficient as hand-written folds.")
+ (license license:bsd-3)))
+
+(define-public ghc-foundation
+ (package
+ (name "ghc-foundation")
+ (version "0.0.21")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "foundation/foundation-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1q43y8wfj0wf9gdq2kzphwjwq6m5pvryy1lqgk954aq5z3ks1lsf"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-basement" ,ghc-basement)))
+ (home-page "https://github.com/haskell-foundation/foundation")
+ (synopsis "Alternative prelude with batteries and no dependencies")
+ (description
+ "This package provides a custom prelude with no dependencies apart from
+the base package.
+
+Foundation has the following goals:
+
+@enumerate
+@item provide a base like sets of modules that provide a consistent set of
+ features and bugfixes across multiple versions of GHC (unlike base).
+@item provide a better and more efficient prelude than base's prelude.
+@item be self-sufficient: no external dependencies apart from base;
+@item provide better data-types: packed unicode string by default, arrays;
+@item Numerical classes that better represent mathematical things (no more
+ all-in-one @code{Num});
+@item I/O system with less lazy IO.
+@end enumerate\n")
+ (license license:bsd-3)))
+
+(define-public ghc-free
+ (package
+ (name "ghc-free")
+ (version "5.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/free/free-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "15m3n9vhz7z3kzv1w3wlfa3x8jp4cbrkwmrcjr7jlx39iqffn1gg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-prelude-extras" ,ghc-prelude-extras)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/ekmett/free/")
+ (synopsis "Unrestricted monads for Haskell")
+ (description "This library provides free monads, which are useful for many
+tree-like structures and domain specific languages. If @code{f} is a
+@code{Functor} then the free @code{Monad} on @code{f} is the type of trees
+whose nodes are labeled with the constructors of @code{f}. The word \"free\"
+is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
+f} makes no constraining assumptions beyond those given by @code{f} and the
+definition of @code{Monad}.")
+ (license license:bsd-3)))
+
+(define-public ghc-fsnotify
+ (package
+ (name "ghc-fsnotify")
+ (version "0.3.0.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/fsnotify/"
+ "fsnotify-" version ".tar.gz"))
+ (sha256
+ (base32
+ "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-hinotify" ,ghc-hinotify)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-random" ,ghc-random)
+ ("ghc-shelly" ,ghc-shelly)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/haskell-fswatch/hfsnotify")
+ (synopsis "Cross platform library for file change notification.")
+ (description "Cross platform library for file creation, modification, and
+deletion notification. This library builds upon existing libraries for platform
+specific Windows, Mac, and Linux file system event notification.")
+ (license license:bsd-3)))
+
+(define-public ghc-generic-deriving
+ (package
+ (name "ghc-generic-deriving")
+ (version "1.12.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/generic-deriving/generic-deriving-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1i7d6cpj9yhaqb79zays3nqchhaacacjz9bkc0zlwj73y5gvi22n"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-th-abstraction" ,ghc-th-abstraction)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/generic-deriving")
+ (synopsis "Generalise the deriving mechanism to arbitrary classes")
+ (description "This package provides functionality for generalising the
+deriving mechanism in Haskell to arbitrary classes.")
+ (license license:bsd-3)))
+
+(define-public ghc-generics-sop
+ (package
+ (name "ghc-generics-sop")
+ (version "0.3.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "generics-sop-" version "/"
+ "generics-sop-" version ".tar.gz"))
+ (sha256
+ (base32
+ "168v62i845jh9jbfaz3ldz8svz4wmzq9mf2vhb7pxlnbkk8fqq1h"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/well-typed/generics-sop")
+ (synopsis "Generic Programming using True Sums of Products for Haskell")
+ (description "This Haskell package supports the definition of generic
+functions. Datatypes are viewed in a uniform, structured way: the choice
+between constructors is represented using an n-ary sum, and the arguments of
+each constructor are represented using an n-ary product.")
+ (license license:bsd-3)))
+
+(define-public ghc-geniplate-mirror
+ (package
+ (name "ghc-geniplate-mirror")
+ (version "0.7.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package"
+ "/geniplate-mirror"
+ "/geniplate-mirror-" version ".tar.gz"))
+ (sha256
+ (base32 "1y0m0bw5zpm1y1y6d9qmxj3swl8j8hlw1shxbr5awycf6k884ssb"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/danr/geniplate")
+ (synopsis "Use Template Haskell to generate Uniplate-like functions")
+ (description
+ "Use Template Haskell to generate Uniplate-like functions. This is a
+maintained mirror of the @uref{https://hackage.haskell.org/package/geniplate,
+geniplate} package, written by Lennart Augustsson.")
+ (license license:bsd-3)))
+
+(define-public ghc-genvalidity
+ (package
+ (name "ghc-genvalidity")
+ (version "0.5.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/genvalidity/genvalidity-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "17ykq38j9a2lzir6dqz5jgy6ndaafrpkhqhcg96c5ppg7wcxaaj0"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-validity" ,ghc-validity)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-hspec-core" ,ghc-hspec-core)))
+ (home-page
+ "https://github.com/NorfairKing/validity")
+ (synopsis
+ "Testing utilities for the @code{validity} library")
+ (description
+ "This package provides testing utilities that are useful in conjunction
+with the @code{Validity} typeclass.")
+ (license license:expat)))
+
+(define-public ghc-genvalidity-property
+ (package
+ (name "ghc-genvalidity-property")
+ (version "0.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "genvalidity-property/genvalidity-property-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0cjw5i2pydidda9bnp6x37ylhxdk9g874x5sadr6sscg5kq85a1b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-genvalidity" ,ghc-genvalidity)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-validity" ,ghc-validity)))
+ (native-inputs `(("ghc-doctest" ,ghc-doctest)))
+ (home-page
+ "https://github.com/NorfairKing/validity")
+ (synopsis
+ "Standard properties for functions on @code{Validity} types")
+ (description
+ "This package supplements the @code{Validity} typeclass with standard
+properties for functions operating on them.")
+ (license license:expat)))
+
+(define-public ghc-gitrev
+ (package
+ (name "ghc-gitrev")
+ (version "1.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/gitrev/gitrev-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "0cl3lfm6k1h8fxp2vxa6ihfp4v8igkz9h35iwyq2frzm4kdn96d8"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-base-compat" ,ghc-base-compat)))
+ (home-page "https://github.com/acfoltzer/gitrev")
+ (synopsis "Compile git revision info into Haskell projects")
+ (description
+ "This package provides some handy Template Haskell splices for including
+the current git hash and branch in the code of your project. This is useful
+for including in panic messages, @command{--version} output, or diagnostic
+info for more informative bug reports.")
+ (license license:bsd-3)))
+
+(define-public ghc-glob
+ (package
+ (name "ghc-glob")
+ (version "0.9.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "Glob-" version "/"
+ "Glob-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1rbwcq9w9951qsnp13vqcm9r01yax2yh1wk8s4zxa3ckk9717iwg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-dlist" ,ghc-dlist)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "http://iki.fi/matti.niemenmaa/glob/")
+ (synopsis "Haskell library matching glob patterns against file paths")
+ (description "This package provides a Haskell library for @dfn{globbing}:
+matching patterns against file paths.")
+ (license license:bsd-3)))
+
+(define-public ghc-gluraw
+ (package
+ (name "ghc-gluraw")
+ (version "2.0.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/GLURaw/GLURaw-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-openglraw" ,ghc-openglraw)))
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Raw Haskell bindings GLU")
+ (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
+utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
+basis for a nicer interface.")
+ (license license:bsd-3)))
+
+(define-public ghc-glut
+ (package
+ (name "ghc-glut")
+ (version "2.7.0.14")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/GLUT/GLUT-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "01i162fly4q1751fp60lgkzlb8kr0qqbvmxj74zc6skb19qggy2w"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-statevar" ,ghc-statevar)
+ ("ghc-opengl" ,ghc-opengl)
+ ("ghc-openglraw" ,ghc-openglraw)
+ ("freeglut" ,freeglut)))
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
+ (description "This library provides Haskell bindings for the OpenGL
+Utility Toolkit, a window system-independent toolkit for writing OpenGL
+programs.")
+ (license license:bsd-3)))
+
+(define-public ghc-gnuplot
+ (package
+ (name "ghc-gnuplot")
+ (version "0.5.5.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/gnuplot/gnuplot-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1mlppnc13ygjzmf6ldydys4wvy35yb3xjwwfgf9rbi7nfcqjr6mn"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-utility-ht" ,ghc-utility-ht)
+ ("ghc-data-accessor-transformers" ,ghc-data-accessor-transformers)
+ ("ghc-data-accessor" ,ghc-data-accessor)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("gnuplot" ,gnuplot)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'fix-path-to-gnuplot
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((gnuplot (assoc-ref inputs "gnuplot")))
+ (substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
+ (("(gnuplotName = ).*$" all cmd)
+ (string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
+ (home-page "https://www.haskell.org/haskellwiki/Gnuplot")
+ (synopsis "2D and 3D plots using gnuplot")
+ (description "This package provides a Haskell module for creating 2D and
+3D plots using gnuplot.")
+ (license license:bsd-3)))
+
+(define-public ghc-graphviz
+ (package
+ (name "ghc-graphviz")
+ (version "2999.20.0.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "graphviz/graphviz-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0kj7ap0gnliviq2p8lscw1m06capnsa90vpvcys24nqy5nw2wrp7"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-dlist" ,ghc-dlist)
+ ("ghc-fgl" ,ghc-fgl)
+ ("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
+ ("ghc-polyparse" ,ghc-polyparse)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("graphviz" ,graphviz)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/graphviz")
+ (synopsis "Bindings to Graphviz for graph visualisation")
+ (description
+ "This library provides bindings for the Dot language used by
+the @uref{https://graphviz.org/, Graphviz} suite of programs for
+visualising graphs, as well as functions to call those programs.
+Main features of the graphviz library include:
+
+@enumerate
+@item Almost complete coverage of all Graphviz attributes and syntax
+@item Support for specifying clusters
+@item The ability to use a custom node type
+@item Functions for running a Graphviz layout tool with all specified output types
+@item Generate and parse Dot code with two options: strict and liberal
+@item Functions to convert FGL graphs and other graph-like data structures
+@item Round-trip support for passing an FGL graph through Graphviz to augment node
+and edge labels with positional information, etc.
+@end enumerate\n")
+ (license license:bsd-3)))
+
+(define-public ghc-gtk2hs-buildtools
+ (package
+ (name "ghc-gtk2hs-buildtools")
+ (version "0.13.4.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "gtk2hs-buildtools/gtk2hs-buildtools-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0yg6xmylgpylmnh5g33qwwn5x9bqckdvvv4czqzd9vrr12lnnghg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-hashtables" ,ghc-hashtables)))
+ (native-inputs
+ `(("ghc-alex" ,ghc-alex)
+ ("ghc-happy" ,ghc-happy)))
+ (home-page "http://projects.haskell.org/gtk2hs/")
+ (synopsis "Tools to build the Gtk2Hs suite of user interface libraries")
+ (description
+ "This package provides a set of helper programs necessary to build the
+Gtk2Hs suite of libraries. These tools include a modified c2hs binding tool
+that is used to generate FFI declarations, a tool to build a type hierarchy
+that mirrors the C type hierarchy of GObjects found in glib, and a generator
+for signal declarations that are used to call back from C to Haskell. These
+tools are not needed to actually run Gtk2Hs programs.")
+ (license license:gpl2)))
+
+(define-public ghc-hackage-security
+ (package
+ (name "ghc-hackage-security")
+ (version "0.5.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hackage-security/hackage-security-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f)) ; Tests fail because of framework updates.
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256)
+ ("ghc-ed25519" ,ghc-ed25519)
+ ("ghc-network" ,ghc-network)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-tar" ,ghc-tar)
+ ("ghc-zlib" ,ghc-zlib)))
+ (native-inputs
+ `(("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tar" ,ghc-tar)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-zlib" ,ghc-zlib)))
+ (home-page "https://github.com/haskell/hackage-security")
+ (synopsis "Hackage security library")
+ (description "This Hackage security library provides both server and
+client utilities for securing @uref{http://hackage.haskell.org/, the
+Hackage package server}. It is based on
+@uref{http://theupdateframework.com/, The Update Framework}, a set of
+recommendations developed by security researchers at various universities
+in the US as well as developers on the @uref{https://www.torproject.org/,
+Tor project}.")
+ (license license:bsd-3)))
+
+(define-public ghc-haddock
+ (package
+ (name "ghc-haddock")
+ (version "2.19.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haddock/haddock-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7"))))
+ (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
+ (lambda _
+ (use-modules (ice-9 rdelim))
+ (with-atomic-file-replacement "haddock.cabal"
+ (lambda (in out)
+ (let loop ((line (read-line in 'concat)) (deleting? #f))
+ (cond
+ ((eof-object? line) #t)
+ ((string-every char-set:whitespace line)
+ (unless deleting? (display line out))
+ (loop (read-line in 'concat) #f))
+ ((member line '("test-suite html-test\n"
+ "test-suite hypsrc-test\n"
+ "test-suite latex-test\n"
+ "test-suite hoogle-test\n"))
+ (loop (read-line in 'concat) #t))
+ (else
+ (unless deleting? (display line out))
+ (loop (read-line in 'concat) deleting?)))))))))))
+ (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://www.haskell.org/haddock/")
+ (synopsis
+ "Documentation-generation tool for Haskell libraries")
+ (description
+ "Haddock is a documentation-generation tool for Haskell libraries.")
+ (license license:bsd-3)))
+
+(define-public ghc-haddock-api
+ (package
+ (name "ghc-haddock-api")
+ (version "2.19.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haddock-api/haddock-api-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "haddock-api.cabal"
+ (("Cabal \\^>= 2\\.0\\.0")
+ "Cabal ^>= 2.2.0")
+ (("hspec \\^>= 2\\.4\\.4")
+ "hspec >= 2.4.4 && < 2.6")))))))
+ (inputs
+ `(("ghc-paths" ,ghc-paths)
+ ("ghc-haddock-library" ,ghc-haddock-library)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://www.haskell.org/haddock/")
+ (synopsis "API for documentation-generation tool Haddock")
+ (description "This package provides an API to Haddock, the
+documentation-generation tool for Haskell libraries.")
+ (license license:bsd-3)))
+
+(define-public ghc-haddock-library
+ (package
+ (name "ghc-haddock-library")
+ (version "1.5.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haddock-library/haddock-library-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1cmbg8l5xrwpliclwy3l057raypjqy0hsg1h1743ahaj8gq10b7z"))
+ (patches (search-patches
+ "ghc-haddock-library-unbundle.patch"))
+ (modules '((guix build utils)))
+ (snippet '(begin
+ (delete-file-recursively "vendor")
+ #t))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'relax-test-suite-dependencies
+ (lambda _
+ (substitute* "haddock-library.cabal"
+ (("base-compat\\s*\\^>= 0\\.9\\.3") "base-compat")
+ (("hspec\\s*\\^>= 2\\.4\\.4") "hspec"))))
+ ;; The release tarball does not contain the "fixtures/examples"
+ ;; directory, which is required for testing. In the upstream
+ ;; repository, the directory exists and is populated. Here, we
+ ;; create an empty directory to placate the tests.
+ (add-before 'check 'add-examples-directory
+ (lambda _
+ (mkdir "fixtures/examples")
+ #t)))))
+ (native-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tree-diff" ,ghc-tree-diff)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://www.haskell.org/haddock/")
+ (synopsis "Library exposing some functionality of Haddock")
+ (description
+ "Haddock is a documentation-generation tool for Haskell libraries. These
+modules expose some functionality of it without pulling in the GHC dependency.
+Please note that the API is likely to change so specify upper bounds in your
+project if you can't release often. For interacting with Haddock itself, see
+the ‘haddock’ package.")
+ (license license:bsd-3)))
+
+(define-public ghc-half
+ (package
+ (name "ghc-half")
+ (version "0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/half/half-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "14r0nx8hm5fic9gz0ybjjw4kyc758zfgvhhwvzsshpx5caq6zch6"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/ekmett/half")
+ (synopsis "Half-precision floating-point computations")
+ (description "This library provides a half-precision floating-point
+computation library for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-happy
+ (package
+ (name "ghc-happy")
+ (version "1.19.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/happy/happy-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "138xpxdb7x62lpmgmb6b3v3vgdqqvqn4273jaap3mjmc2gla709y"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'skip-test-issue93
+ (lambda _
+ ;; Tests run out of memory on a system with 2GB of available RAM,
+ ;; in 'issue93.a.hs' and 'issue93.n.hs'.
+ (substitute* "tests/Makefile"
+ ((" issue93.y ") " "))
+ #t)))))
+ (home-page "https://hackage.haskell.org/package/happy")
+ (synopsis "Parser generator for Haskell")
+ (description "Happy is a parser generator for Haskell. Given a grammar
+specification in BNF, Happy generates Haskell code to parse the grammar.
+Happy works in a similar way to the yacc tool for C.")
+ (license license:bsd-3)))
+
+(define-public ghc-hashable
+ (package
+ (name "ghc-hashable")
+ (version "1.2.7.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hashable/hashable-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1gra8gq3kb7b2sd845h55yxlrfqx3ii004c6vjhga8v0b30fzdgc"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)))
+ (native-inputs
+ `(("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/tibbe/hashable")
+ (synopsis "Class for types that can be converted to a hash value")
+ (description
+ "This package defines a class, @code{Hashable}, for types that can be
+converted to a hash value. This class exists for the benefit of hashing-based
+data structures. The package provides instances for basic types and a way to
+combine hash values.")
+ (license license:bsd-3)))
+
+(define-public ghc-hashable-bootstrap
+ (package
+ (inherit ghc-hashable)
+ (name "ghc-hashable-bootstrap")
+ (arguments `(#:tests? #f))
+ (native-inputs '())
+ (properties '((hidden? #t)))))
+
+(define-public ghc-hashable-time
+ (package
+ (name "ghc-hashable-time")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hashable-time/hashable-time-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0k932nyd08l3xxbh2g3n76py2f4kd9yw4s5a065vjz0xp6wjnxdm"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "0rv40xkg3gj8jnqsry1gq3f5s5la6d5arg8fzkirnwdpcgha1as6")))
+ (inputs `(("ghc-hashable" ,ghc-hashable)))
+ (home-page "http://hackage.haskell.org/package/hashable-time")
+ (synopsis "Hashable instances for Data.Time")
+ (description
+ "This package provides @code{Hashable} instances for types in
+@code{Data.Time}.")
+ (license license:bsd-3)))
+
+(define-public ghc-hashtables
+ (package
+ (name "ghc-hashtables")
+ (version "1.2.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hashtables/hashtables-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1giw9caajr07slf09j7zry9b0kvm4yj9q78zy1mawzi6gk3wglcg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/gregorycollins/hashtables")
+ (synopsis "Haskell Mutable hash tables in the ST monad")
+ (description "This package provides a Haskell library including a
+couple of different implementations of mutable hash tables in the ST
+monad, as well as a typeclass abstracting their common operations, and
+a set of wrappers to use the hash tables in the IO monad.")
+ (license license:bsd-3)))
+
+(define-public ghc-haskell-lexer
+ (package
+ (name "ghc-haskell-lexer")
+ (version "1.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haskell-lexer/haskell-lexer-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/haskell-lexer")
+ (synopsis "Fully compliant Haskell 98 lexer")
+ (description
+ "This package provides a fully compliant Haskell 98 lexer.")
+ (license license:bsd-3)))
+
+(define-public ghc-haskell-src
+ (package
+ (name "ghc-haskell-src")
+ (version "1.0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haskell-src/haskell-src-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1g4dj1f0j68bhn4ixfac63wjzy6gsp6kwgxryb1k5nl3i0g99d5l"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-happy" ,ghc-happy)
+ ("ghc-syb" ,ghc-syb)))
+ (home-page
+ "https://hackage.haskell.org/package/haskell-src")
+ (synopsis
+ "Support for manipulating Haskell source code")
+ (description
+ "The @code{haskell-src} package provides support for manipulating Haskell
+source code. The package provides a lexer, parser and pretty-printer, and a
+definition of a Haskell abstract syntax tree (AST). Common uses of this
+package are to parse or generate Haskell 98 code.")
+ (license license:bsd-3)))
+
+(define-public ghc-haskell-src-exts
+ (package
+ (name "ghc-haskell-src-exts")
+ (version "1.20.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1sm3z4v1p5yffg01ldgavz71s3bvfhjfa13k428rk14bpkl8crlz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("cpphs" ,cpphs)
+ ("ghc-happy" ,ghc-happy)
+ ("ghc-pretty-show" ,ghc-pretty-show)))
+ (native-inputs
+ `(("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)))
+ (home-page "https://github.com/haskell-suite/haskell-src-exts")
+ (synopsis "Library for manipulating Haskell source")
+ (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
+extension of the standard @code{haskell-src} package, and handles most
+registered syntactic extensions to Haskell. All extensions implemented in GHC
+are supported. Apart from these standard extensions, it also handles regular
+patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
+ (license license:bsd-3)))
+
+(define-public ghc-haskell-src-exts-util
+ (package
+ (name "ghc-haskell-src-exts-util")
+ (version "0.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "haskell-src-exts-util/haskell-src-exts-util-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1803718paq89f8pdck4mb88hv2k1ah9lxzq0lgjgwi9n88ryycz8"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-data-default" ,ghc-data-default)
+ ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-uniplate" ,ghc-uniplate)))
+ (home-page "https://github.com/pepeiborra/haskell-src-exts-util")
+ (synopsis "Helper functions for working with haskell-src-exts trees")
+ (description
+ "This package provides helper functions for working with
+@code{haskell-src-exts} trees.")
+ (license license:bsd-3)))
+
+(define-public ghc-haskell-src-meta
+ (package
+ (name "ghc-haskell-src-meta")
+ (version "0.8.0.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "haskell-src-meta/haskell-src-meta-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "08jq156zv4m0fjq6712n99c1jwxnpa6kj6sq8ch0r1l0a1ay6ww4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-th-orphans" ,ghc-th-orphans)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://hackage.haskell.org/package/haskell-src-meta")
+ (synopsis "Parse source to template-haskell abstract syntax")
+ (description
+ "This package provides tools to parse Haskell sources to the
+template-haskell abstract syntax.")
+ (license license:bsd-3)))
+
+(define-public ghc-hasktags
+ (package
+ (name "ghc-hasktags")
+ (version "0.71.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hasktags/hasktags-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1s2k9qrgy1jily96img2pmn7g35mwnnfiw6si3aw32jfhg5zsh1c"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-system-filepath" ,ghc-system-filepath)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
+ (native-inputs
+ `(("ghc-json" ,ghc-json)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-microlens-platform" ,ghc-microlens-platform)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "http://github.com/MarcWeber/hasktags")
+ (synopsis "Make @code{Ctags} and @code{Etags} files for Haskell programs")
+ (description
+ "This package provides a means of generating tag files for Emacs and
+Vim.")
+ (license license:bsd-3)))
+
+(define-public ghc-hex
+ (package
+ (name "ghc-hex")
+ (version "0.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hex-" version "/"
+ "hex-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1v31xiaivrrn0q2jz8919wvkjplv1kxna5ajhsj701fqxm1i5vhj"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/hex")
+ (synopsis "Convert strings into hexadecimal and back")
+ (description "This package provides conversion functions between
+bytestrings and their hexademical representation.")
+ (license license:bsd-3)))
+
+(define-public ghc-highlighting-kate
+ (package
+ (name "ghc-highlighting-kate")
+ (version "0.6.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "highlighting-kate/highlighting-kate-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1bqv00gfmrsf0jjr4qf3lhshvfkyzmhbi3pjb6mafbnsyn2k7f6q"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-diff" ,ghc-diff)
+ ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
+ (native-inputs
+ `(("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-utf8-string" ,ghc-utf8-string)))
+ (home-page "https://github.com/jgm/highlighting-kate")
+ (synopsis "Syntax highlighting library")
+ (description
+ "Highlighting-kate is a syntax highlighting library with support for
+nearly one hundred languages. The syntax parsers are automatically generated
+from @uref{https://kate-editor.org/, Kate syntax descriptions}, so any syntax
+supported by Kate can be added. An (optional) command-line program is
+provided, along with a utility for generating new parsers from Kate XML syntax
+descriptions.")
+ (license license:gpl2+)))
+
+(define-public ghc-hindent
+ (package
+ (name "ghc-hindent")
+ (version "5.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hindent/hindent-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0wkfik7mvqskk23kyh7ybgnlh3j9j1ym7d3ncahsbli9w654b7xg"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:modules ((guix build haskell-build-system)
+ (guix build utils)
+ (guix build emacs-utils))
+ #:imported-modules (,@%haskell-build-system-modules
+ (guix build emacs-utils))
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'install 'emacs-install
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (elisp-file "elisp/hindent.el")
+ (dest (string-append out "/share/emacs/site-lisp"
+ "/guix.d/hindent-" ,version))
+ (emacs (string-append (assoc-ref inputs "emacs")
+ "/bin/emacs")))
+ (make-file-writable elisp-file)
+ (emacs-substitute-variables elisp-file
+ ("hindent-process-path"
+ (string-append out "/bin/hindent")))
+ (install-file elisp-file dest)
+ (emacs-generate-autoloads "hindent" dest)))))))
+ (inputs
+ `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+ ("ghc-monad-loops" ,ghc-monad-loops)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-yaml" ,ghc-yaml)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-path" ,ghc-path)
+ ("ghc-path-io" ,ghc-path-io)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-diff" ,ghc-diff)
+ ("emacs" ,emacs-minimal)))
+ (home-page
+ "https://github.com/commercialhaskell/hindent")
+ (synopsis "Extensible Haskell pretty printer")
+ (description
+ "This package provides automatic formatting for Haskell files. Both a
+library and an executable.")
+ (license license:bsd-3)))
+
+(define-public ghc-hinotify
+ (package
+ (name "ghc-hinotify")
+ (version "0.3.10")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hinotify/"
+ "hinotify-" version ".tar.gz"))
+ (sha256
+ (base32
+ "17ax3n68a5c2ddazp86aciliskrh6znd3bnry0wcllmb6dbpsaxg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)))
+ (home-page "https://github.com/kolmodin/hinotify.git")
+ (synopsis "Haskell binding to inotify")
+ (description "This library provides a wrapper to the Linux kernel's inotify
+feature, allowing applications to subscribe to notifications when a file is
+accessed or modified.")
+ (license license:bsd-3)))
+
+(define-public ghc-hmatrix
+ (package
+ (name "ghc-hmatrix")
+ (version "0.19.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hmatrix/hmatrix-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "10jd69nby29dggghcyjk6ykyr5wrn97nrv1dkpyrp0y5xm12xssj"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-split" ,ghc-split)
+ ("ghc-storable-complex" ,ghc-storable-complex)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-vector" ,ghc-vector)
+ ;;("openblas" ,openblas)
+ ("lapack" ,lapack)))
+ ;; Guix's OpenBLAS is built with the flag "NO_LAPACK=1" which
+ ;; disables inclusion of the LAPACK functions.
+ ;; (arguments `(#:configure-flags '("--flags=openblas")))
+ (home-page "https://github.com/albertoruiz/hmatrix")
+ (synopsis "Haskell numeric linear algebra library")
+ (description "The HMatrix package provices a Haskell library for
+dealing with linear systems, matrix decompositions, and other
+numerical computations based on BLAS and LAPACK.")
+ (license license:bsd-3)))
+
+(define-public ghc-hmatrix-gsl
+ (package
+ (name "ghc-hmatrix-gsl")
+ (version "0.19.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "0v6dla426x4ywaq59jm89ql1i42n39iw6z0j378xwb676v9kfxhm"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hmatrix" ,ghc-hmatrix)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-random" ,ghc-random)
+ ("gsl" ,gsl)))
+ (native-inputs `(("pkg-config" ,pkg-config)))
+ (home-page "https://github.com/albertoruiz/hmatrix")
+ (synopsis "Haskell GSL binding")
+ (description "This Haskell library provides a purely functional
+interface to selected numerical computations, internally implemented
+using GSL.")
+ (license license:gpl3+)))
+
+(define-public ghc-hmatrix-gsl-stats
+ (package
+ (name "ghc-hmatrix-gsl-stats")
+ (version "0.4.1.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://hackage.haskell.org/package/hmatrix-gsl-stats/hmatrix-gsl-stats-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1gslgk58lzin43cvbpivhw7nrn9qyaa6qwhy1z9ypvyal5p8n3sa"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)
+ ("ghc-storable-complex" ,ghc-storable-complex)
+ ("ghc-hmatrix" ,ghc-hmatrix)
+ ("gsl" ,gsl)))
+ (native-inputs `(("pkg-config" ,pkg-config)))
+ (home-page "http://code.haskell.org/hmatrix-gsl-stats")
+ (synopsis "GSL Statistics interface for Haskell")
+ (description "This Haskell library provides a purely functional
+interface for statistics based on hmatrix and GSL.")
+ (license license:bsd-3)))
+
+(define-public ghc-hmatrix-special
+ (package
+ (name "ghc-hmatrix-special")
+ (version "0.19.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://hackage.haskell.org/package/hmatrix-special/hmatrix-special-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1mywr61kr852sbff26n9x95kswx9l4ycbv6s68qsbkh02xzqq7qz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hmatrix" ,ghc-hmatrix)
+ ("ghc-hmatrix-gsl" ,ghc-hmatrix-gsl)))
+ (home-page "https://github.com/albertoruiz/hmatrix")
+ (synopsis "Haskell interface to GSL special functions")
+ (description "This library provides an interface to GSL special
+functions for Haskell.")
+ (license license:gpl3+)))
+
+(define-public ghc-hostname
+ (package
+ (name "ghc-hostname")
+ (version "1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/hostname/"
+ "hostname-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/hostname")
+ (synopsis "Hostname in Haskell")
+ (description "Network.HostName is a simple package providing a means to
+determine the hostname.")
+ (license license:bsd-3)))
+
+(define-public ghc-hourglass
+ (package
+ (name "ghc-hourglass")
+ (version "0.2.12")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hourglass/hourglass-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0jnay5j13vpz6i1rkaj3j0d9v8jfpri499xn3l7wd01f81f5ncs4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/vincenthz/hs-hourglass")
+ (synopsis "Simple time-related library for Haskell")
+ (description
+ "This is a simple time library providing a simple but powerful and
+performant API. The backbone of the library are the @code{Timeable} and
+@code{Time} type classes. Each @code{Timeable} instances can be converted to
+a type that has a @code{Time} instances, and thus are different
+representations of current time.")
+ (license license:bsd-3)))
+
+(define-public ghc-hpack
+ (package
+ (name "ghc-hpack")
+ (version "0.28.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/hpack/"
+ "hpack-" version ".tar.gz"))
+ (sha256
+ (base32
+ "18w0h76jdp3mk9vin8da9iz3cwhcxmw787xy8wlh8bxcpcr16q5r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-glob" ,ghc-glob)
+ ("ghc-http-client" ,ghc-http-client)
+ ("ghc-http-client-tls" ,ghc-http-client-tls)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-yaml" ,ghc-yaml)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-interpolate" ,ghc-interpolate)
+ ("ghc-mockery" ,ghc-mockery)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-temporary" ,ghc-temporary)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/sol/hpack")
+ (synopsis "Tools for an alternative Haskell package format")
+ (description
+ "Hpack is a format for Haskell packages. It is an alternative to the
+Cabal package format and follows different design principles. Hpack packages
+are described in a file named @code{package.yaml}. Both @code{cabal2nix} and
+@code{stack} support @code{package.yaml} natively. For other build tools the
+@code{hpack} executable can be used to generate a @code{.cabal} file from
+@code{package.yaml}.")
+ (license license:expat)))
+
+(define-public ghc-hs-bibutils
+ (package
+ (name "ghc-hs-bibutils")
+ (version "6.6.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hs-bibutils/hs-bibutils-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0n2sz2zl4naspryd49ii858qkjp2lapns5a2gr8zm6vvn5sh1f0l"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-syb" ,ghc-syb)))
+ (home-page "https://hackage.haskell.org/package/hs-bibutils")
+ (synopsis "Haskell bindings to bibutils")
+ (description
+ "This package provides Haskell bindings to @code{bibutils}, a library
+that interconverts between various bibliography formats using a common
+MODS-format XML intermediate.")
+ (license license:gpl2+)))
+
+(define-public ghc-hslogger
+ (package
+ (name "ghc-hslogger")
+ (version "1.2.10")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hslogger-" version "/" "hslogger-"
+ version ".tar.gz"))
+ (sha256 (base32
+ "0as5gvlh6pi2gflakp695qnlizyyp059dqrhvjl4gjxalja6xjnp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-network" ,ghc-network)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://software.complete.org/hslogger")
+ (synopsis "Logging framework for Haskell, similar to Python's logging module")
+ (description "Hslogger lets each log message have a priority and source be
+associated with it. The programmer can then define global handlers that route
+or filter messages based on the priority and source. It also has a syslog
+handler built in.")
+ (license license:bsd-3)))
+
+(define-public ghc-hslua
+ (package
+ (name "ghc-hslua")
+ (version "0.9.5.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hslua/hslua-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1rdvv01p214zfjh6fcqjjgqwi8y42wad6cqzhlcv5gvclzw2ck8f"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags '("-fsystem-lua")))
+ (inputs
+ `(("lua" ,lua)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-fail" ,ghc-fail)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+ (home-page "https://hackage.haskell.org/package/hslua")
+ (synopsis "Lua language interpreter embedding in Haskell")
+ (description
+ "The Scripting.Lua module is a wrapper of the Lua language interpreter as
+described in @url{https://www.lua.org/}.")
+ (license license:expat)))
+
+(define-public ghc-hslua-module-text
+ (package
+ (name "ghc-hslua-module-text")
+ (version "0.1.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hslua-module-text/hslua-module-text-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0bcfpb1dhnxp0gr376ai4w7vczr9zrjl1r3r6w7kcxivfkwq9cxf"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n")))
+ (inputs
+ `(("ghc-hslua" ,ghc-hslua)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/hslua/hslua-module-text")
+ (synopsis "Lua module for text")
+ (description
+ "This package provides a UTF-8 aware subset of Lua's @code{string} module
+for Haskell. The functions provided by this module are @code{upper},
+@code{lower}, @code{len}, @code{reverse}, and @code{sub}.")
+ (license license:expat)))
+
+(define-public ghc-http-api-data
+ (package
+ (name "ghc-http-api-data")
+ (version "0.3.8.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "http-api-data-" version "/"
+ "http-api-data-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1cq6459b8wz6nvkvpi89dg189n5q2xdq4rdq435hf150555vmskf"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Tests require QuickCheck >= 2.9
+ (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-attoparsec-iso8601" ,ghc-attoparsec-iso8601)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-uri-bytestring" ,ghc-uri-bytestring)
+ ("ghc-uuid-types" ,ghc-uuid-types)))
+ (home-page "https://github.com/fizruk/http-api-data")
+ (synopsis "Convert to/from HTTP API data like URL pieces, headers and
+query parameters")
+ (description "This Haskell package defines typeclasses used for converting
+Haskell data types to and from HTTP API data.")
+ (license license:bsd-3)))
+
+(define-public ghc-ieee754
+ (package
+ (name "ghc-ieee754")
+ (version "0.8.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/ieee754/"
+ "ieee754-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1lcs521g9lzy9d7337vg4w7q7s8500rfqy7rcifcz6pm6yfgyb8f"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/patperry/hs-ieee754")
+ (synopsis "Utilities for dealing with IEEE floating point numbers")
+ (description "Utilities for dealing with IEEE floating point numbers,
+ported from the Tango math library; approximate and exact equality comparisons
+for general types.")
+ (license license:bsd-3)))
+
+(define-public ghc-ifelse
+ (package
+ (name "ghc-ifelse")
+ (version "0.85")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "IfElse/IfElse-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
+ (build-system haskell-build-system)
+ (home-page "http://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
+@code{switch} function.")
+ (license license:bsd-3)))
+
+(define-public ghc-indents
+ (package
+ (name "ghc-indents")
+ (version "0.5.0.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/indents/indents-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1ly3v41jacc6lrsvg4j3m5a6zs90gr8dyif5m6bf34hj1k5cgg0n"))))
+ (build-system haskell-build-system)
+ ;; This package needs an older version of tasty.
+ (arguments '(#:tests? #f))
+ (inputs
+ `(("ghc-concatenative" ,ghc-concatenative)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "http://patch-tag.com/r/salazar/indents")
+ (synopsis "Indentation sensitive parser-combinators for parsec")
+ (description
+ "This library provides functions for use in parsing indentation sensitive
+contexts. It parses blocks of lines all indented to the same level as well as
+lines continued at an indented level below.")
+ (license license:bsd-3)))
+
+(define-public ghc-inline-c
+ (package
+ (name "ghc-inline-c")
+ (version "0.6.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/inline-c/"
+ "inline-c-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0vbfrsqsi7mdziqsnj68bsqlwbqxxhvrmy9rv6w8z18d1m8w3n6h"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-cryptohash" ,ghc-cryptohash)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-parsers" ,ghc-parsers)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("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")
+ (synopsis "Write Haskell source files including C code inline")
+ (description
+ "inline-c lets you seamlessly call C libraries and embed high-performance
+inline C code in Haskell modules. Haskell and C can be freely intermixed in
+the same source file, and data passed to and from code in either language with
+minimal overhead. No FFI required.")
+ (license license:expat)))
+
+(define-public ghc-inline-c-cpp
+ (package
+ (name "ghc-inline-c-cpp")
+ (version "0.2.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/inline-c-cpp/"
+ "inline-c-cpp-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1rk7fmpkmxw9hhwr8df29kadnf0ybnwj64ggdbnsdrpfyhnkisci"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-inline-c" ,ghc-inline-c)
+ ("ghc-safe-exceptions" ,ghc-safe-exceptions)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://hackage.haskell.org/package/inline-c-cpp")
+ (synopsis "Lets you embed C++ code into Haskell")
+ (description
+ "This package provides utilities to inline C++ code into Haskell using
+@code{inline-c}.")
+ (license license:expat)))
+
+(define-public ghc-integer-logarithms
+ (package
+ (name "ghc-integer-logarithms")
+ (version "1.0.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "integer-logarithms/integer-logarithms-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1wj8kgjg5bn2yrs4zh9qfjv85cx6w998j9pi39yrbv305944mb9j"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "integer-logarithms.cabal"
+ (("tasty >= 0\\.10 && < 1\\.1")
+ "tasty >= 0.10 && < 1.2")))))))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)))
+ (home-page "https://github.com/Bodigrim/integer-logarithms")
+ (synopsis "Integer logarithms")
+ (description
+ "This package provides the following modules:
+@code{Math.NumberTheory.Logarithms} and
+@code{Math.NumberTheory.Powers.Integer} from the @code{arithmoi} package,
+@code{GHC.Integer.Logarithms.Compat} and
+@code{Math.NumberTheory.Power.Natural}, as well as some additional functions
+in migrated modules.")
+ (license license:expat)))
+
+(define-public ghc-integer-logarithms-bootstrap
+ (package
+ (inherit ghc-integer-logarithms)
+ (name "ghc-integer-logarithms-bootstrap")
+ (arguments `(#:tests? #f))
+ (native-inputs '())
+ (properties '(hidden? #t))))
+
+(define-public ghc-interpolate
+ (package
+ (name "ghc-interpolate")
+ (version "0.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/interpolate/"
+ "interpolate-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1gkaj98yz363v38fv78sqby236mp8yqwqcilx7kr2b9z0w3204bf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
+ (native-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/sol/interpolate")
+ (synopsis "String interpolation library")
+ (description "This package provides a string interpolation library for
+Haskell.")
+ (license license:expat)))
+
+(define-public ghc-intervalmap
+ (package
+ (name "ghc-intervalmap")
+ (version "0.6.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/IntervalMap/"
+ "IntervalMap-" version ".tar.gz"))
+ (sha256
+ (base32
+ "06hin9wf1by8aqa7820fsi2339bh82184frkwz3jsb9sqa0hszcg"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://www.chr-breitkopf.de/comp/IntervalMap")
+ (synopsis "Containers for intervals, with efficient search")
+ (description
+ "This package provides ordered containers of intervals, with efficient
+search for all keys containing a point or overlapping an interval. See the
+example code on the home page for a quick introduction.")
+ (license license:bsd-3)))
+
+(define-public ghc-invariant
+ (package
+ (name "ghc-invariant")
+ (version "0.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/invariant/invariant-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0aqj7z55632qdg45074kgn9qfdxzb0a2f8lgjzr0l0i4mm2rr37b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-statevar" ,ghc-statevar)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-th-abstraction" ,ghc-th-abstraction)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/nfrisby/invariant-functors")
+ (synopsis "Haskell98 invariant functors")
+ (description "Haskell98 invariant functors (also known as exponential
+functors). For more information, see Edward Kmett's article
+@uref{http://comonad.com/reader/2008/rotten-bananas/, Rotten Bananas}.")
+ (license license:bsd-2)))
+
(define-public ghc-io-streams
(package
(name "ghc-io-streams")
@@ -146,6 +5334,160 @@ about a networked peer (like remote address and port) to be propagated
through a forwarding proxy that is configured to speak this protocol.")
(license license:bsd-3)))
+(define-public ghc-iproute
+ (package
+ (name "ghc-iproute")
+ (version "1.7.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/iproute/iproute-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1vw1nm3s8vz1hqnjnqd3wh5rr4q3m2r4izn5ynhf93h9185qwqzd"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
+ ; exported by ghc-byteorder. Doctest issue.
+ (inputs
+ `(("ghc-appar" ,ghc-appar)
+ ("ghc-byteorder" ,ghc-byteorder)
+ ("ghc-network" ,ghc-network)
+ ("ghc-safe" ,ghc-safe)))
+ (home-page "https://www.mew.org/~kazu/proj/iproute/")
+ (synopsis "IP routing table")
+ (description "IP Routing Table is a tree of IP ranges to search one of
+them on the longest match base. It is a kind of TRIE with one way branching
+removed. Both IPv4 and IPv6 are supported.")
+ (license license:bsd-3)))
+
+(define-public ghc-iwlib
+ (package
+ (name "ghc-iwlib")
+ (version "0.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/iwlib/iwlib-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "0khmfwql4vwj55idsxmhjhrbqzfir3g9wm5lmpvnf77mm95cfpdz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("wireless-tools" ,wireless-tools)))
+ (home-page "https://github.com/jaor/iwlib")
+ (synopsis "Haskell binding to the iw wireless networking library")
+ (description
+ "IWlib is a thin Haskell binding to the iw C library. It provides
+information about the current wireless network connections, and adapters on
+supported systems.")
+ (license license:bsd-3)))
+
+(define-public ghc-json
+ (package
+ (name "ghc-json")
+ (version "0.9.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/json/"
+ "json-" version ".tar.gz"))
+ (sha256
+ (base32
+ "13kkfgx58z18jphbg56jn08jn72wi3kvfndlwwx87hqwg7x1dfz6"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-syb" ,ghc-syb)))
+ (home-page "https://hackage.haskell.org/package/json")
+ (synopsis "Serializes Haskell data to and from JSON")
+ (description "This package provides a parser and pretty printer for
+converting between Haskell values and JSON.
+JSON (JavaScript Object Notation) is a lightweight data-interchange format.")
+ (license license:bsd-3)))
+
+(define-public ghc-juicypixels
+ (package
+ (name "ghc-juicypixels")
+ (version "3.2.9.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "JuicyPixels/JuicyPixels-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0mf3ihr0xy2wc2wzb9a17g0n3p60x7pvm8akwpvhdy8klvs6r744"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-zlib" ,ghc-zlib)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-mmap" ,ghc-mmap)))
+ (home-page "https://github.com/Twinside/Juicy.Pixels")
+ (synopsis "Picture loading and serialization library")
+ (description
+ "This library can load and store images in PNG, Bitmap, JPEG, Radiance,
+TIFF and GIF formats.")
+ (license license:bsd-3)))
+
+(define-public ghc-kan-extensions
+ (package
+ (name "ghc-kan-extensions")
+ (version "5.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/kan-extensions/kan-extensions-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1lyvyiwwh962j2nnnsqzlvp5zq6z8p3spvhmji99cjvldxc7wwkb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-adjunctions" ,ghc-adjunctions)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-free" ,ghc-free)
+ ("ghc-invariant" ,ghc-invariant)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/ekmett/kan-extensions/")
+ (synopsis "Kan extensions library")
+ (description "This library provides Kan extensions, Kan lifts, various
+forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-language-c
+ (package
+ (name "ghc-language-c")
+ (version "0.8.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "language-c/language-c-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0sdkjj0hq8p69fcdm6ljbjkjvrsrb8a6rl5dq6dj6byj32ajrm3d"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-syb" ,ghc-syb)))
+ (native-inputs
+ `(("ghc-happy" ,ghc-happy)
+ ("ghc-alex" ,ghc-alex)))
+ (home-page "https://visq.github.io/language-c/")
+ (synopsis "Analysis and generation of C code")
+ (description
+ "Language C is a Haskell library for the analysis and generation of C code.
+It features a complete, well-tested parser and pretty printer for all of C99
+and a large set of GNU extensions.")
+ (license license:bsd-3)))
+
(define-public ghc-language-glsl
(package
(name "ghc-language-glsl")
@@ -170,6 +5512,2071 @@ through a forwarding proxy that is configured to speak this protocol.")
representation, parsing, and pretty-printing of GLSL 1.50 code.")
(license license:bsd-3)))
+(define-public ghc-language-haskell-extract
+ (package
+ (name "ghc-language-haskell-extract")
+ (version "0.2.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "language-haskell-extract-" version "/"
+ "language-haskell-extract-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-posix" ,ghc-regex-posix)))
+ (home-page "https://github.com/finnsson/template-helper")
+ (synopsis "Haskell module to automatically extract functions from
+the local code")
+ (description "This package contains helper functions on top of
+Template Haskell.
+
+For example, @code{functionExtractor} extracts all functions after a
+regexp-pattern, which can be useful if you wish to extract all functions
+beginning with @code{test} (for a test framework) or all functions beginning
+with @code{wc} (for a web service).")
+ (license license:bsd-3)))
+
+(define-public ghc-lens
+ (package
+ (name "ghc-lens")
+ (version "4.16.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/lens/lens-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1im4drhbydbawd6i0jsrzpqihnmx4ywpkg7yg94ddwsw3mxwkgpm"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri")))
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-free" ,ghc-free)
+ ("ghc-kan-extensions" ,ghc-kan-extensions)
+ ("ghc-parallel" ,ghc-parallel)
+ ("ghc-reflection" ,ghc-reflection)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-call-stack" ,ghc-call-stack)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-void" ,ghc-void)
+ ("ghc-generic-deriving" ,ghc-generic-deriving)
+ ("ghc-nats" ,ghc-nats)
+ ("ghc-simple-reflect" ,ghc-simple-reflect)
+ ("hlint" ,hlint)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-th" ,ghc-test-framework-th)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/ekmett/lens/")
+ (synopsis "Lenses, Folds and Traversals")
+ (description "This library provides @code{Control.Lens}. The combinators
+in @code{Control.Lens} provide a highly generic toolbox for composing families
+of getters, folds, isomorphisms, traversals, setters and lenses and their
+indexed variants.")
+ (license license:bsd-3)))
+
+(define-public ghc-libffi
+ (package
+ (name "ghc-libffi")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "libffi/libffi-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0g7jnhng3j7z5517aaqga0144aamibsbpgm3yynwyfzkq1kp0f28"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("pkg-config" ,pkg-config)))
+ (inputs `(("libffi" ,libffi)))
+ (home-page "http://hackage.haskell.org/package/libffi")
+ (synopsis "Haskell binding to libffi")
+ (description
+ "A binding to libffi, allowing C functions of types only known at runtime
+to be called from Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-libmpd
+ (package
+ (name "ghc-libmpd")
+ (version "0.9.0.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/libmpd/libmpd-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1931m23iqb4wddpdidm4ph746zpaw41kkjzmb074j7yyfpk7x1jv"))))
+ (build-system haskell-build-system)
+ ;; Tests fail on i686.
+ ;; See https://github.com/vimus/libmpd-haskell/issues/112
+ (arguments `(#:tests? #f))
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-network" ,ghc-network)
+ ("ghc-utf8-string" ,ghc-utf8-string)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/vimus/libmpd-haskell")
+ (synopsis "Haskell client library for the Music Player Daemon")
+ (description "This package provides a pure Haskell client library for the
+Music Player Daemon.")
+ (license license:expat)))
+
+(define-public ghc-libxml
+ (package
+ (name "ghc-libxml")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/libxml/"
+ "libxml-" version ".tar.gz"))
+ (sha256
+ (base32
+ "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("libxml2" ,libxml2)))
+ (arguments
+ `(#:configure-flags
+ `(,(string-append "--extra-include-dirs="
+ (assoc-ref %build-inputs "libxml2")
+ "/include/libxml2"))))
+ (home-page "https://hackage.haskell.org/package/libxml")
+ (synopsis "Haskell bindings to libxml2")
+ (description
+ "This library provides minimal Haskell binding to libxml2.")
+ (license license:bsd-3)))
+
+(define-public ghc-lifted-async
+ (package
+ (name "ghc-lifted-async")
+ (version "0.10.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/lifted-async/lifted-async-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1073r512c1x2m1v0jar9bwqg656slg7jd1jhsyj6m8awgx1l1mwf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-constraints" ,ghc-constraints)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-th" ,ghc-tasty-th)))
+ (home-page "https://github.com/maoe/lifted-async")
+ (synopsis "Run lifted IO operations asynchronously and wait for their results")
+ (description
+ "This package provides IO operations from @code{async} package lifted to any
+instance of @code{MonadBase} or @code{MonadBaseControl}.")
+ (license license:bsd-3)))
+
+(define-public ghc-lifted-base
+ (package
+ (name "ghc-lifted-base")
+ (version "0.2.3.12")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/lifted-base/lifted-base-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1i8p8d3rkdh21bhgjjh32vd7qqjr7jq7p59qds0aw2kmargsjd61"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
+ (inputs
+ `(("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/basvandijk/lifted-base")
+ (synopsis "Lifted IO operations from the base library")
+ (description "Lifted-base exports IO operations from the @code{base}
+library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
+Note that not all modules from @code{base} are converted yet. The package
+includes a copy of the @code{monad-peel} test suite written by Anders
+Kaseorg.")
+ (license license:bsd-3)))
+
+(define-public ghc-linear
+ (package
+ (name "ghc-linear")
+ (version "1.20.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/linear/"
+ "linear-" version ".tar.gz"))
+ (sha256
+ (base32
+ "046vkvxlb0s286qr55s0c6db0rlwbm1cmlmwhrrkqbkzhfcipgay"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-adjunctions" ,ghc-adjunctions)
+ ("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-bytes" ,ghc-bytes)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-reflection" ,ghc-reflection)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-void" ,ghc-void)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-simple-reflect" ,ghc-simple-reflect)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "http://github.com/ekmett/linear/")
+ (synopsis "Linear algebra library for Haskell")
+ (description
+ "This package provides types and combinators for linear algebra on free
+vector spaces.")
+ (license license:bsd-3)))
+
+(define-public ghc-logging-facade
+ (package
+ (name "ghc-logging-facade")
+ (version "0.3.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "logging-facade/logging-facade-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/logging-facade")
+ (synopsis "Simple logging abstraction that allows multiple back-ends")
+ (description
+ "This package provides a simple logging abstraction that allows multiple
+back-ends.")
+ (license license:expat)))
+
+(define-public ghc-logict
+ (package
+ (name "ghc-logict")
+ (version "0.6.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/logict/logict-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
+ (build-system haskell-build-system)
+ (home-page "http://code.haskell.org/~dolio/")
+ (synopsis "Backtracking logic-programming monad")
+ (description "This library provides a continuation-based, backtracking,
+logic programming monad. An adaptation of the two-continuation implementation
+found in the paper \"Backtracking, Interleaving, and Terminating Monad
+Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
+online}.")
+ (license license:bsd-3)))
+
+(define-public ghc-lzma
+ (package
+ (name "ghc-lzma")
+ (version "0.0.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/lzma/"
+ "lzma-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg"))))
+ (build-system haskell-build-system)
+ (arguments
+ '(#:tests? #f ; requires older versions of QuickCheck and tasty.
+ #:cabal-revision
+ ("3" "1sify6gnsalyp6dakfzi0mdy5jcz2kcp9jsdsgkmxd40nfzgd44m")))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/hvr/lzma")
+ (synopsis "LZMA/XZ compression and decompression")
+ (description
+ "This package provides a pure interface for compressing and
+decompressing LZMA streams of data represented as lazy @code{ByteString}s. A
+monadic incremental interface is provided as well.")
+ (license license:bsd-3)))
+
+(define-public ghc-lzma-conduit
+ (package
+ (name "ghc-lzma-conduit")
+ (version "1.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/lzma-conduit/"
+ "lzma-conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0hm72da7xk9l3zxjh274yg444vf405djxqbkf3q3p2qhicmxlmg9"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-lzma" ,ghc-lzma)
+ ("ghc-resourcet" ,ghc-resourcet)))
+ (native-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/alphaHeavy/lzma-conduit")
+ (synopsis "Conduit interface for lzma/xz compression")
+ (description
+ "This package provides a @code{Conduit} interface for the LZMA
+compression algorithm used in the @code{.xz} file format.")
+ (license license:bsd-3)))
+
+(define-public ghc-markdown-unlit
+ (package
+ (name "ghc-markdown-unlit")
+ (version "0.5.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/markdown-unlit/"
+ "markdown-unlit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1gy79vr85vcp13rdjh0hz7zv6daqqffww4j0cqn2lpjjh9xhsbg7"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-stringbuilder" ,ghc-stringbuilder)
+ ("ghc-temporary" ,ghc-temporary)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/sol/markdown-unlit#readme")
+ (synopsis "Literate Haskell support for Markdown")
+ (description "This package allows you to have a README.md that at the
+same time is a literate Haskell program.")
+ (license license:expat)))
+
+(define-public ghc-math-functions
+ (package
+ (name "ghc-math-functions")
+ (version "0.2.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "math-functions-" version "/"
+ "math-functions-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1sv5vabsx332v1lpb6v3jv4zrzvpx1n7yprzd8wlcda5vsc5a6zp"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: 1 test fails.
+ (inputs
+ `(("ghc-vector" ,ghc-vector)
+ ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-erf" ,ghc-erf)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/bos/math-functions")
+ (synopsis "Special functions and Chebyshev polynomials for Haskell")
+ (description "This Haskell library provides implementations of
+special mathematical functions and Chebyshev polynomials. These
+functions are often useful in statistical and numerical computing.")
+ (license license:bsd-3)))
+
+(define-public ghc-megaparsec
+ (package
+ (name "ghc-megaparsec")
+ (version "6.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "megaparsec/megaparsec-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "12iggy7qpf8x93jm64zf0g215xwy779bqyfyjk2bhmxqqr1yzgdy"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("4" "0ij3asi5vwlhbgwsy6nhli9a0qb7926mg809fsgyl1rnhs9fvpx1")))
+ (inputs
+ `(("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-parser-combinators" ,ghc-parser-combinators)
+ ("ghc-scientific" ,ghc-scientific)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/mrkkrp/megaparsec")
+ (synopsis "Monadic parser combinators")
+ (description
+ "This is an industrial-strength monadic parser combinator library.
+Megaparsec is a feature-rich package that strikes a nice balance between
+speed, flexibility, and quality of parse errors.")
+ (license license:bsd-2)))
+
+(define-public ghc-memory
+ (package
+ (name "ghc-memory")
+ (version "0.14.16")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "memory/memory-" version ".tar.gz"))
+ (sha256
+ (base32
+ "03rbszi5d4z9rlbfv8ydrl1xf84xsh8z57g07f7j9qccn9587c3v"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-basement" ,ghc-basement)
+ ("ghc-foundation" ,ghc-foundation)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/vincenthz/hs-memory")
+ (synopsis "Memory abstractions for Haskell")
+ (description
+ "This package provides memory abstractions, such as chunk of memory,
+polymorphic byte array management and manipulation functions. It contains a
+polymorphic byte array abstraction and functions similar to strict ByteString,
+different type of byte array abstraction, raw memory IO operations (memory
+set, memory copy, ..) and more")
+ (license license:bsd-3)))
+
+(define-public ghc-memotrie
+ (package
+ (name "ghc-memotrie")
+ (version "0.6.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/MemoTrie/MemoTrie-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "157p0pi6rrq74a35mq6zkkycv4ah7xhkbrcmnkb9xf7pznw4aq0x"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-newtype-generics" ,ghc-newtype-generics)))
+ (home-page "https://github.com/conal/MemoTrie")
+ (synopsis "Trie-based memo functions")
+ (description "This package provides a functional library for creating
+efficient memo functions using tries.")
+ (license license:bsd-3)))
+
+(define-public ghc-microlens
+ (package
+ (name "ghc-microlens")
+ (version "0.4.9.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "microlens-" version "/"
+ "microlens-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0j2nzf0vpx2anvsrg2w0vy2z4jn3kkcs2n6glkzblhn1j9piqh51"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/aelve/microlens")
+ (synopsis "Provides a tiny lens Haskell library with no dependencies")
+ (description "This Haskell package provides a lens library, just like
+@code{ghc-lens}, but smaller. It provides essential lenses and
+traversals (like @code{_1} and @code{_Just}), as well as ones which are simply
+nice to have (like @code{each}, @code{at}, and @code{ix}), and some
+combinators (like @code{failing} and @code{singular}), but everything else is
+stripped. As the result, this package has no dependencies.")
+ (license license:bsd-3)))
+
+(define-public ghc-microlens-ghc
+ (package
+ (name "ghc-microlens-ghc")
+ (version "0.4.9.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/microlens-ghc/microlens-ghc-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "03iwgg8zww9irv59l70c8yy7vzxir1zf66y12210xk91k5hq6jrj"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-microlens" ,ghc-microlens)))
+ (home-page "https://github.com/monadfix/microlens")
+ (synopsis "Use @code{microlens} with GHC libraries like @code{array}")
+ (description "This library provides everything that @code{microlens}
+provides plus instances to make @code{each}, @code{at}, and @code{ix}
+usable with arrays, @code{ByteString}, and containers. This package is
+a part of the @uref{http://hackage.haskell.org/package/microlens,
+microlens} family; see the readme
+@uref{https://github.com/aelve/microlens#readme, on Github}.")
+ (license license:bsd-3)))
+
+(define-public ghc-microlens-mtl
+ (package
+ (name "ghc-microlens-mtl")
+ (version "0.1.11.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/microlens-mtl/microlens-mtl-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0l6z1gkzwcpv89bxf5vgfrjb6gq2pj7sjjc53nvi5b9alx34zryk"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-microlens" ,ghc-microlens)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/monadfix/microlens")
+ (synopsis
+ "@code{microlens} support for Reader/Writer/State from mtl")
+ (description
+ "This package contains functions (like @code{view} or @code{+=}) which
+work on @code{MonadReader}, @code{MonadWriter}, and @code{MonadState} from the
+mtl package. This package is a part of the
+@uref{http://hackage.haskell.org/package/microlens, microlens} family; see the
+readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
+ (license license:bsd-3)))
+
+(define-public ghc-microlens-platform
+ (package
+ (name "ghc-microlens-platform")
+ (version "0.3.10")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "microlens-platform/microlens-platform-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1d4nhmgf9jq0ixc7qhwm7aaw3xdr0nalw58d0ydsydgf02cyazwv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-microlens" ,ghc-microlens)
+ ("ghc-microlens-ghc" ,ghc-microlens-ghc)
+ ("ghc-microlens-mtl" ,ghc-microlens-mtl)
+ ("ghc-microlens-th" ,ghc-microlens-th)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/monadfix/microlens")
+ (synopsis "Feature-complete microlens")
+ (description
+ "This package exports a module which is the recommended starting point
+for using @uref{http://hackage.haskell.org/package/microlens, microlens} if
+you aren't trying to keep your dependencies minimal. By importing
+@code{Lens.Micro.Platform} you get all functions and instances from
+@uref{http://hackage.haskell.org/package/microlens, microlens},
+@uref{http://hackage.haskell.org/package/microlens-th, microlens-th},
+@uref{http://hackage.haskell.org/package/microlens-mtl, microlens-mtl},
+@uref{http://hackage.haskell.org/package/microlens-ghc, microlens-ghc}, as
+well as instances for @code{Vector}, @code{Text}, and @code{HashMap}. The
+minor and major versions of @code{microlens-platform} are incremented whenever
+the minor and major versions of any other @code{microlens} package are
+incremented, so you can depend on the exact version of
+@code{microlens-platform} without specifying the version of @code{microlens}
+you need. This package is a part of the
+@uref{http://hackage.haskell.org/package/microlens, microlens} family; see the
+readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
+ (license license:bsd-3)))
+
+(define-public ghc-microlens-th
+ (package
+ (name "ghc-microlens-th")
+ (version "0.4.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "microlens-th-" version "/"
+ "microlens-th-" version ".tar.gz"))
+ (sha256
+ (base32
+ "02nj7lnl61yffi3c6wn341arxhld5r0vj6nzcb5zmqjhnqsv8c05"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-microlens" ,ghc-microlens)
+ ("ghc-th-abstraction" ,ghc-th-abstraction)))
+ (home-page
+ "https://github.com/aelve/microlens")
+ (synopsis "Automatic generation of record lenses for
+@code{ghc-microlens}")
+ (description "This Haskell package lets you automatically generate lenses
+for data types; code was extracted from the lens package, and therefore
+generated lenses are fully compatible with ones generated by lens (and can be
+used both from lens and microlens).")
+ (license license:bsd-3)))
+
+(define-public ghc-missingh
+ (package
+ (name "ghc-missingh")
+ (version "1.4.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/MissingH/"
+ "MissingH-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0wcvgrmav480w7nf4bl14yi0jq2yzanysxwzwas9hpb28vyjlgr8"))))
+ (build-system haskell-build-system)
+ ;; Tests require the unmaintained testpack package, which depends on the
+ ;; outdated QuickCheck version 2.7, which can no longer be built with
+ ;; recent versions of GHC and Haskell libraries.
+ (arguments '(#:tests? #f))
+ (inputs
+ `(("ghc-network" ,ghc-network)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-regex-compat" ,ghc-regex-compat)
+ ("ghc-hslogger" ,ghc-hslogger)
+ ("ghc-random" ,ghc-random)
+ ("ghc-old-time" ,ghc-old-time)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (native-inputs
+ `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "http://software.complete.org/missingh")
+ (synopsis "Large utility library")
+ (description
+ "MissingH is a library of all sorts of utility functions for Haskell
+programmers. It is written in pure Haskell and thus should be extremely
+portable and easy to use.")
+ (license license:bsd-3)))
+
+(define-public ghc-mmap
+ (package
+ (name "ghc-mmap")
+ (version "0.5.9")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "mmap/mmap-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/mmap")
+ (synopsis "Memory mapped files for Haskell")
+ (description
+ "This library provides a wrapper to @code{mmap}, allowing files or
+devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
+@code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
+do on-demand loading.")
+ (license license:bsd-3)))
+
+(define-public ghc-mmorph
+ (package
+ (name "ghc-mmorph")
+ (version "1.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/mmorph/mmorph-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1gjz1ib968lqybma7my1n19qq6cdj6a7nskrlnwy4jy9jrwzs2n9"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://hackage.haskell.org/package/mmorph")
+ (synopsis "Monad morphisms")
+ (description
+ "This library provides monad morphism utilities, most commonly used for
+manipulating monad transformer stacks.")
+ (license license:bsd-3)))
+
+(define-public ghc-mockery
+ (package
+ (name "ghc-mockery")
+ (version "0.3.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "mockery/mockery-" version ".tar.gz"))
+ (sha256
+ (base32
+ "09ypgm3z69gq8mj6y66ss58kbjnk15r8frwcwbqcfbfksfnfv8dp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-logging-facade" ,ghc-logging-facade)
+ ("ghc-base-compat" ,ghc-base-compat)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/mockery")
+ (synopsis "Support functions for automated testing")
+ (description
+ "The mockery package provides support functions for automated testing.")
+ (license license:expat)))
+
+(define-public ghc-monad-control
+ (package
+ (name "ghc-monad-control")
+ (version "1.0.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/monad-control"
+ "/monad-control-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1c92833gr6cadidjdp8mlznkpp8lyxl0w3y7d19y8yi3klc3843c"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/basvandijk/monad-control")
+ (synopsis "Monad transformers to lift control operations like exception
+catching")
+ (description "This package defines the type class @code{MonadBaseControl},
+a subset of @code{MonadBase} into which generic control operations such as
+@code{catch} can be lifted from @code{IO} or any other base monad.")
+ (license license:bsd-3)))
+
+(define-public ghc-monad-logger
+ (package
+ (name "ghc-monad-logger")
+ (version "0.3.29")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "monad-logger-" version "/"
+ "monad-logger-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-stm-chans" ,ghc-stm-chans)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-fast-logger" ,ghc-fast-logger)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-monad-loops" ,ghc-monad-loops)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-exceptions" ,ghc-exceptions)))
+ (home-page "https://github.com/kazu-yamamoto/logger")
+ (synopsis "Provides a class of monads which can log messages for Haskell")
+ (description "This Haskell package uses a monad transformer approach
+for logging.
+
+This package provides Template Haskell functions for determining source
+code locations of messages.")
+ (license license:expat)))
+
+(define-public ghc-monad-loops
+ (package
+ (name "ghc-monad-loops")
+ (version "0.4.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "monad-loops-" version "/"
+ "monad-loops-" version ".tar.gz"))
+ (sha256
+ (base32
+ "062c2sn3hc8h50p1mhqkpyv6x8dydz2zh3ridvlfjq9nqimszaky"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/mokus0/monad-loops")
+ (synopsis "Monadic loops for Haskell")
+ (description "This Haskell package provides some useful control
+operators for looping.")
+ (license license:public-domain)))
+
+(define-public ghc-monad-par
+ (package
+ (name "ghc-monad-par")
+ (version "0.3.4.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "monad-par-" version "/"
+ "monad-par-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0ldrzqy24fsszvn2a2nr77m2ih7xm0h9bgkjyv1l274aj18xyk7q"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
+ ("ghc-abstract-deque" ,ghc-abstract-deque)
+ ("ghc-monad-par-extras" ,ghc-monad-par-extras)
+ ("ghc-mwc-random" ,ghc-mwc-random)
+ ("ghc-parallel" ,ghc-parallel)))
+ (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2"
+ ,ghc-test-framework-quickcheck2)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-th" ,ghc-test-framework-th)))
+ (home-page "https://github.com/simonmar/monad-par")
+ (synopsis "Haskell library for parallel programming based on a monad")
+ (description "The @code{Par} monad offers an API for parallel
+programming. The library works for parallelising both pure and @code{IO}
+computations, although only the pure version is deterministic. The default
+implementation provides a work-stealing scheduler and supports forking tasks
+that are much lighter weight than IO-threads.")
+ (license license:bsd-3)))
+
+(define-public ghc-monad-par-extras
+ (package
+ (name "ghc-monad-par-extras")
+ (version "0.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "monad-par-extras-" version "/"
+ "monad-par-extras-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-random" ,ghc-random)))
+ (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.")
+ (license license:bsd-3)))
+
+(define-public ghc-monadrandom
+ (package
+ (name "ghc-monadrandom")
+ (version "0.5.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "MonadRandom-" version "/"
+ "MonadRandom-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0w44jl1n3kqvqaflh82l1wj3xxbhzfs3kf4m8rk7w6fgg8llmnmb"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-random" ,ghc-random)))
+ (home-page "https://github.com/byorgey/MonadRandom")
+ (synopsis "Random-number generation monad for Haskell")
+ (description "This Haskell package provides support for computations
+which consume random values.")
+ (license license:bsd-3)))
+
+(define-public ghc-monads-tf
+ (package
+ (name "ghc-monads-tf")
+ (version "0.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/monads-tf/monads-tf-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/monads-tf")
+ (synopsis "Monad classes, using type families")
+ (description
+ "Monad classes using type families, with instances for various monad transformers,
+inspired by the paper 'Functional Programming with Overloading and Higher-Order
+Polymorphism', by Mark P Jones. This package is almost a compatible replacement for
+the @code{mtl-tf} package.")
+ (license license:bsd-3)))
+
+(define-public ghc-mono-traversable
+ (package
+ (name "ghc-mono-traversable")
+ (version "1.0.9.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "mono-traversable-" version "/"
+ "mono-traversable-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0180ks0dyvpk1r20w5jw2w2n79mjnk69n9vhspaxzlyxqgim5psa"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-vector-algorithms" ,ghc-vector-algorithms)
+ ("ghc-split" ,ghc-split)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-foldl" ,ghc-foldl)))
+ (home-page "https://github.com/snoyberg/mono-traversable")
+ (synopsis "Haskell classes for mapping, folding, and traversing monomorphic
+containers")
+ (description "This Haskell package provides Monomorphic variants of the
+Functor, Foldable, and Traversable typeclasses. If you understand Haskell's
+basic typeclasses, you understand mono-traversable. In addition to what
+you are used to, it adds on an IsSequence typeclass and has code for marking
+data structures as non-empty.")
+ (license license:expat)))
+
+(define-public ghc-murmur-hash
+ (package
+ (name "ghc-murmur-hash")
+ (version "0.1.0.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/murmur-hash"
+ "/murmur-hash-" version ".tar.gz"))
+ (sha256
+ (base32 "1bb58kfnzvx3mpc0rc0dhqc1fk36nm8prd6gvf20gk6lxaadpfc9"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/nominolo/murmur-hash")
+ (synopsis "MurmurHash2 implementation for Haskell")
+ (description
+ "This package provides an implementation of MurmurHash2, a good, fast,
+general-purpose, non-cryptographic hashing function. See
+@url{https://sites.google.com/site/murmurhash/} for details. This
+implementation is pure Haskell, so it might be a bit slower than a C FFI
+binding.")
+ (license license:bsd-3)))
+
+(define-public ghc-mwc-random
+ (package
+ (name "ghc-mwc-random")
+ (version "0.13.6.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "mwc-random-" version "/"
+ "mwc-random-" version ".tar.gz"))
+ (sha256
+ (base32
+ "05j7yh0hh9nxic3dijmzv44kc6gzclvamdph7sq7w19wq57k6pq6"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-primitive" ,ghc-primitive)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-math-functions" ,ghc-math-functions)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/bos/mwc-random")
+ (synopsis "Random number generation library for Haskell")
+ (description "This Haskell package contains code for generating
+high quality random numbers that follow either a uniform or normal
+distribution. The generated numbers are suitable for use in
+statistical applications.
+
+The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222)
+multiply-with-carry generator, which has a period of 2^{8222} and
+fares well in tests of randomness. It is also extremely fast,
+between 2 and 3 times faster than the Mersenne Twister.")
+ (license license:bsd-3)))
+
+(define-public ghc-nats
+ (package
+ (name "ghc-nats")
+ (version "1.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/nats/nats-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1v40drmhixck3pz3mdfghamh73l4rp71mzcviipv1y8jhrfxilmr"))))
+ (build-system haskell-build-system)
+ (arguments `(#:haddock? #f))
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)))
+ (home-page "https://hackage.haskell.org/package/nats")
+ (synopsis "Natural numbers")
+ (description "This library provides the natural numbers for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-nats-bootstrap
+ (package
+ (inherit ghc-nats)
+ (name "ghc-nats-bootstrap")
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable-bootstrap)))
+ (properties '((hidden? #t)))))
+
+(define-public ghc-network
+ (package
+ (name "ghc-network")
+ (version "2.6.3.6")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/network/network-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "198mam7ahny48p9fajznbqq16a8ya2gw0xm3gnm1si1rmc4hdplv"))))
+ (build-system haskell-build-system)
+ ;; The regression tests depend on an unpublished module.
+ (arguments `(#:tests? #f))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://github.com/haskell/network")
+ (synopsis "Low-level networking interface")
+ (description
+ "This package provides a low-level networking interface.")
+ (license license:bsd-3)))
+
+(define-public ghc-network-info
+ (package
+ (name "ghc-network-info")
+ (version "0.2.0.10")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "network-info-" version "/"
+ "network-info-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/jystic/network-info")
+ (synopsis "Access the local computer's basic network configuration")
+ (description "This Haskell library provides simple read-only access to the
+local computer's networking configuration. It is currently capable of
+getting a list of all the network interfaces and their respective
+IPv4, IPv6 and MAC addresses.")
+ (license license:bsd-3)))
+
+(define-public ghc-network-uri
+ (package
+ (name "ghc-network-uri")
+ (version "2.6.1.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/network-uri/network-uri-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1w27zkvn39kjr9lmw9421y8w43h572ycsfafsb7kyvr3a4ihlgj2"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (inputs
+ `(("ghc-network" ,ghc-network)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page
+ "https://github.com/haskell/network-uri")
+ (synopsis "Library for URI manipulation")
+ (description "This package provides an URI manipulation interface. In
+@code{network-2.6} the @code{Network.URI} module was split off from the
+@code{network} package into this package.")
+ (license license:bsd-3)))
+
+(define-public ghc-newtype-generics
+ (package
+ (name "ghc-newtype-generics")
+ (version "0.5.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "newtype-generics/newtype-generics-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0igyisw2djg19v9vkna1rwf47k97mvkvk4bbkmswznvbm00z15gj"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "http://github.com/sjakobi/newtype-generics")
+ (synopsis "Typeclass and set of functions for working with newtypes")
+ (description "The @code{Newtype} typeclass represents the packing and
+unpacking of a newtype, and allows you to operate under that newtype with
+functions such as @code{ala}. Generics support was added in version 0.4,
+making this package a full replacement for the original newtype package,
+and an alternative to newtype-th.")
+ (license license:bsd-3)))
+
+(define-public ghc-objectname
+ (package
+ (name "ghc-objectname")
+ (version "1.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/ObjectName/ObjectName-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "046jm94rmm46cicd31pl54vdvfjvhd9ffbfycy2lxzc0fliyznvj"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/ObjectName")
+ (synopsis "Helper library for Haskell OpenGL")
+ (description "This tiny package contains the class ObjectName, which
+corresponds to the general notion of explicitly handled identifiers for API
+objects, e.g. a texture object name in OpenGL or a buffer object name in
+OpenAL.")
+ (license license:bsd-3)))
+
+(define-public ghc-old-locale
+ (package
+ (name "ghc-old-locale")
+ (version "1.0.0.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/old-locale/old-locale-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "04b9vn007hlvsrx4ksd3r8r3kbyaj2kvwxchdrmd4370qzi8p6gs")))
+ (home-page "https://hackage.haskell.org/package/old-locale")
+ (synopsis "Adapt to locale conventions")
+ (description
+ "This package provides the ability to adapt to locale conventions such as
+date and time formats.")
+ (license license:bsd-3)))
+
+(define-public ghc-old-time
+ (package
+ (name "ghc-old-time")
+ (version "1.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/old-time/old-time-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "1j6ln1dkvhdvnwl33bp0xf9lhc4sybqk0aw42p8cq81xwwzbn7y9")))
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)))
+ (home-page "https://hackage.haskell.org/package/old-time")
+ (synopsis "Time compatibility library for Haskell")
+ (description "Old-time is a package for backwards compatibility with the
+old @code{time} library. For new projects, the newer
+@uref{https://hackage.haskell.org/package/time, time library} is recommended.")
+ (license license:bsd-3)))
+
+(define-public ghc-opengl
+ (package
+ (name "ghc-opengl")
+ (version "3.0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/OpenGL/OpenGL-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "19vxwvx2n8zq2klj176l25n2b64ybp0b8mhm4p46gvpcivz41fjc"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-objectname" ,ghc-objectname)
+ ("ghc-gluraw" ,ghc-gluraw)
+ ("ghc-statevar" ,ghc-statevar)
+ ("ghc-openglraw" ,ghc-openglraw)))
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Haskell bindings for the OpenGL graphics system")
+ (description "This package provides Haskell bindings for the OpenGL
+graphics system (GL, version 4.5) and its accompanying utility library (GLU,
+version 1.3).")
+ (license license:bsd-3)))
+
+(define-public ghc-openglraw
+ (package
+ (name "ghc-openglraw")
+ (version "3.3.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1x8w3x308jldj2c1xqcq3a3sc2jc06pdpgqkgjsmixi1skv4a1vb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-half" ,ghc-half)
+ ("ghc-fixed" ,ghc-fixed)
+ ("glu" ,glu)))
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Raw Haskell bindings for the OpenGL graphics system")
+ (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
+graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
+of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
+offers access to all necessary functions, tokens and types plus a general
+facility for loading extension entries. The module hierarchy closely mirrors
+the naming structure of the OpenGL extensions, making it easy to find the
+right module to import. All API entries are loaded dynamically, so no special
+C header files are needed for building this package. If an API entry is not
+found at runtime, a userError is thrown.")
+ (license license:bsd-3)))
+
+(define-public ghc-operational
+ (package
+ (name "ghc-operational")
+ (version "0.2.3.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/operational/"
+ "operational-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1x2abg2q9d26h1vzj40r6k7k3gqgappbs4g9d853vvg77837km4i"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)))
+ (home-page "http://wiki.haskell.org/Operational")
+ (synopsis "Implementation of difficult monads made easy with operational semantics")
+ (description
+ "This library makes it easy to implement monads with tricky control
+flow. This is useful for: writing web applications in a sequential style,
+programming games with a uniform interface for human and AI players and easy
+replay capababilities, implementing fast parser monads, designing monadic
+DSLs, etc.")
+ (license license:bsd-3)))
+
+(define-public ghc-options
+ (package
+ (name "ghc-options")
+ (version "1.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/options/options-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-monads-tf" ,ghc-monads-tf)
+ ("ghc-chell" ,ghc-chell)
+ ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)))
+ (home-page "https://john-millikin.com/software/haskell-options/")
+ (synopsis "Powerful and easy-to-use command-line option parser")
+ (description
+ "The @code{options} package lets library and application developers
+easily work with command-line options.")
+ (license license:expat)))
+
+;; See ghc-system-filepath-bootstrap, chell and chell-quickcheck are required for tests.
+(define ghc-options-bootstrap
+ (package
+ (name "ghc-options-bootstrap")
+ (version "1.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/options/options-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f))
+ (inputs
+ `(("ghc-monads-tf" ,ghc-monads-tf)))
+ (home-page "https://john-millikin.com/software/haskell-options/")
+ (synopsis "Powerful and easy-to-use command-line option parser")
+ (description
+ "The @code{options} package lets library and application developers
+easily work with command-line options.")
+ (license license:expat)))
+
+
+(define-public ghc-optparse-applicative
+ (package
+ (name "ghc-optparse-applicative")
+ (version "0.14.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/optparse-applicative"
+ "/optparse-applicative-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0c3z1mvynlyv1garjbdmdd3npm40dabgm75js4r07cf766c1wd71"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/pcapriotti/optparse-applicative")
+ (synopsis "Utilities and combinators for parsing command line options")
+ (description "This package provides utilities and combinators for parsing
+command line options in Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-pandoc
+ (package
+ (name "ghc-pandoc")
+ (version "2.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1dqin92w513l7whg5wdgrngnxsj5mb8gppfvn7kjgyv2pdgpy0zy"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "pandoc.cabal"
+ (("tasty >= 0\\.11 && < 1\\.1")
+ "tasty >= 0.11 && < 1.1.1"))))
+ (add-before 'configure 'patch-tests
+ (lambda _
+ ;; These tests fail benignly and have been adjusted upstream:
+ ;; <https://github.com/commercialhaskell/stackage/issues/3719>.
+ (substitute* "test/Tests/Old.hs"
+ (("lhsWriterTests \"html\"") "[]")))))))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-aeson-pretty" ,ghc-aeson-pretty)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("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-text" ,ghc-hslua-module-text)
+ ("ghc-http" ,ghc-http)
+ ("ghc-http-client" ,ghc-http-client)
+ ("ghc-http-client-tls" ,ghc-http-client-tls)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-juicypixels" ,ghc-juicypixels)
+ ("ghc-network" ,ghc-network)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-pandoc-types" ,ghc-pandoc-types)
+ ("ghc-random" ,ghc-random)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-sha" ,ghc-sha)
+ ("ghc-skylighting" ,ghc-skylighting)
+ ("ghc-split" ,ghc-split)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-tagsoup" ,ghc-tagsoup)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-texmath" ,ghc-texmath)
+ ("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-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://pandoc.org")
+ (synopsis "Conversion between markup formats")
+ (description
+ "Pandoc is a Haskell library for converting from one markup format to
+another, and a command-line tool that uses this library. It can read and
+write Markdown and (subsets of) other formats, such as HTML, reStructuredText,
+LaTeX, DocBook, and many more.
+
+Pandoc extends standard Markdown syntax with footnotes, embedded LaTeX,
+definition lists, tables, and other features. A compatibility mode is
+provided for those who need a drop-in replacement for Markdown.pl.")
+ (license license:gpl2+)))
+
+(define-public ghc-pandoc-citeproc
+ (package
+ (name "ghc-pandoc-citeproc")
+ (version "0.14.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "pandoc-citeproc/pandoc-citeproc-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0yj6rckwsc9vig40cm15ry0j3d01xpk04qma9n4byhal6v4b5h22"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; Many YAML tests (44) are failing do to changes in ghc-yaml:
+ ;; <https://github.com/jgm/pandoc-citeproc/issues/342>.
+ (add-before 'configure 'patch-tests
+ (lambda _
+ (substitute* "tests/test-pandoc-citeproc.hs"
+ (("let allTests = citeprocTests \\+\\+ biblio2yamlTests")
+ "let allTests = citeprocTests"))))
+ ;; Tests need to be run after installation.
+ (delete 'check)
+ (add-after 'install 'post-install-check
+ (assoc-ref %standard-phases 'check)))))
+ (inputs
+ `(("ghc-pandoc-types" ,ghc-pandoc-types)
+ ("ghc-pandoc" ,ghc-pandoc)
+ ("ghc-tagsoup" ,ghc-tagsoup)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-xml-conduit" ,ghc-xml-conduit)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-data-default" ,ghc-data-default)
+ ("ghc-setenv" ,ghc-setenv)
+ ("ghc-split" ,ghc-split)
+ ("ghc-yaml" ,ghc-yaml)
+ ("ghc-hs-bibutils" ,ghc-hs-bibutils)
+ ("ghc-rfc5051" ,ghc-rfc5051)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-aeson-pretty" ,ghc-aeson-pretty)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/jgm/pandoc-citeproc")
+ (synopsis "Library for using pandoc with citeproc")
+ (description
+ "The @code{pandoc-citeproc} library exports functions for using the
+citeproc system with pandoc. It relies on @code{citeproc-hs}, a library for
+rendering bibliographic reference citations into a variety of styles using a
+macro language called @dfn{Citation Style Language} (CSL). This package also
+contains an executable @code{pandoc-citeproc}, which works as a pandoc filter,
+and also has a mode for converting bibliographic databases a YAML format
+suitable for inclusion in pandoc YAML metadata.")
+ (license license:bsd-3)))
+
+(define-public ghc-pandoc-types
+ (package
+ (name "ghc-pandoc-types")
+ (version "1.17.5.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "pandoc-types/pandoc-types-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1q6v2bynij724fv347mhqxdscwifzrx5jb9mq80608qf638fn717"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-string-qq" ,ghc-string-qq)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "http://johnmacfarlane.net/pandoc")
+ (synopsis "Types for representing a structured document")
+ (description
+ "This module defines the @code{Pandoc} data structure, which is used by
+pandoc to represent structured documents. It also provides functions for
+building up, manipulating and serialising @code{Pandoc} structures.")
+ (license license:bsd-3)))
+
+(define-public ghc-parallel
+ (package
+ (name "ghc-parallel")
+ (version "3.2.2.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/parallel/parallel-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1xkfi96w6yfpppd0nw1rnszdxmvifwzm699ilv6332ra3akm610p"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/parallel")
+ (synopsis "Parallel programming library")
+ (description
+ "This package provides a library for parallel programming.")
+ (license license:bsd-3)))
+
+(define-public ghc-parsec-numbers
+ (package
+ (name "ghc-parsec-numbers")
+ (version "0.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "parsec-numbers/parsec-numbers-" version ".tar.gz"))
+ (sha256
+ (base32 "1gzy4v3r02kvdxvgg1nj83mmb6aph2v4ilf9c7y6nbvi2x49l0bp"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/parsec-numbers")
+ (synopsis "Utilities for parsing numbers from strings")
+ (description
+ "This package provides the number parsers without the need to use a large
+(and unportable) token parser.")
+ (license license:bsd-3)))
+
+(define-public ghc-parser-combinators
+ (package
+ (name "ghc-parser-combinators")
+ (version "1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "parser-combinators/parser-combinators-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1pwfdsklqwvaynwpdzmx1bs35mp6dpsyaqdnzxnqcrxwf5h8sk75"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/mrkkrp/parser-combinators")
+ (synopsis "Commonly useful parser combinators")
+ (description
+ "This is a lightweight package providing commonly useful parser
+combinators.")
+ (license license:bsd-3)))
+
+(define-public ghc-parsers
+ (package
+ (name "ghc-parsers")
+ (version "0.12.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/parsers/parsers-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1r05sc1mcglk8w596kq9a1brfn9c2vll8lq16j07ln0vsz4jzrc1"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
+ ; -package attoparsec-0.13.0.1"
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-charset" ,ghc-charset)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (home-page "https://github.com/ekmett/parsers/")
+ (synopsis "Parsing combinators")
+ (description "This library provides convenient combinators for working
+with and building parsing combinator libraries. Given a few simple instances,
+you get access to a large number of canned definitions. Instances exist for
+the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
+@code{Text.Read}.")
+ (license license:bsd-3)))
+
+(define-public ghc-path
+ (package
+ (name "ghc-path")
+ (version "0.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/path/path-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0nayla4k1gb821k8y5b9miflv1bi8f0czf9rqr044nrr2dddi2sb"))))
+ (build-system haskell-build-system)
+ (arguments
+ ;; TODO: There are some Windows-related tests and modules that need to be
+ ;; danced around.
+ `(#:tests? #f
+ #:cabal-revision
+ ("1" "05b1zwx2a893h4h5wvgpc5g5pyx71hfmx409rqisd8s1bq1hn463")))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hashable" ,ghc-hashable)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-genvalidity" ,ghc-genvalidity)
+ ("ghc-genvalidity-property" ,ghc-genvalidity-property)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-validity" ,ghc-validity)))
+ (home-page
+ "http://hackage.haskell.org/package/path")
+ (synopsis "Support for well-typed paths")
+ (description "This package introduces a type for paths upholding useful
+invariants.")
+ (license license:bsd-3)))
+
+(define-public ghc-path-io
+ (package
+ (name "ghc-path-io")
+ (version "1.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/path-io/path-io-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1g9m3qliqjk1img894wsb89diym5zrq51qkkrwhz4sbm9a8hbv1a"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-dlist" ,ghc-dlist)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-path" ,ghc-path)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-temporary" ,ghc-temporary)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (arguments
+ `(#:cabal-revision
+ ("3" "1h9hsibbflkxpjl2fqamqiv3x3gasf51apnmklrs9l9x8r32hzcc")))
+ (home-page
+ "https://github.com/mrkkrp/path-io")
+ (synopsis "Functions for manipulating well-typed paths")
+ (description "This package provides an interface to the @code{directory}
+package for users of @code{path}. It also implements some missing stuff like
+recursive scanning and copying of directories, working with temporary
+files/directories, and more.")
+ (license license:bsd-3)))
+
+(define-public ghc-paths
+ (package
+ (name "ghc-paths")
+ (version "0.1.0.9")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/ghc-paths/ghc-paths-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/simonmar/ghc-paths")
+ (synopsis
+ "Knowledge of GHC's installation directories")
+ (description
+ "Knowledge of GHC's installation directories.")
+ (license license:bsd-3)))
+
+(define-public ghc-patience
+ (package
+ (name "ghc-patience")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/patience/patience-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/patience")
+ (synopsis "Patience diff and longest increasing subsequence")
+ (description
+ "This library implements the 'patience diff' algorithm, as well as the
+patience algorithm for the longest increasing subsequence problem.
+Patience diff computes the difference between two lists, for example the lines
+of two versions of a source file. It provides a good balance between
+performance, nice output for humans, and simplicity of implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-pcre-light
+ (package
+ (name "ghc-pcre-light")
+ (version "0.4.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/pcre-light/pcre-light-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0xcyi1fivwg7a92mch5bcqzmrfxzqj42rmb3m8kgs61x4qwpxj82"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("pcre" ,pcre)))
+ (native-inputs
+ `(("pkg-config" ,pkg-config)))
+ (home-page "https://github.com/Daniel-Diaz/pcre-light")
+ (synopsis "Haskell library for Perl 5 compatible regular expressions")
+ (description "This package provides a small, efficient, and portable regex
+library for Perl 5 compatible regular expressions. The PCRE library is a set
+of functions that implement regular expression pattern matching using the same
+syntax and semantics as Perl 5.")
+ (license license:bsd-3)))
+
+(define-public ghc-persistent
+ (package
+ (name "ghc-persistent")
+ (version "2.8.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "persistent-" version "/"
+ "persistent-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-resource-pool" ,ghc-resource-pool)
+ ("ghc-path-pieces" ,ghc-path-pieces)
+ ("ghc-http-api-data" ,ghc-http-api-data)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-fast-logger" ,ghc-fast-logger)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-void" ,ghc-void)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://www.yesodweb.com/book/persistent")
+ (synopsis "Type-safe, multi-backend data serialization for Haskell")
+ (description "This Haskell package allows Haskell programs to access data
+storage systems like PostgreSQL, SQLite, MySQL and MongoDB in a type-safe
+way.")
+ (license license:expat)))
+
+(define-public ghc-persistent-sqlite
+ (package
+ (name "ghc-persistent-sqlite")
+ (version "2.8.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "persistent-sqlite-" version "/"
+ "persistent-sqlite-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1chbmvjz46smhgnzhha3bbkhys3fys6dip1jr4v7xp1jf78zbyp6"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-persistent" ,ghc-persistent)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-microlens-th" ,ghc-microlens-th)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-resource-pool" ,ghc-resource-pool)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-persistent-template" ,ghc-persistent-template)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page
+ "https://www.yesodweb.com/book/persistent")
+ (synopsis "Backend for the persistent library using sqlite3")
+ (description "This Haskell package includes a thin sqlite3 wrapper based
+on the direct-sqlite package, as well as the entire C library, so there are no
+system dependencies.")
+ (license license:expat)))
+
+(define-public ghc-persistent-template
+ (package
+ (name "ghc-persistent-template")
+ (version "2.5.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "persistent-template-" version "/"
+ "persistent-template-" version ".tar.gz"))
+ (sha256
+ (base32
+ "008afcy7zbw7bzp9jww8gdldb51kfm0fg4p0x4xcp61gx4679bjc"))))
+ (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)
+ ("ghc-aeson-compat" ,ghc-aeson-compat)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-path-pieces" ,ghc-path-pieces)
+ ("ghc-http-api-data" ,ghc-http-api-data)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://www.yesodweb.com/book/persistent")
+ (synopsis "Type-safe, non-relational, multi-backend persistence")
+ (description "This Haskell package provides interfaces and helper
+functions for the ghc-persistent package.")
+ (license license:expat)))
+
+(define-public ghc-polyparse
+ (package
+ (name "ghc-polyparse")
+ (version "1.12")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/polyparse/polyparse-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "05dya1vdvq29hkhkdlsglzhw7bdn51rvs1javs0q75nf99c66k7m"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://code.haskell.org/~malcolm/polyparse/")
+ (synopsis
+ "Alternative parser combinator libraries")
+ (description
+ "This package provides a variety of alternative parser combinator
+libraries, including the original HuttonMeijer set. The Poly sets have
+features like good error reporting, arbitrary token type, running state, lazy
+parsing, and so on. Finally, Text.Parse is a proposed replacement for the
+standard Read class, for better deserialisation of Haskell values from
+Strings.")
+ (license license:lgpl2.1)))
+
+(define-public ghc-pqueue
+ (package
+ (name "ghc-pqueue")
+ (version "1.4.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "pqueue/pqueue-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1zvwm1zcqqq5n101s1brjhgbay8rf9fviq6gxbplf40i63m57p1x"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/pqueue")
+ (synopsis "Reliable, persistent, fast priority queues")
+ (description
+ "This package provides a fast, reliable priority queue implementation
+based on a binomial heap.")
+ (license license:bsd-3)))
+
+(define-public ghc-prelude-extras
+ (package
+ (name "ghc-prelude-extras")
+ (version "0.4.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/prelude-extras/prelude-extras-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0xzqdf3nl2h0ra4gnslm1m1nsxlsgc0hh6ky3vn578vh11zhifq9"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/ekmett/prelude-extras")
+ (synopsis "Higher order versions of Prelude classes")
+ (description "This library provides higher order versions of
+@code{Prelude} classes to ease programming with polymorphic recursion and
+reduce @code{UndecidableInstances}.")
+ (license license:bsd-3)))
+
(define-public ghc-prettyclass
(package
(name "ghc-prettyclass")
@@ -191,6 +7598,219 @@ provides the pretty printing class and instances for the Prelude
types.")
(license license:bsd-3)))
+(define-public ghc-pretty-hex
+ (package
+ (name "ghc-pretty-hex")
+ (version "1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "pretty-hex-" version "/"
+ "pretty-hex-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0ylwkvvjvmpprha9nx83xb8gkhyanhk5fffc0r7lb96n4ch5z6pz"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/GaloisInc/hexdump")
+ (synopsis "Haskell library for hex dumps of ByteStrings")
+ (description "This Haskell library generates pretty hex dumps of
+ByteStrings in the style of other common *nix hex dump tools.")
+ (license license:bsd-3)))
+
+(define-public ghc-pretty-show
+ (package
+ (name "ghc-pretty-show")
+ (version "1.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/pretty-show/"
+ "pretty-show-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0br7pkxqqqhby2j2v1g847lgqsrasx56g1jw3dhmjh4flzs6warq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-haskell-lexer" ,ghc-haskell-lexer)
+ ("ghc-happy" ,ghc-happy)))
+ (home-page "http://wiki.github.com/yav/pretty-show")
+ (synopsis "Tools for working with derived `Show` instances")
+ (description
+ "This package provides a library and an executable for working with
+derived @code{Show} instances. By using the library, derived @code{Show}
+instances can be parsed into a generic data structure. The @code{ppsh} tool
+uses the library to produce human-readable versions of @code{Show} instances,
+which can be quite handy for debugging Haskell programs. We can also render
+complex generic values into an interactive Html page, for easier
+examination.")
+ (license license:expat)))
+
+(define-public ghc-primitive
+ (package
+ (name "ghc-primitive")
+ (version "0.6.4.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/primitive/primitive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0r0cda7acvplgwaxy69kviv4jp7kkfi038by68gj4yfx4iwszgjc"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/haskell/primitive")
+ (synopsis "Primitive memory-related operations")
+ (description
+ "This package provides various primitive memory-related operations.")
+ (license license:bsd-3)))
+
+(define-public ghc-profunctors
+ (package
+ (name "ghc-profunctors")
+ (version "5.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/profunctors/profunctors-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0s1pwjidbn761xk43pmzyvn99hm3psdifjd78ylki7f97aiyd0g9"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "1ywlg9z8nlhd2avgb8c6gbkv8zyk7hvc25926bafyg0m0k8y1amq")))
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-tagged" ,ghc-tagged)))
+ (home-page "https://github.com/ekmett/profunctors/")
+ (synopsis "Profunctors for Haskell")
+ (description "This library provides profunctors for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-psqueues
+ (package
+ (name "ghc-psqueues")
+ (version "0.2.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "psqueues-" version "/"
+ "psqueues-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1sjgc9bxh63kkdp59nbirx3xazr02ia5yhp4f4a0jnq1hj465wsc"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/jaspervdj/psqueues")
+ (synopsis "Pure priority search queues")
+ (description "The psqueues package provides
+@uref{https://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in
+three different flavors:
+
+@itemize
+@item @code{OrdPSQ k p v}, which uses the @code{Ord k} instance to provide
+fast insertion, deletion and lookup. This implementation is based on Ralf
+Hinze's @uref{http://citeseer.ist.psu.edu/hinze01simple.html, A Simple
+Implementation Technique for Priority Search Queues}.
+
+Hence, it is similar to the @uref{https://hackage.haskell.org/package/PSQueue,
+PSQueue} library, although it is considerably faster and provides a slightly
+different API.
+
+@item @code{IntPSQ p v} is a far more efficient implementation. It fixes the
+key type to @code{Int} and uses a
+@code{https://en.wikipedia.org/wiki/Radix_tree, radix tree} (like @code{IntMap})
+with an additional min-heap property.
+
+@item @code{HashPSQ k p v} is a fairly straightforward extension
+of @code{IntPSQ}: it simply uses the keys' hashes as indices in the
+@code{IntPSQ}. If there are any hash collisions, it uses an
+@code{OrdPSQ} to resolve those. The performance of this implementation
+is comparable to that of @code{IntPSQ}, but it is more widely
+applicable since the keys are not restricted to @code{Int},
+but rather to any @code{Hashable} datatype.
+@end itemize
+
+Each of the three implementations provides the same API, so they can
+be used interchangeably.
+
+Typical applications of Priority Search Queues include:
+
+@itemize
+@item Caches, and more specifically LRU Caches;
+@item Schedulers;
+@item Pathfinding algorithms, such as Dijkstra's and A*.
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public ghc-random
+ (package
+ (name "ghc-random")
+ (version "1.1")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/random/random-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/random")
+ (synopsis "Random number library")
+ (description "This package provides a basic random number generation
+library, including the ability to split random number generators.")
+ (license license:bsd-3)))
+
+(define-public ghc-raw-strings-qq
+ (package
+ (name "ghc-raw-strings-qq")
+ (version "1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "raw-strings-qq/raw-strings-qq-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1lxy1wy3awf52968iy5y9r5z4qgnn2sxkdrh7js3m9gadb11w09f"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/23Skidoo/raw-strings-qq")
+ (synopsis "Raw string literals for Haskell")
+ (description
+ "This package provides a quasiquoter for raw string literals, i.e. string
+literals that don't recognise the standard escape sequences. Basically, they
+make your code more readable by freeing you from the responsibility to escape
+backslashes. They are useful when working with regular expressions,
+DOS/Windows paths and markup languages (such as XML).")
+ (license license:bsd-3)))
+
(define-public ghc-readable
(package
(name "ghc-readable")
@@ -211,6 +7831,2084 @@ reading data types from @code{ByteString} and @code{Text}. It also
includes efficient implementations for common data types.")
(license license:bsd-3)))
+(define-public ghc-rebase
+ (package
+ (name "ghc-rebase")
+ (version "1.2.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "rebase-" version "/"
+ "rebase-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1gah2qwfpzwamnikbc5h4nv6dgvv9h16di9ka7946za3nibyasya"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-uuid" ,ghc-uuid)
+ ("ghc-dlist" ,ghc-dlist)
+ ("ghc-void" ,ghc-void)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-contravariant-extras" ,ghc-contravariant-extras)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-either" ,ghc-either)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-base-prelude" ,ghc-base-prelude)))
+ (home-page "https://github.com/nikita-volkov/rebase")
+ (synopsis "Progressive alternative to the base package
+for Haskell")
+ (description "This Haskell package is intended for those who are
+tired of keeping long lists of dependencies to the same essential libraries
+in each package as well as the endless imports of the same APIs all over again.
+
+It also supports the modern tendencies in the language.
+
+To solve those problems this package does the following:
+
+@itemize
+@item Reexport the original APIs under the @code{Rebase} namespace.
+
+@item Export all the possible non-conflicting symbols from the
+@code{Rebase.Prelude} module.
+
+@item Give priority to the modern practices in the conflicting cases.
+@end itemize
+
+The policy behind the package is only to reexport the non-ambiguous and
+non-controversial APIs, which the community has obviously settled on.
+The package is intended to rapidly evolve with the contribution from
+the community, with the missing features being added with pull-requests.")
+ (license license:expat)))
+
+(define-public ghc-reducers
+ (package
+ (name "ghc-reducers")
+ (version "3.12.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/reducers/reducers-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "09wf8pl9ycglcv6qj5ba26gkg2s5iy81hsx9xp0q8na0cwvp71ki"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-fingertree" ,ghc-fingertree)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://github.com/ekmett/reducers/")
+ (synopsis "Semigroups, specialized containers and a general map/reduce framework")
+ (description "This library provides various semigroups, specialized
+containers and a general map/reduce framework for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-refact
+ (package
+ (name "ghc-refact")
+ (version "0.3.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "refact/refact-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/refact")
+ (synopsis "Specify refactorings to perform with apply-refact")
+ (description
+ "This library provides a datatype which can be interpreted by
+@code{apply-refact}. It exists as a separate library so that applications can
+specify refactorings without depending on GHC.")
+ (license license:bsd-3)))
+
+(define-public ghc-reflection
+ (package
+ (name "ghc-reflection")
+ (version "2.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/reflection/reflection-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0kf4a5ijw6jfnfibjcrpdy9vzh1n6v2pxia8dhyyqdissiwc8bzj"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-tagged" ,ghc-tagged)))
+ (home-page "https://github.com/ekmett/reflection")
+ (synopsis "Reify arbitrary terms into types that can be reflected back
+into terms")
+ (description "This package addresses the 'configuration problem' which is
+propagating configurations that are available at run-time, allowing multiple
+configurations to coexist without resorting to mutable global variables or
+@code{System.IO.Unsafe.unsafePerformIO}.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex
+ (package
+ (name "ghc-regex")
+ (version "1.0.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/regex/"
+ "regex-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'relax-dependencies
+ (lambda _
+ (substitute* "regex.cabal"
+ (("base-compat.*>=.*0.6.*")
+ "base-compat >= 0.6\n")
+ (("template-haskell.*>=.*2.7.*")
+ "template-haskell >= 2.7\n"))
+ #t)))))
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
+ ("ghc-regex-tdfa" ,ghc-regex-tdfa)
+ ("ghc-regex-tdfa-text" ,ghc-regex-tdfa-text)
+ ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-utf8-string" ,ghc-utf8-string)))
+ (home-page "http://regex.uk")
+ (synopsis "Toolkit for regex-base")
+ (description
+ "This package provides a regular expression toolkit for @code{regex-base}
+with compile-time checking of regular expression syntax, data types for
+matches and captures, a text replacement toolkit, portable options, high-level
+AWK-like tools for building text processing apps, regular expression macros
+with parsers and test bench, comprehensive documentation, tutorials and
+copious examples.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-applicative
+ (package
+ (name "ghc-regex-applicative")
+ (version "0.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-applicative/"
+ "regex-applicative-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1riv7jqf26lbv4rm54sd6mrx8xdh4dvh4xbzymzdfdw13k6a4nb6"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/feuerbach/regex-applicative")
+ (synopsis "Regex-based parsing with applicative interface")
+ (description
+ "@code{regex-applicative} is a Haskell library for parsing using
+regular expressions. Parsers can be built using Applicative interface.")
+ (license license:expat)))
+
+(define-public ghc-regex-base
+ (package
+ (name "ghc-regex-base")
+ (version "0.93.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-base/regex-base-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://sourceforge.net/projects/lazy-regex")
+ (synopsis "Replaces/Enhances Text.Regex")
+ (description "@code{Text.Regex.Base} provides the interface API for
+regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-compat
+ (package
+ (name "ghc-regex-compat")
+ (version "0.95.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-compat/regex-compat-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-posix" ,ghc-regex-posix)))
+ (home-page "https://sourceforge.net/projects/lazy-regex")
+ (synopsis "Replaces/Enhances Text.Regex")
+ (description "This library provides one module layer over
+@code{regex-posix} to replace @code{Text.Regex}.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-compat-tdfa
+ (package
+ (name "ghc-regex-compat-tdfa")
+ (version "0.95.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-compat-tdfa/regex-compat-tdfa-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
+ (home-page "https://hub.darcs.net/shelarcy/regex-compat-tdfa")
+ (synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
+ (description
+ "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
+@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
+This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
+this problem.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-pcre-builtin
+ (package
+ (name "ghc-regex-pcre-builtin")
+ (version "0.94.4.8.8.35")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "regex-pcre-builtin/regex-pcre-builtin-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)))
+ (home-page "https://hackage.haskell.org/package/regex-pcre")
+ (synopsis "Enhancement of the builtin Text.Regex library")
+ (description
+ "This package is an enhancement of the @code{Text.Regex} library,
+providing the PCRE backend to accompany regex-base, with bundled code from
+@url{https://www.pcre.org}.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-posix
+ (package
+ (name "ghc-regex-posix")
+ (version "0.95.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-posix/regex-posix-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)))
+ (home-page "https://sourceforge.net/projects/lazy-regex")
+ (synopsis "POSIX regular expressions for Haskell")
+ (description "This library provides the POSIX regex backend used by the
+Haskell library @code{regex-base}.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-tdfa
+ (package
+ (name "ghc-regex-tdfa")
+ (version "1.2.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-tdfa/regex-tdfa-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0l7ajnh4hpgggf2a1r9dg0hx2fy679vd2kada5y7r02hy3nfxala"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)))
+ (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
+ (synopsis "POSIX extended regular expressions in Haskell.")
+ (description
+ "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
+extended regular expressions. It is a \"tagged\" DFA regex engine. It is
+inspired by libtre.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-tdfa-text
+ (package
+ (name "ghc-regex-tdfa-text")
+ (version "1.0.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-tdfa-text/"
+ "regex-tdfa-text-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0090g6lgbdm9lywpqm2d3724nnnh24nx3vnlqr96qc2w486pmmrq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
+ (home-page
+ "http://hackage.haskell.org/package/regex-tdfa-text")
+ (synopsis "Text interface for regex-tdfa")
+ (description
+ "This provides an extra text interface for regex-tdfa.")
+ (license license:bsd-3)))
+
+(define-public ghc-rerebase
+ (package
+ (name "ghc-rerebase")
+ (version "1.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/rerebase/rerebase-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "11v6rmz7ql2rdx6mhb3lsal952lwihclfhh0m7fcnii5br0906ks"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-rebase" ,ghc-rebase)))
+ (home-page "https://github.com/nikita-volkov/rerebase")
+ (synopsis "Reexports from ``base'' with many other standard libraries")
+ (description "A rich drop-in replacement for @code{base}. For details and
+documentation please visit @uref{https://github.com/nikita-volkov/rerebase,
+the project's home page}.")
+ (license license:expat)))
+
+(define-public ghc-resolv
+ (package
+ (name "ghc-resolv")
+ (version "0.1.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/resolv/resolv-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0wh7wj56l3f2bylz563g5g04a4nydj8acv60hpwa7k3mn792xca9"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "15ay4n3x8c09cb3h4z1nan84yd3n9zpgvi6h114hk98bq10k8mma")
+ #:tests? #f)) ; The required test frameworks are too old.
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)))
+ (home-page "https://github.com/haskell/hackage-security")
+ (synopsis "Domain Name Service (DNS) lookup via @code{libresolv}")
+ (description "This package implements an API for accessing the
+@uref{https://tools.ietf.org/html/rfc1035, Domain Name Service (DNS)}
+resolver service via the standard @code{libresolv} system library (whose
+API is often available directly via the standard @code{libc} C library) on
+Unix systems.")
+ (license license:gpl3)))
+
+(define-public ghc-resource-pool
+ (package
+ (name "ghc-resource-pool")
+ (version "0.2.3.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "resource-pool-" version "/"
+ "resource-pool-" version ".tar.gz"))
+ (sha256
+ (base32
+ "04mw8b9djb14zp4rdi6h7mc3zizh597ffiinfbr4m0m8psifw9w6"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/bos/pool")
+ (synopsis "Striped resource pooling implementation in Haskell")
+ (description "This Haskell package provides striped pooling abstraction
+for managing flexibly-sized collections of resources such as database
+connections.")
+ (license license:bsd-3)))
+
+(define-public ghc-resourcet
+ (package
+ (name "ghc-resourcet")
+ (version "1.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/resourcet/"
+ "resourcet-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0rzjzh34s36ssign7akqjnwnjxf11c3511wk7ky0xxy0dqmc2rg7"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-mmorph" ,ghc-mmorph)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)))
+ (native-inputs
+ `(("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/snoyberg/conduit")
+ (synopsis "Deterministic allocation and freeing of scarce resources")
+ (description "ResourceT is a monad transformer which creates a region of
+code where you can safely allocate resources.")
+ (license license:bsd-3)))
+
+(define-public ghc-rfc5051
+ (package
+ (name "ghc-rfc5051")
+ (version "0.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/rfc5051/"
+ "rfc5051-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/rfc5051")
+ (synopsis "Simple unicode collation as per RFC5051")
+ (description
+ "This library implements @code{unicode-casemap}, the simple, non
+locale-sensitive unicode collation algorithm described in RFC 5051. Proper
+unicode collation can be done using @code{text-icu}, but that is a big
+dependency that depends on a large C library, and @code{rfc5051} might be
+better for some purposes.")
+ (license license:bsd-3)))
+
+(define-public ghc-rio
+ (package
+ (name "ghc-rio")
+ (version "0.1.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/rio/rio-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "064h8a4hp53a479d3ak0vmqbx8hi0cpg7zn4wp23rjy26dka8p7g"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-microlens" ,ghc-microlens)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-typed-process" ,ghc-typed-process)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/commercialhaskell/rio#readme")
+ (synopsis "A standard library for Haskell")
+ (description "This package works as a prelude replacement for Haskell,
+providing more functionality and types out of the box than the standard
+prelude (such as common data types like @code{ByteString} and
+@code{Text}), as well as removing common ``gotchas'', like partial
+functions and lazy I/O. The guiding principle here is:
+@itemize
+@item If something is safe to use in general and has no expected naming
+conflicts, expose it.
+@item If something should not always be used, or has naming conflicts,
+expose it from another module in the hierarchy.
+@end itemize")
+ (license license:expat)))
+
+(define-public ghc-safe
+ (package
+ (name "ghc-safe")
+ (version "0.3.17")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/safe/safe-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0p3yaf5slvyz1cyy51jq64c5rlp8yzwim8iy2dlnk42if4gc9ibr"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/ndmitchell/safe#readme")
+ (synopsis "Library of safe (exception free) functions")
+ (description "This library provides wrappers around @code{Prelude} and
+@code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
+exceptions.")
+ (license license:bsd-3)))
+
+(define-public ghc-safe-exceptions
+ (package
+ (name "ghc-safe-exceptions")
+ (version "0.1.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "safe-exceptions/safe-exceptions-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0sd0zfsm9pcll5bzzj523rbn45adjrnavdkz52hgmdjjgdcdrk8q"))))
+ (build-system haskell-build-system)
+ (arguments
+ '(#:cabal-revision
+ ("4" "0fid41gishzsyb47wzxhd5falandfirqcp760hcja81qjpfmqd32")))
+ (inputs `(("ghc-exceptions" ,ghc-exceptions)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-void" ,ghc-void)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/fpco/safe-exceptions")
+ (synopsis "Safe, consistent, and easy exception handling")
+ (description "Runtime exceptions - as exposed in @code{base} by the
+@code{Control.Exception} module - have long been an intimidating part of the
+Haskell ecosystem. This package is intended to overcome this. It provides a
+safe and simple API on top of the existing exception handling machinery. The
+API is equivalent to the underlying implementation in terms of power but
+encourages best practices to minimize the chances of getting the exception
+handling wrong.")
+ (license license:expat)))
+
+(define-public ghc-safeio
+ (package
+ (name "ghc-safeio")
+ (version "0.0.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/safeio/"
+ "safeio-" version ".tar.gz"))
+ (sha256
+ (base32
+ "04g3070cbjdqj0h9l9ii6470xcbn40xfv4fr89a8yvnkdim9nyfm"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-combinators" ,ghc-conduit-combinators)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-resourcet" ,ghc-resourcet)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("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/safeio")
+ (synopsis "Write output to disk atomically")
+ (description
+ "This package implements utilities to perform atomic output so as to
+avoid the problem of partial intermediate files.")
+ (license license:expat)))
+
+(define-public ghc-safesemaphore
+ (package
+ (name "ghc-safesemaphore")
+ (version "0.10.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "SafeSemaphore/SafeSemaphore-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/ChrisKuklewicz/SafeSemaphore")
+ (synopsis "Exception safe semaphores")
+ (description "This library provides exception safe semaphores that can be
+used in place of @code{QSem}, @code{QSemN}, and @code{SampleVar}, all of which
+are not exception safe and can be broken by @code{killThread}.")
+ (license license:bsd-3)))
+
+(define-public ghc-sandi
+ (package
+ (name "ghc-sandi")
+ (version "0.4.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/sandi/sandi-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0dvkpk91n9kz2ha04rvp231ra9sgd1ilyc1qkzf9l03iir7zrh9b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-stringsearch" ,ghc-stringsearch)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-th" ,ghc-tasty-th)))
+ (home-page "https://hackage.haskell.org/package/sandi")
+ (synopsis "Data encoding library")
+ (description "Reasonably fast data encoding library.")
+ (license license:bsd-3)))
+
+(define-public ghc-scientific
+ (package
+ (name "ghc-scientific")
+ (version "0.3.6.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/scientific/scientific-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "03ql2f0ac8bsl524idy9xxa3kxisb2sj3avflzw580j5hzy0m397"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-integer-logarithms" ,ghc-integer-logarithms)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-primitive" ,ghc-primitive)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/basvandijk/scientific")
+ (synopsis "Numbers represented using scientific notation")
+ (description "This package provides @code{Data.Scientific}, which provides
+the number type @code{Scientific}. Scientific numbers are arbitrary precision
+and space efficient. They are represented using
+@uref{https://en.wikipedia.org/wiki/Scientific_notation, scientific
+notation}.")
+ (license license:bsd-3)))
+
+(define-public ghc-scientific-bootstrap
+ (package
+ (inherit ghc-scientific)
+ (name "ghc-scientific-bootstrap")
+ (arguments `(#:tests? #f))
+ (inputs
+ `(("ghc-integer-logarithms" ,ghc-integer-logarithms-bootstrap)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-primitive" ,ghc-primitive)))
+ (native-inputs '())
+ (properties '(hidden? #t))))
+
+(define-public ghc-sdl
+ (package
+ (name "ghc-sdl")
+ (version "0.6.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/SDL/SDL-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "00y67v80a8l09i3k76z09lg25kw72ivl09nag8ckdlk4a0cfnzfq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("sdl" ,sdl)))
+ (home-page "https://hackage.haskell.org/package/SDL")
+ (synopsis "LibSDL for Haskell")
+ (description "Simple DirectMedia Layer (libSDL) is a cross-platform
+multimedia library designed to provide low level access to audio, keyboard,
+mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
+by MPEG playback software, emulators, and many popular games, including the
+award winning Linux port of \"Civilization: Call To Power.\"")
+ (license license:bsd-3)))
+
+(define-public ghc-sdl-image
+ (package
+ (name "ghc-sdl-image")
+ (version "0.6.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/SDL-image/SDL-image-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1gxwrvswgwjw6g7ym52gik22l9l3ljy592phv97jdmcf3gi6qcg1"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags
+ (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
+ (sdl-image-include (string-append sdl-image "/include/SDL")))
+ (list (string-append "--extra-include-dirs=" sdl-image-include)))))
+ (inputs
+ `(("ghc-sdl" ,ghc-sdl)
+ ("sdl-image" ,sdl-image)))
+ (home-page "https://hackage.haskell.org/package/SDL-image")
+ (synopsis "Haskell bindings to libSDL_image")
+ (description "SDL_image is an image file loading library. It loads images
+as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
+PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
+ (license license:bsd-3)))
+
+(define-public ghc-sdl-mixer
+ (package
+ (name "ghc-sdl-mixer")
+ (version "0.6.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0k26hqgdh789ka3mv4dsk6rin6x6vwcs6hjmnsqq7j3mnrh1342r"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags
+ (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
+ (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
+ (list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
+ (inputs
+ `(("ghc-sdl" ,ghc-sdl)
+ ("sdl-mixer" ,sdl-mixer)))
+ (home-page "https://hackage.haskell.org/package/SDL-mixer")
+ (synopsis "Haskell bindings to libSDL_mixer")
+ (description "SDL_mixer is a sample multi-channel audio mixer library. It
+supports any number of simultaneously playing channels of 16 bit stereo audio,
+plus a single channel of music, mixed by the popular MikMod MOD, Timidity
+MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
+ (license license:bsd-3)))
+
+(define-public ghc-securemem
+ (package
+ (name "ghc-securemem")
+ (version "0.1.10")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "securemem-" version "/"
+ "securemem-" version ".tar.gz"))
+ (sha256
+ (base32
+ "19hnw2cfbsfjynxq1bq9f6djbxhsc1k751ml0y1ab3ah913mm29j"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-memory" ,ghc-memory)))
+ (home-page "https://github.com/vincenthz/hs-securemem")
+ (synopsis "Auto-scrubbing and const-time-eq memory chunk abstraction for
+Haskell")
+ (description "SecureMem is similar to ByteString, except that it provides
+a memory chunk that will be auto-scrubbed after it run out of scope.")
+ (license license:bsd-3)))
+
+(define-public ghc-semigroupoids
+ (package
+ (name "ghc-semigroupoids")
+ (version "5.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/semigroupoids/semigroupoids-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "17i96y4iqj8clcs090lf6k0ij3j16nj14vsfwz0mm9nd6i4gbpp4"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("4" "0pqfrxzypjq6z8lgdkzq4vhcyqkpk5326hny0r6snpc3gm78r4ij")))
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-contravariant" ,ghc-contravariant)
+ ("ghc-distributive" ,ghc-distributive)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)))
+ (home-page "https://github.com/ekmett/semigroupoids")
+ (synopsis "Semigroupoids operations for Haskell")
+ (description "This library provides a wide array of (semi)groupoids and
+operations for working with them. A @code{Semigroupoid} is a @code{Category}
+without the requirement of identity arrows for every object in the category.
+A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
+Finally, to work with these weaker structures it is beneficial to have
+containers that can provide stronger guarantees about their contents, so
+versions of @code{Traversable} and @code{Foldable} that can be folded with
+just a @code{Semigroup} are added.")
+ (license license:bsd-3)))
+
+(define-public ghc-semigroups
+ (package
+ (name "ghc-semigroups")
+ (version "0.18.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/semigroups/semigroups-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "17g29h62g1k51ghhvzkw72zksjgi6vs6bfipkj81pqw1dsprcamb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-nats" ,ghc-nats)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-hashable" ,ghc-hashable)))
+ (home-page "https://github.com/ekmett/semigroups/")
+ (synopsis "Semigroup operations for Haskell")
+ (description "This package provides semigroups for Haskell. In
+mathematics, a semigroup is an algebraic structure consisting of a set
+together with an associative binary operation. A semigroup generalizes a
+monoid in that there might not exist an identity element. It
+also (originally) generalized a group (a monoid with all inverses) to a type
+where every element did not have to have an inverse, thus the name
+semigroup.")
+ (license license:bsd-3)))
+
+(define-public ghc-semigroups-bootstrap
+ (package
+ (inherit ghc-semigroups)
+ (name "ghc-semigroups-bootstrap")
+ (inputs
+ `(("ghc-nats" ,ghc-nats-bootstrap)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-unordered-containers" ,ghc-unordered-containers-bootstrap)
+ ("ghc-hashable" ,ghc-hashable-bootstrap)))
+ (properties '(hidden? #t))))
+
+(define-public ghc-setenv
+ (package
+ (name "ghc-setenv")
+ (version "0.1.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/setenv/setenv-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/setenv")
+ (synopsis "Library for setting environment variables")
+ (description "This package provides a Haskell library for setting
+environment variables.")
+ (license license:expat)))
+
+(define-public ghc-setlocale
+ (package
+ (name "ghc-setlocale")
+ (version "1.0.0.8")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/setlocale-"
+ version "/setlocale-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0sdrsmkhw08483d73ysgm2926fdbhii61br03lqpqw0lfzj4ilbd"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/setlocale")
+ (synopsis "Haskell bindings to setlocale")
+ (description "This package provides Haskell bindings to the
+@code{setlocale} C function.")
+ (license license:bsd-3)))
+
+(define-public ghc-shakespeare
+ (package
+ (name "ghc-shakespeare")
+ (version "2.0.15")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "shakespeare-" version "/"
+ "shakespeare-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1vk4b19zvwy4mpwaq9z3l3kfmz75gfyf7alhh0y112gspgpccm23"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-scientific" ,ghc-scientific)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://www.yesodweb.com/book/shakespearean-templates")
+ (synopsis "Family of type-safe template languages for Haskell")
+ (description "This Haskell package provides a family of type-safe
+templates with simple variable interpolation. Shakespeare templates can
+be used inline with a quasi-quoter or in an external file and it
+interpolates variables according to the type being inserted.")
+ (license license:expat)))
+
+(define-public ghc-shelly
+ (package
+ (name "ghc-shelly")
+ (version "1.8.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/shelly/shelly-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "023fbvbqs5gdwm30j5517gbdcc7fvz0md70dgwgpypkskj3i926y"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
+ ("ghc-system-fileio-bootstrap" ,ghc-system-fileio-bootstrap)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-lifted-async" ,ghc-lifted-async)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
+ ("ghc-async" ,ghc-async)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-contrib" ,ghc-hspec-contrib)))
+ (home-page "https://github.com/yesodweb/Shelly.hs")
+ (synopsis "Shell-like (systems) programming in Haskell")
+ (description
+ "Shelly provides convenient systems programming in Haskell, similar in
+spirit to POSIX shells. Shelly is originally forked from the Shellish package.")
+ (license license:bsd-3)))
+
+(define-public ghc-silently
+ (package
+ (name "ghc-silently")
+ (version "1.2.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/silently/silently-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ;; circular dependency with nanospec
+ ;; (inputs
+ ;; `(("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/hspec/silently")
+ (synopsis "Prevent writing to stdout")
+ (description "This package provides functions to prevent or capture
+writing to stdout and other handles.")
+ (license license:bsd-3)))
+
+(define-public ghc-simple-reflect
+ (package
+ (name "ghc-simple-reflect")
+ (version "0.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/simple-reflect/simple-reflect-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0ayvrx5cm8n6db21jiyjmk5h93pw7cz1707hih09hlhk9jh5x0h7"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
+ (synopsis
+ "Simple reflection of expressions containing variables")
+ (description
+ "This package allows simple reflection of expressions containing
+variables. Reflection here means that a Haskell expression is turned into a
+string. The primary aim of this package is teaching and understanding; there
+are no options for manipulating the reflected expressions beyond showing
+them.")
+ (license license:bsd-3)))
+
+(define-public ghc-simple-sendfile
+ (package
+ (name "ghc-simple-sendfile")
+ (version "0.2.27")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "simple-sendfile-" version "/"
+ "simple-sendfile-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1bwwqzcm56m2w4ymsa054sxmpbj76h9pvb0jf8zxp8lr41cp51gn"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-network" ,ghc-network)
+ ("ghc-resourcet" ,ghc-resourcet)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/kazu-yamamoto/simple-sendfile")
+ (synopsis "Cross platform library for the sendfile system call")
+ (description "This library tries to call minimum system calls which
+are the bottleneck of web servers.")
+ (license license:bsd-3)))
+
+(define-public ghc-skylighting-core
+ (package
+ (name "ghc-skylighting-core")
+ (version "0.7.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "skylighting-core/skylighting-core-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "066fwmwsd7xcvwlinfk2izlzq0xp8697i6lnbgsbl71jdybyackq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-hxt" ,ghc-hxt)
+ ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-utf8-string" ,ghc-utf8-string)))
+ (native-inputs
+ `(("ghc-diff" ,ghc-diff)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-pretty-show" ,ghc-pretty-show)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/jgm/skylighting")
+ (synopsis "Syntax highlighting library")
+ (description "Skylighting is a syntax highlighting library with support
+for over one hundred languages. It derives its tokenizers from XML syntax
+definitions used by KDE's @code{KSyntaxHighlighting} framework, so any syntax
+supported by that framework can be added. An optional command-line program is
+provided. Skylighting is intended to be the successor to highlighting-kate.")
+ (license license:gpl2)))
+
+(define-public ghc-skylighting
+ (package
+ (inherit ghc-skylighting-core)
+ (name "ghc-skylighting")
+ (version "0.7.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/skylighting-"
+ version "/skylighting-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1rh3z1a7a4clvksdw1qlpmhxqkfahwypi70k91whgfamzsqpxdch"))))
+ (inputs
+ `(("ghc-skylighting-core" ,ghc-skylighting-core)
+ ,@(package-inputs ghc-skylighting-core)))))
+
+(define-public ghc-smallcheck
+ (package
+ (name "ghc-smallcheck")
+ (version "1.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/smallcheck/smallcheck-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "195fj7w3v03d1y1nm2ylavzrwxjcdbq0lb6zsw1dwyx5jmwfc84h"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-logict" ,ghc-logict)))
+ (home-page
+ "https://github.com/feuerbach/smallcheck")
+ (synopsis "Property-based testing library")
+ (description "SmallCheck is a testing library that allows to verify
+properties for all test cases up to some depth. The test cases are generated
+automatically by SmallCheck.")
+ (license license:bsd-3)))
+
+(define-public ghc-socks
+ (package
+ (name "ghc-socks")
+ (version "0.5.6")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "socks/socks-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0f44qy74i0n6ll3jym0a2ipafkpw1h67amcpqmj8iq95h21wsqzs"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-cereal" ,ghc-cereal)
+ ("ghc-network" ,ghc-network)))
+ (home-page "https://github.com/vincenthz/hs-socks")
+ (synopsis "SOCKS proxy (version 5) implementation")
+ (description
+ "This library provides a SOCKS proxy (version 5) implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-split
+ (package
+ (name "ghc-split")
+ (version "0.2.3.3")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/split/split-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "04qlmkcyklznl03gsjg95b4nzb6i96gdapqg60rny9szgi7ngk8x"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/split")
+ (synopsis "Combinator library for splitting lists")
+ (description "This package provides a collection of Haskell functions for
+splitting lists into parts, akin to the @code{split} function found in several
+mainstream languages.")
+ (license license:bsd-3)))
+
+(define-public ghc-statevar
+ (package
+ (name "ghc-statevar")
+ (version "1.1.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/StateVar/StateVar-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "08r2iw0gdmfs4f6wraaq19vfmkjdbics3dbhw39y7mdjd98kcr7b"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/StateVar")
+ (synopsis "State variables for Haskell")
+ (description "This package provides state variables, which are references
+in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
+ (license license:bsd-3)))
+
+(define-public ghc-statistics
+ (package
+ (name "ghc-statistics")
+ (version "0.14.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "statistics-" version "/"
+ "statistics-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0y27gafkib0x0fn39qfn2rkgsfrm09ng35sbb5dwr7rclhnxz59l"))))
+ (build-system haskell-build-system)
+ (arguments
+ '(#:cabal-revision
+ ("2" "1bx70yqkn62ii17fjv3pig4hklrzkqd09zj67zzjiyjzmn04fir3")
+ ;; Two tests fail: "Discrete CDF is OK" and "Quantile is CDF inverse".
+ #:tests? #f))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-base-orphans" ,ghc-base-orphans)
+ ("ghc-erf" ,ghc-erf)
+ ("ghc-math-functions" ,ghc-math-functions)
+ ("ghc-monad-par" ,ghc-monad-par)
+ ("ghc-mwc-random" ,ghc-mwc-random)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-vector-algorithms" ,ghc-vector-algorithms)
+ ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)
+ ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-ieee754" ,ghc-ieee754)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/bos/mwc-random")
+ (synopsis "Haskell library of statistical types, data, and functions")
+ (description "This library provides a number of common functions
+and types useful in statistics. We focus on high performance, numerical
+robustness, and use of good algorithms. Where possible, we provide references
+to the statistical literature.
+
+The library's facilities can be divided into four broad categories:
+
+@itemize
+@item Working with widely used discrete and continuous probability
+distributions. (There are dozens of exotic distributions in use; we focus
+on the most common.)
+
+@item Computing with sample data: quantile estimation, kernel density
+estimation, histograms, bootstrap methods, significance testing,
+and regression and autocorrelation analysis.
+
+@item Random variate generation under several different distributions.
+
+@item Common statistical tests for significant differences between samples.
+@end itemize")
+ (license license:bsd-2)))
+
+(define-public ghc-stm-chans
+ (package
+ (name "ghc-stm-chans")
+ (version "3.0.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "stm-chans-" version "/"
+ "stm-chans-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0f27sp09yha43xk9q55sc185jyjs5h7gq2dhsyx6bm9kz9dzqi13"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/stm-chans")
+ (synopsis "Additional types of channels for ghc-stm")
+ (description "This Haskell package offers a collection of channel types,
+similar to @code{Control.Concurrent.STM.@{TChan,TQueue@}} but with additional
+features.")
+ (license license:bsd-3)))
+
+(define-public ghc-stm-conduit
+ (package
+ (name "ghc-stm-conduit")
+ (version "4.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/stm-conduit/"
+ "stm-conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-stm-chans" ,ghc-stm-chans)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-cereal-conduit" ,ghc-cereal-conduit)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-async" ,ghc-async)
+ ("ghc-monad-loops" ,ghc-monad-loops)
+ ("ghc-unliftio" ,ghc-unliftio)))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/cgaebel/stm-conduit")
+ (synopsis "Introduces conduits to channels and promotes using conduits concurrently")
+ (description
+ "This package provides two simple conduit wrappers around STM channels: a
+source and a sink.")
+ (license license:bsd-3)))
+
+(define-public ghc-stmonadtrans
+ (package
+ (name "ghc-stmonadtrans")
+ (version "0.4.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/STMonadTrans"
+ "/STMonadTrans-" version ".tar.gz"))
+ (sha256
+ (base32 "1nr26fnmi5fdjc6d00w13kjhmfyvb5b837d0006w4dj0yxndaksp"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/STMonadTrans")
+ (synopsis "Monad transformer version of the ST monad")
+ (description
+ "This package provides a monad transformer version of the @code{ST} monad
+for strict state threads.")
+ (license license:bsd-3)))
+
+(define-public ghc-storable-complex
+ (package
+ (name "ghc-storable-complex")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/storable-complex/storable-complex-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/cartazio/storable-complex")
+ (synopsis "Haskell Storable instance for Complex")
+ (description "This package provides a Haskell library including a
+Storable instance for Complex which is binary compatible with C99, C++
+and Fortran complex data types.")
+ (license license:bsd-3)))
+
+(define-public ghc-streaming-commons
+ (package
+ (name "ghc-streaming-commons")
+ (version "0.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "streaming-commons/streaming-commons-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1lmyx3wkjsayhy5yilzvy0kf8qwmycwlk26r1d8f3cxbfhkr7s52"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-network" ,ghc-network)
+ ("ghc-random" ,ghc-random)
+ ("ghc-zlib" ,ghc-zlib)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/streaming-commons")
+ (synopsis "Conduit and pipes needed by some streaming data libraries")
+ (description "This package provides low-dependency functionality commonly
+needed by various Haskell streaming data libraries, such as @code{conduit} and
+@code{pipe}s.")
+ (license license:expat)))
+
+(define-public ghc-strict
+ (package
+ (name "ghc-strict")
+ (version "0.3.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/strict/strict-"
+ version ".tar.gz"))
+ (sha256
+ (base32 "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/strict")
+ (synopsis "Strict data types and String IO")
+ (description
+ "This package provides strict versions of some standard Haskell data
+types, such as pairs, @code{Maybe} and @code{Either}. It also contains strict
+IO operations.")
+ (license license:bsd-3)))
+
+(define-public ghc-stringbuilder
+ (package
+ (name "ghc-stringbuilder")
+ (version "0.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/stringbuilder/stringbuilder-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1fh3csx1wcssn8xyvl4ip4aprh9l4qyz2kk8mgjvqvc0vb2bsy6q"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
+ ; enabled
+ (home-page "https://hackage.haskell.org/package/stringbuilder")
+ (synopsis "Writer monad for multi-line string literals")
+ (description "This package provides a writer monad for multi-line string
+literals.")
+ (license license:expat)))
+
+(define-public ghc-string-qq
+ (package
+ (name "ghc-string-qq")
+ (version "0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/string-qq/string-qq-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0662m3i5xrdrr95w829bszkhp88mj9iy1zya54vk2sl5hz9wlmwp"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/string-qq")
+ (synopsis
+ "QuasiQuoter for non-interpolated strings, texts and bytestrings.")
+ (description
+ "This package provides a quasiquoter for non-interpolated strings, texts
+and bytestrings.")
+ (license license:public-domain)))
+
+(define-public ghc-stringsearch
+ (package
+ (name "ghc-stringsearch")
+ (version "0.3.6.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/stringsearch/stringsearch-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
+ (build-system haskell-build-system)
+ (home-page "https://bitbucket.org/dafis/stringsearch")
+ (synopsis "Fast searching, splitting and replacing of ByteStrings")
+ (description "This package provides several functions to quickly search
+for substrings in strict or lazy @code{ByteStrings}. It also provides
+functions for breaking or splitting on substrings and replacing all
+occurrences of a substring (the first in case of overlaps) with another.")
+ (license license:bsd-3)))
+
+(define-public ghc-stylish-haskell
+ (package
+ (name "ghc-stylish-haskell")
+ (version "0.9.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/stylish-haskell/stylish-haskell-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-file-embed" ,ghc-file-embed)
+ ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-yaml" ,ghc-yaml)
+ ("ghc-strict" ,ghc-strict)
+ ("ghc-optparse-applicative"
+ ,ghc-optparse-applicative)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://github.com/jaspervdj/stylish-haskell")
+ (synopsis "Haskell code prettifier")
+ (description "Stylish-haskell is a Haskell code prettifier. The goal is
+not to format all of the code in a file, to avoid \"getting in the way\".
+However, this tool can e.g. clean up import statements and help doing various
+tasks that get tedious very quickly. It can
+@itemize
+@item
+Align and sort @code{import} statements
+@item
+Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant
+pragmas
+@item
+Remove trailing whitespaces
+@item
+Align branches in @code{case} and fields in records
+@item
+Convert line endings (customisable)
+@item
+Replace tabs by four spaces (turned off by default)
+@item
+Replace some ASCII sequences by their Unicode equivalent (turned off by
+default)
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public ghc-syb
+ (package
+ (name "ghc-syb")
+ (version "0.7")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/syb/syb-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1da2zz7gqm4xbkx5vpd74dayx1svaxyl145fl14mq15lbb77sxdq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page
+ "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
+ (synopsis "Scrap Your Boilerplate")
+ (description "This package contains the generics system described in the
+/Scrap Your Boilerplate/ papers (see
+@uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It
+defines the @code{Data} class of types permitting folding and unfolding of
+constructor applications, instances of this class for primitive types, and a
+variety of traversals.")
+ (license license:bsd-3)))
+
+(define-public ghc-system-fileio
+ (package
+ (name "ghc-system-fileio")
+ (version "0.3.16.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-fileio/system-fileio-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-system-filepath" ,ghc-system-filepath)
+ ("ghc-chell" ,ghc-chell)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "Consistent file system interaction across GHC versions")
+ (description
+ "This is a small wrapper around the directory, unix, and Win32 packages,
+for use with system-filepath. It provides a consistent API to the various
+versions of these packages distributed with different versions of GHC.
+In particular, this library supports working with POSIX files that have paths
+which can't be decoded in the current locale encoding.")
+ (license license:expat)))
+
+;; See ghc-system-filepath-bootstrap. In addition this package depends on
+;; ghc-system-filepath.
+(define ghc-system-fileio-bootstrap
+ (package
+ (name "ghc-system-fileio-bootstrap")
+ (version "0.3.16.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-fileio/system-fileio-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f))
+ (inputs
+ `(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "Consistent file system interaction across GHC versions")
+ (description
+ "This is a small wrapper around the directory, unix, and Win32 packages,
+for use with system-filepath. It provides a consistent API to the various
+versions of these packages distributed with different versions of GHC.
+In particular, this library supports working with POSIX files that have paths
+which can't be decoded in the current locale encoding.")
+ (license license:expat)))
+
+
+(define-public ghc-system-filepath
+ (package
+ (name "ghc-system-filepath")
+ (version "0.4.14")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-filepath/system-filepath-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn"))))
+ (build-system haskell-build-system)
+ ;; FIXME: One of the tests fails:
+ ;; [ FAIL ] tests.validity.posix
+ ;; note: seed=7310214548328823169
+ ;; *** Failed! Falsifiable (after 24 tests):
+ ;; FilePath "/r2\ENQ52\t ;$/o\US=/okG\146\&6\n<u\DC3/5\182\223a\DELN\EOT#\NUL/`[m/\USEKV\ETX([)b6/\ACK\SOo\245\ETBO/f\128\STX`|\EM\"/*\EMA\USD3/\143\&4/\CAN?\SUBee\CANR/9/B0\187Kx4/Vqr\232'b:/\a\234\DLE.\"\179/\ENQ{J/|/G)@^\237/\219ml/\DC3pd\ESC"
+ (arguments `(#:tests? #f))
+ (inputs
+ `(("ghc-chell" ,ghc-chell)
+ ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "High-level, byte-based file and directory path manipulations")
+ (description
+ "Provides a FilePath datatype and utility functions for operating on it.
+Unlike the filepath package, this package does not simply reuse String,
+increasing type safety.")
+ (license license:expat)))
+
+;; Ghc-shelly depends on ghc-system-filepath and ghc-system-fileio, who in turn depend on
+;; ghc-chell and ghc-chell-quickcheck for the test phase. Ghc-chell depends on ghc-options
+;; which depends on ghc-chell and ghc-chell-quickcheck.
+;; Therefore we bootstrap it with tests disabled.
+(define ghc-system-filepath-bootstrap
+ (package
+ (name "ghc-system-filepath-bootstrap")
+ (version "0.4.14")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-filepath/system-filepath-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f))
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "High-level, byte-based file and directory path manipulations")
+ (description
+ "Provides a FilePath datatype and utility functions for operating on it.
+Unlike the filepath package, this package does not simply reuse String,
+increasing type safety.")
+ (license license:expat)))
+
+
+(define-public ghc-tagged
+ (package
+ (name "ghc-tagged")
+ (version "0.8.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tagged/tagged-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "16cdzh0bw16nvjnyyy5j9s60malhz4nnazw96vxb0xzdap4m2z74"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "0r2knfcq0b4s652vlvlnfwxlc2mkc2ra9kl8bp4zdn1awmfy0ia5")))
+ (inputs
+ `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://hackage.haskell.org/package/tagged")
+ (synopsis "Haskell phantom types to avoid passing dummy arguments")
+ (description "This library provides phantom types for Haskell 98, to avoid
+having to unsafely pass dummy arguments.")
+ (license license:bsd-3)))
+
+(define-public ghc-tar
+ (package
+ (name "ghc-tar")
+ (version "0.5.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tar/tar-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0s2brvaxg5fki2jdkccmnpssiy6a3wjh24p6a3dkkdvjcixnk7f8"))))
+ (build-system haskell-build-system)
+ ;; FIXME: 2/24 tests fail.
+ (arguments `(#:tests? #f))
+ (inputs
+ `(("ghc-bytestring-handle" ,ghc-bytestring-handle)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/tar")
+ (synopsis "Reading, writing and manipulating \".tar\" archive files")
+ (description
+ "This library is for working with \\\"@.tar@\\\" archive files.
+It can read and write a range of common variations of the tar archive format
+including V7, POSIX USTAR and GNU formats. It provides support for packing and
+unpacking portable archives. This makes it suitable for distribution but not
+backup because details like file ownership and exact permissions are not
+preserved. It also provides features for random access to archive content using
+an index.")
+ (license license:bsd-3)))
+
+(define-public ghc-temporary
+ (package
+ (name "ghc-temporary")
+ (version "1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/temporary/temporary-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "144qhwfwg37l3k313raf4ssiz16jbgwlm1nf4flgqpsbd69jji4c"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-random" ,ghc-random)))
+ (native-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://www.github.com/batterseapower/temporary")
+ (synopsis "Temporary file and directory support")
+ (description "The functions for creating temporary files and directories
+in the Haskelll base library are quite limited. This library just repackages
+the Cabal implementations of its own temporary file and folder functions so
+that you can use them without linking against Cabal or depending on it being
+installed.")
+ (license license:bsd-3)))
+
+(define-public ghc-temporary-rc
+ (package
+ (name "ghc-temporary-rc")
+ (version "1.2.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/temporary-rc/temporary-rc-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-exceptions" ,ghc-exceptions)))
+ (home-page
+ "https://www.github.com/feuerbach/temporary")
+ (synopsis
+ "Portable temporary file and directory support")
+ (description
+ "The functions for creating temporary files and directories in the base
+library are quite limited. The unixutils package contains some good ones, but
+they aren't portable to Windows. This library just repackages the Cabal
+implementations of its own temporary file and folder functions so that you can
+use them without linking against Cabal or depending on it being installed.
+This is a better maintained fork of the \"temporary\" package.")
+ (license license:bsd-3)))
+
+(define-public ghc-terminal-size
+ (package
+ (name "ghc-terminal-size")
+ (version "0.3.2.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/terminal-size/"
+ "terminal-size-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/terminal-size")
+ (synopsis "Get terminal window height and width")
+ (description "Get terminal window height and width without ncurses
+dependency.")
+ (license license:bsd-3)))
+
+(define-public ghc-texmath
+ (package
+ (name "ghc-texmath")
+ (version "0.11.0.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "texmath/texmath-" version ".tar.gz"))
+ (sha256
+ (base32
+ "11dc09hfnyfsz20ch2c867w0zdgjkzq41506lm61i3dk87ngdisf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-split" ,ghc-split)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-xml" ,ghc-xml)
+ ("ghc-pandoc-types" ,ghc-pandoc-types)))
+ (home-page "https://github.com/jgm/texmath")
+ (synopsis "Conversion between formats used to represent mathematics")
+ (description
+ "The texmath library provides functions to read and write TeX math,
+presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
+Office). Support is also included for converting math formats to pandoc's
+native format (allowing conversion, via pandoc, to a variety of different
+markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
+it can parse and apply LaTeX macros.")
+ (license license:gpl2+)))
+
+(define-public ghc-text-binary
+ (package
+ (name "ghc-text-binary")
+ (version "0.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "text-binary/text-binary-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "18gl10pwg3qwsk0za3c70j4n6a9129wwf1b7d3a461h816yv55xn"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/kawu/text-binary")
+ (synopsis "Binary instances for text types")
+ (description
+ "This package provides a compatibility layer providing @code{Binary}
+instances for strict and lazy text types for versions older than 1.2.1 of the
+text package.")
+ (license license:bsd-2)))
+
+(define-public ghc-tf-random
+ (package
+ (name "ghc-tf-random")
+ (version "0.5")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tf-random/tf-random-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-primitive" ,ghc-primitive)
+ ("ghc-random" ,ghc-random)))
+ (home-page "https://hackage.haskell.org/package/tf-random")
+ (synopsis "High-quality splittable pseudorandom number generator")
+ (description "This package contains an implementation of a high-quality
+splittable pseudorandom number generator. The generator is based on a
+cryptographic hash function built on top of the ThreeFish block cipher. See
+the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
+Hashing\" by Claessen, Pałka for details and the rationale of the design.")
+ (license license:bsd-3)))
+
+(define-public ghc-th-abstraction
+ (package
+ (name "ghc-th-abstraction")
+ (version "0.2.8.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "th-abstraction/th-abstraction-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0n17w4q2ykd0nica4sck2wng6md56rfad8x0icl0l8vnzb9nn4ya"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/glguy/th-abstraction")
+ (synopsis "Nicer interface for reified information about data types")
+ (description
+ "This package normalizes variations in the interface for inspecting
+datatype information via Template Haskell so that packages and support a
+single, easier to use informational datatype while supporting many versions of
+Template Haskell.")
+ (license license:isc)))
+
+(define-public ghc-th-expand-syns
+ (package
+ (name "ghc-th-expand-syns")
+ (version "0.4.4.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "th-expand-syns/th-expand-syns-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "01prlvh3py5hq5ccjidfyp9ixq2zd88dkbsidyjrpkja6v8m43yc"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-syb" ,ghc-syb)))
+ (home-page "https://hackage.haskell.org/package/th-expand-syns")
+ (synopsis "Expands type synonyms in Template Haskell ASTs")
+ (description
+ "This package enables users to expand type synonyms in Template Haskell
+@dfn{abstract syntax trees} (ASTs).")
+ (license license:bsd-3)))
+
+(define-public ghc-th-lift
+ (package
+ (name "ghc-th-lift")
+ (version "0.7.11")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "th-lift/th-lift-" version ".tar.gz"))
+ (sha256
+ (base32
+ "131360zxb0hazbqwbkk6ab2p77jkxr79bwwm618mrwrwkm3x2g6m"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-th-abstraction" ,ghc-th-abstraction)))
+ (home-page "https://github.com/mboes/th-lift")
+ (synopsis "Derive Template Haskell's Lift class for datatypes")
+ (description
+ "This is a Haskell library to derive Template Haskell's Lift class for
+datatypes.")
+ (license license:bsd-3)))
+
+(define-public ghc-th-lift-instances
+ (package
+ (name "ghc-th-lift-instances")
+ (version "0.1.11")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "th-lift-instances/th-lift-instances-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1f56cp6ckcalld5jchv0kxpjkwcsixd7smd0g7r8cg67ppx6m90x"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-th-lift" ,ghc-th-lift)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/bennofs/th-lift-instances/")
+ (synopsis "Lift instances for template-haskell for common data types.")
+ (description "Most data types in the Haskell platform do not have Lift
+instances. This package provides orphan instances for @code{containers},
+@code{text}, @code{bytestring} and @code{vector}.")
+ (license license:bsd-3)))
+
+(define-public ghc-th-orphans
+ (package
+ (name "ghc-th-orphans")
+ (version "0.13.6")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "th-orphans/th-orphans-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0sfl3pn9kq9da3ji3lsgzgzy82vz6yvsg80dmakc1jvk7awycibp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-th-lift" ,ghc-th-lift)
+ ("ghc-th-lift-instances" ,ghc-th-lift-instances)
+ ("ghc-th-reify-many" ,ghc-th-reify-many)
+ ("ghc-generic-deriving" ,ghc-generic-deriving)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://hackage.haskell.org/package/th-orphans")
+ (synopsis "Orphan instances for TH datatypes")
+ (description
+ "This package provides orphan instances for Template Haskell datatypes. In particular,
+instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
+and @code{Eq} instances. These instances used to live in the haskell-src-meta
+package, and that's where the version number started.")
+ (license license:bsd-3)))
+
(define-public ghc-threads
(package
(name "ghc-threads")
@@ -248,6 +9946,1403 @@ package is similar to the @code{threadmanager}, @code{async} and
@end itemize")
(license license:bsd-3)))
+(define-public ghc-th-reify-many
+ (package
+ (name "ghc-th-reify-many")
+ (version "0.1.8")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "th-reify-many/th-reify-many-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0hzy6hvhvcd6i60vx5cp2b7ggmnnjh9rx4h8bm8xw4grglcaxjnf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-safe" ,ghc-safe)
+ ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
+ (home-page "https://github.com/mgsloan/th-reify-many")
+ (synopsis "Recurseively reify template haskell datatype info")
+ (description
+ "th-reify-many provides functions for recursively reifying top level
+declarations. The main intended use case is for enumerating the names of
+datatypes reachable from an initial datatype, and passing these names to some
+function which generates instances.")
+ (license license:bsd-3)))
+
+(define-public ghc-time-locale-compat
+ (package
+ (name "ghc-time-locale-compat")
+ (version "0.1.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "time-locale-compat/time-locale-compat-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0b2hmj8wwrfkndwzgm11qr496ca2ahwdxcj3m0ii91bxvrk1bzq7"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-old-locale" ,ghc-old-locale)))
+ (home-page "https://github.com/khibino/haskell-time-locale-compat")
+ (synopsis "Compatibility of TimeLocale between old-locale and time-1.5")
+ (description "This package contains a wrapped name module for
+@code{TimeLocale}.")
+ (license license:bsd-3)))
+
+(define-public ghc-tldr
+ (package
+ (name "ghc-tldr")
+ (version "0.4.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tldr/tldr-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0nc581y9jjzwd8l88g48c72mla7k6q1w102akl7gl5jsk9ljamd3"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-cmark" ,ghc-cmark)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-typed-process" ,ghc-typed-process)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)))
+ (home-page "https://github.com/psibi/tldr-hs#readme")
+ (synopsis "Haskell tldr client")
+ (description "This package provides the @command{tldr} command and a
+Haskell client library allowing users to update and view @code{tldr} pages
+from a shell. The @code{tldr} pages are a community effort to simplify the
+man pages with practical examples.")
+ (license license:bsd-3)))
+
+(define-public ghc-transformers-base
+ (package
+ (name "ghc-transformers-base")
+ (version "0.4.5.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/transformers-base/transformers-base-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page
+ "https://hackage.haskell.org/package/transformers-compat")
+ (synopsis
+ "Backported transformer library")
+ (description
+ "Backported versions of types that were added to transformers in
+transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
+compatibility to run on old versions of the platform.")
+ (license license:bsd-3)))
+
+(define-public ghc-transformers-compat
+ (package
+ (name "ghc-transformers-compat")
+ (version "0.6.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/transformers-compat"
+ "/transformers-compat-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1gp4a8kvniwgm8947ghb4iwv4b7wd6ry4kvv4nfnym4agf5j41nw"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/ekmett/transformers-compat/")
+ (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
+ (description "This package includes backported versions of types that were
+added to transformers in transformers 0.3 and 0.4 for users who need strict
+transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
+but also need those types.")
+ (license license:bsd-3)))
+
+(define-public ghc-tree-diff
+ (package
+ (name "ghc-tree-diff")
+ (version "0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tree-diff/tree-diff-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "049v44c520jy3icxlnrvbdblh3mjmvd7m6qmkzxbzkf02x63xqmz"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("4" "1rqxxyj6hqllahs11693g855cxz8mgnb490s7j1ksd300i5xgjsp")
+ #:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "tree-diff.cabal"
+ (("trifecta >=1\\.7\\.1\\.1 && <1\\.8")
+ "trifecta >=1.7.1.1 && <=2")))))))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-generics-sop" ,ghc-generics-sop)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-memotrie" ,ghc-memotrie)
+ ("ghc-parsers" ,ghc-parsers)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-uuid-types" ,ghc-uuid-types)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-trifecta" ,ghc-trifecta)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/phadej/tree-diff")
+ (synopsis "Compute difference between (expression) trees")
+ (description "This Haskell library provides a function for computing
+the difference between (expression) trees. It also provides a way to
+compute the difference between arbitrary abstract datatypes (ADTs) using
+@code{Generics}-derivable helpers.")
+ (license license:bsd-3)))
+
+(define-public ghc-trifecta
+ (package
+ (name "ghc-trifecta")
+ (version "2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/trifecta/"
+ "trifecta-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0hznd8i65s81xy13i2qc7cvipw3lfb2yhkv53apbdsh6sbljz5sk"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; doctest suite fails to build on i686
+ (inputs
+ `(("ghc-reducers" ,ghc-reducers)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-charset" ,ghc-charset)
+ ("ghc-comonad" ,ghc-comonad)
+ ("ghc-fingertree" ,ghc-fingertree)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-parsers" ,ghc-parsers)
+ ("ghc-profunctors" ,ghc-profunctors)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-utf8-string" ,ghc-utf8-string)))
+ (native-inputs
+ `(("cabal-doctest" ,cabal-doctest)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/ekmett/trifecta/")
+ (synopsis "Parser combinator library with convenient diagnostics")
+ (description "Trifecta is a modern parser combinator library for Haskell,
+with slicing and Clang-style colored diagnostics.")
+ (license license:bsd-3)))
+
+(define-public ghc-tuple-th
+ (package
+ (name "ghc-tuple-th")
+ (version "0.2.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tuple-th-" version "/"
+ "tuple-th-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1mrl4vvxmby7sf1paf7hklzidnr6wq55822i73smqyz0xpf3gsjn"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/DanielSchuessler/tuple-th")
+ (synopsis "Generate utility functions for tuples of statically known size
+for Haskell")
+ (description "This Haskell package contains Template Haskell functions for
+generating functions similar to those in @code{Data.List} for tuples of
+statically known size.")
+ (license license:bsd-3)))
+
+(define-public ghc-typed-process
+ (package
+ (name "ghc-typed-process")
+ (version "0.2.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "typed-process/typed-process-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0j36vrc9w841m5qbwqra1lwiznx31xfnhin1sm8x2c2739csbpn0"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)))
+ (native-inputs
+ `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://haskell-lang.org/library/typed-process")
+ (synopsis "Run external processes with strong typing of streams")
+ (description
+ "This library provides the ability to launch and interact with external
+processes. It wraps around the @code{process} library, and intends to improve
+upon it.")
+ (license license:expat)))
+
+(define-public ghc-unbounded-delays
+ (package
+ (name "ghc-unbounded-delays")
+ (version "0.1.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ir9fghbrc214c97bwafk5ck6cacxz1pdnq4i18p604d1b8zg9wa"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/basvandijk/unbounded-delays")
+ (synopsis "Unbounded thread delays and timeouts")
+ (description "The @code{threadDelay} and @code{timeout} functions from the
+Haskell base library use the bounded @code{Int} type for specifying the delay
+or timeout period. This package provides alternative functions which use the
+unbounded @code{Integer} type.")
+ (license license:bsd-3)))
+
+(define-public ghc-unexceptionalio
+ (package
+ (name "ghc-unexceptionalio")
+ (version "0.4.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "unexceptionalio-" version "/" "unexceptionalio-"
+ version ".tar.gz"))
+ (sha256 (base32 "09gynk472l7nn5l2w320n4dwigwp0wh0shfp6dyw6r5h2jdxz18p"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/singpolyma/unexceptionalio")
+ (synopsis "IO without any non-error, synchronous exceptions")
+ (description "When you've caught all the exceptions that can be
+handled safely, this is what you're left with.")
+ (license license:isc)))
+
+(define-public ghc-union-find
+ (package
+ (name "ghc-union-find")
+ (version "0.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/union-find/union-find-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/nominolo/union-find")
+ (synopsis "Efficient union and equivalence testing of sets")
+ (description
+ "The Union/Find algorithm implements these operations in (effectively)
+constant-time:
+@enumerate
+@item Check whether two elements are in the same equivalence class.
+@item Create a union of two equivalence classes.
+@item Look up the descriptor of the equivalence class.
+@end enumerate\n")
+ (license license:bsd-3)))
+
+(define-public ghc-uniplate
+ (package
+ (name "ghc-uniplate")
+ (version "1.6.12")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/uniplate/uniplate-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (home-page "http://community.haskell.org/~ndm/uniplate/")
+ (synopsis "Simple, concise and fast generic operations")
+ (description "Uniplate is a library for writing simple and concise generic
+operations. Uniplate has similar goals to the original Scrap Your Boilerplate
+work, but is substantially simpler and faster.")
+ (license license:bsd-3)))
+
+(define-public ghc-unix-compat
+ (package
+ (name "ghc-unix-compat")
+ (version "0.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/unix-compat/unix-compat-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0llwl7rp63fy2ychwdclz1afj45pbin5pfl01dvn6rwhvmwhr7d3"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/jystic/unix-compat")
+ (synopsis "Portable POSIX-compatibility layer")
+ (description
+ "This package provides portable implementations of parts of the unix
+package. This package re-exports the unix package when available. When it
+isn't available, portable implementations are used.")
+ (license license:bsd-3)))
+
+(define-public ghc-unix-time
+ (package
+ (name "ghc-unix-time")
+ (version "0.3.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/unix-time/unix-time-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "051slgpid5cxiaw203ky0ql3823h28fcjs08axkzd4265wrvv8fw"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
+ ; is weird, that should be provided by GHC 7.10.2.
+ (inputs
+ `(("ghc-old-time" ,ghc-old-time)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (home-page "https://hackage.haskell.org/package/unix-time")
+ (synopsis "Unix time parser/formatter and utilities")
+ (description "This library provides fast parsing and formatting utilities
+for Unix time in Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-unliftio
+ (package
+ (name "ghc-unliftio")
+ (version "0.2.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/unliftio/unliftio-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0qql93lq5w7qghl454cc3s1i8v1jb4h08n82fqkw0kli4g3g9njs"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/fpco/unliftio")
+ (synopsis "Provides MonadUnliftIO typecplass for unlifting monads to
+IO (batteries included)")
+ (description "This Haskell package provides the core @code{MonadUnliftIO}
+typeclass, a number of common instances, and a collection of common functions
+working with it.")
+ (license license:expat)))
+
+(define-public ghc-unliftio-core
+ (package
+ (name "ghc-unliftio-core")
+ (version "0.1.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "unliftio-core-" version "/"
+ "unliftio-core-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1193fplsjm1lcr05xwvkj1rsyzx74i755f6kw3ikmxbsv0bv0l3m"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "16bjwcsaghqqmyi69rq65dn3ydifyfaabq3ns37apdm00mwqbcj2")))
+ (home-page
+ "https://github.com/fpco/unliftio/tree/master/unliftio-core#readme")
+ (synopsis "The MonadUnliftIO typeclass for unlifting monads to IO")
+ (description "This Haskell package provides the core @code{MonadUnliftIO}
+typeclass, instances for base and transformers, and basic utility
+functions.")
+ (license license:expat)))
+
+(define-public ghc-unordered-containers
+ (package
+ (name "ghc-unordered-containers")
+ (version "0.2.9.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/unordered-containers"
+ "/unordered-containers-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0l4264p0av12cc6i8gls13q8y27x12z2ar4x34n3x59y99fcnc37"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-hashable" ,ghc-hashable)))
+ (home-page
+ "https://github.com/tibbe/unordered-containers")
+ (synopsis
+ "Efficient hashing-based container types")
+ (description
+ "Efficient hashing-based container types. The containers have been
+optimized for performance critical use, both in terms of large data quantities
+and high speed.")
+ (license license:bsd-3)))
+
+(define-public ghc-unordered-containers-bootstrap
+ (package
+ (inherit ghc-unordered-containers)
+ (name "ghc-unordered-containers-bootstrap")
+ (arguments `(#:tests? #f))
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable-bootstrap)))
+ (properties '(hidden? #t))))
+
+(define-public ghc-uri-bytestring
+ (package
+ (name "ghc-uri-bytestring")
+ (version "0.3.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "uri-bytestring-" version "/"
+ "uri-bytestring-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1q04j5ybvk37zk2m0bkjwyhblz0ymdj0cn4rvsvdca1ikn5xdv5c"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-th-lift-instances" ,ghc-th-lift-instances)))
+ (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-generics-sop" ,ghc-generics-sop)))
+ (home-page "https://github.com/Soostone/uri-bytestring")
+ (synopsis "Haskell URI parsing as ByteStrings")
+ (description "This Haskell package aims to be an RFC3986 compliant URI
+parser that uses ByteStrings for parsing and representing the URI data.")
+ (license license:bsd-3)))
+
+(define-public ghc-utf8-string
+ (package
+ (name "ghc-utf8-string")
+ (version "1.0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/utf8-string/utf8-string-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("3" "02vhj5gykkqa2dyn7s6gn8is1b5fdn9xcqqvlls268g7cpv6rk38")))
+ (home-page "https://github.com/glguy/utf8-string/")
+ (synopsis "Support for reading and writing UTF8 Strings")
+ (description
+ "A UTF8 layer for Strings. The utf8-string package provides operations
+for encoding UTF8 strings to Word8 lists and back, and for reading and writing
+UTF8 without truncation.")
+ (license license:bsd-3)))
+
+(define-public ghc-utility-ht
+ (package
+ (name "ghc-utility-ht")
+ (version "0.0.14")
+ (home-page "https://hackage.haskell.org/package/utility-ht")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append home-page "/utility-ht-" version ".tar.gz"))
+ (sha256
+ (base32 "1a7bgk7wv7sqbxbiv7kankiimr3wij7zdm7s83zwsf886ghyxhk9"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (synopsis "Haskell helper functions for Lists, Maybes, Tuples, Functions")
+ (description "This package includes Hakell modules providing various
+helper functions for Lists, Maybes, Tuples, Functions.")
+ (license license:bsd-3)))
+
+(define-public ghc-uuid
+ (package
+ (name "ghc-uuid")
+ (version "1.3.13")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "uuid-" version "/"
+ "uuid-" version ".tar.gz"))
+ (sha256
+ (base32
+ "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "0m185q62jkfb5jsv358nxbnrkv8y8hd0qqvgvh22wvc5g9ipz0r9")
+ #:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'strip-test-framework-constraints
+ (lambda _
+ (substitute* "uuid.cabal"
+ (("HUnit >= 1\\.2 && < 1\\.4") "HUnit")
+ (("QuickCheck >= 2\\.4 && < 2\\.10") "QuickCheck")
+ (("tasty >= 0\\.10 && < 0\\.12") "tasty")
+ (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit")
+ (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+ (inputs `(("ghc-cryptohash-sha1" ,ghc-cryptohash-sha1)
+ ("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
+ ("ghc-entropy" ,ghc-entropy)
+ ("ghc-network-info" ,ghc-network-info)
+ ("ghc-random" ,ghc-random)
+ ("ghc-uuid-types" ,ghc-uuid-types)))
+ (native-inputs `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/hvr/uuid")
+ (synopsis "Haskell library to create, compare, parse, and print UUIDs")
+ (description "This Haskell library provides utilities creating, comparing,
+parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.")
+ (license license:bsd-3)))
+
+(define-public ghc-uuid-types
+ (package
+ (name "ghc-uuid-types")
+ (version "1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "uuid-types-" version "/"
+ "uuid-types-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'strip-test-framework-constraints
+ (lambda _
+ (substitute* "uuid-types.cabal"
+ (("HUnit >=1\\.2 && < 1\\.4") "HUnit")
+ (("QuickCheck >=2\\.4 && < 2\\.9") "QuickCheck")
+ (("tasty >= 0\\.10 && < 0\\.12") "tasty")
+ (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit")
+ (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+ (inputs `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-random" ,ghc-random)))
+ (native-inputs `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/hvr/uuid")
+ (synopsis "Haskell type definitions for UUIDs")
+ (description "This Haskell library contains type definitions for
+@dfn{Universally Unique Identifiers} or
+@uref{https://en.wikipedia.org/wiki/UUID, UUIDs}, and basic conversion
+functions.")
+ (license license:bsd-3)))
+
+(define-public ghc-validation
+ (package
+ (name "ghc-validation")
+ (version "1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/validation/validation-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "08drmdvyzg2frbb26icy1mlz52xv0l6gi3v8gb7xp0vrcci5libh"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "1x1g4nannz81j1h64l1m3ancc96zc57d1bjhj1wk7bwn1xxbi5h3")))
+ (inputs
+ `(("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-lens" ,ghc-lens)))
+ (native-inputs
+ `(("ghc-hedgehog" ,ghc-hedgehog)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/qfpl/validation")
+ (synopsis
+ "Data-type like Either but with an accumulating Applicative")
+ (description
+ "A data-type like Either but with differing properties and type-class
+instances.
+
+Library support is provided for this different representation, including
+@code{lens}-related functions for converting between each and abstracting over
+their similarities.
+
+The @code{Validation} data type is isomorphic to @code{Either}, but has an
+instance of @code{Applicative} that accumulates on the error side. That is to
+say, if two (or more) errors are encountered, they are appended using a
+@{Semigroup} operation.
+
+As a consequence of this @code{Applicative} instance, there is no
+corresponding @code{Bind} or @code{Monad} instance. @code{Validation} is an
+example of, \"An applicative functor that is not a monad.\"")
+ (license license:bsd-3)))
+
+(define-public ghc-validity
+ (package
+ (name "ghc-validity")
+ (version "0.7.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/validity/validity-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0xribw98amafihw87ddajk6vlirp7w9b26lrnjgq7jfm4710j95f"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page
+ "https://github.com/NorfairKing/validity")
+ (synopsis "Validity typeclass")
+ (description
+ "Values of custom types usually have invariants imposed upon them. This
+package provides the @code{Validity} type class, which makes these invariants
+explicit by providing a function to check whether the invariants hold.")
+ (license license:expat)))
+
+(define-public ghc-vault
+ (package
+ (name "ghc-vault")
+ (version "0.3.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/vault/vault-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "072mbrihsdsb8c6xvg6lvk0rqjgvxvi8qkg4n6wwym5hq0pfa04y"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)))
+ (home-page
+ "https://github.com/HeinrichApfelmus/vault")
+ (synopsis "Persistent store for arbitrary values")
+ (description "This package provides vaults for Haskell. A vault is a
+persistent store for values of arbitrary types. It's like having first-class
+access to the storage space behind @code{IORefs}. The data structure is
+analogous to a bank vault, where you can access different bank boxes with
+different keys; hence the name. Also provided is a @code{locker} type,
+representing a store for a single element.")
+ (license license:bsd-3)))
+
+(define-public ghc-vector
+ (package
+ (name "ghc-vector")
+ (version "0.12.0.1")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/vector/vector-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0yrx2ypiaxahvaz84af5bi855hd3107kxkbqc8km29nsp5wyw05i"))))
+ (build-system haskell-build-system)
+ ;; FIXME: To simplify upgrading all Haskell packages, we leave the tests
+ ;; disabled for now.
+ (arguments
+ `(#:cabal-revision
+ ("3" "0y5rh8k710i2a3p1h2rghvr5cfg78p5h0kbfi7ifxqqf6pzlyr1x")
+ #:tests? #f))
+ (inputs
+ `(("ghc-primitive" ,ghc-primitive)
+ ("ghc-random" ,ghc-random)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ;; ("ghc-hunit" ,ghc-hunit)
+ ;; ("ghc-test-framework" ,ghc-test-framework)
+ ;; ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ;; ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ))
+ (home-page "https://github.com/haskell/vector")
+ (synopsis "Efficient Arrays")
+ (description "This library provides an efficient implementation of
+Int-indexed arrays (both mutable and immutable), with a powerful loop
+optimisation framework.")
+ (license license:bsd-3)))
+
+(define-public ghc-vector-algorithms
+ (package
+ (name "ghc-vector-algorithms")
+ (version "0.7.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "vector-algorithms-" version "/"
+ "vector-algorithms-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0mfa8ig9v69l41p2vb5jl4qmaln5y1rlzarr2mlgm8g1nvq8qqdg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/bos/math-functions")
+ (synopsis "Algorithms for vector arrays in Haskell")
+ (description "This Haskell library algorithms for vector arrays.")
+ (license license:bsd-3)))
+
+(define-public ghc-vector-binary-instances
+ (package
+ (name "ghc-vector-binary-instances")
+ (version "0.2.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "vector-binary-instances/vector-binary-instances-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1y236jb72iab9ska1mc48z6yb0xgwmj45laaqdyjxksd84z7hbrb"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "196frl4akhfk7xf1nxzn8lmq99dxhzhsimanswn9yy7ym8zhki4i")))
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/bos/vector-binary-instances")
+ (synopsis "Instances of Data.Binary and Data.Serialize for vector")
+ (description "This library provides instances of @code{Binary} for the
+types defined in the @code{vector} package, making it easy to serialize
+vectors to and from disk. We use the generic interface to vectors, so all
+vector types are supported. Specific instances are provided for unboxed,
+boxed and storable vectors.")
+ (license license:bsd-3)))
+
+(define-public ghc-vector-builder
+ (package
+ (name "ghc-vector-builder")
+ (version "0.3.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "vector-builder-" version "/"
+ "vector-builder-" version ".tar.gz"))
+ (sha256
+ (base32
+ "06d2pa1fb3ydrl7l6rjazqyxv5i73v65x2f5fp0ypjxfbm6jsmn8"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-vector" ,ghc-vector)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-base-prelude" ,ghc-base-prelude)))
+ (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-rerebase" ,ghc-rerebase)))
+ (home-page "https://github.com/nikita-volkov/vector-builder")
+ (synopsis "Vector builder for Haskell")
+ (description "This Haskell package provides an API for constructing vectors.
+It provides the composable @code{Builder} abstraction, which has instances of the
+@code{Monoid} and @code{Semigroup} classes.
+
+You would first use the @code{Builder} abstraction to specify the structure of
+the vector; then you can execute the builder to actually produce the
+vector. ")
+ (license license:expat)))
+
+(define-public ghc-vector-th-unbox
+ (package
+ (name "ghc-vector-th-unbox")
+ (version "0.2.1.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "vector-th-unbox-" version "/"
+ "vector-th-unbox-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0d82x55f5vvr1jvaia382m23rs690lg55pvavv8f4ph0y6kd91xy"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)
+ ("ghc-data-default" ,ghc-data-default)))
+ (home-page "https://github.com/liyang/vector-th-unbox")
+ (synopsis "Deriver for Data.Vector.Unboxed using Template Haskell")
+ (description "This Haskell library provides a Template Haskell
+deriver for unboxed vectors, given a pair of coercion functions to
+and from some existing type with an Unbox instance.")
+ (license license:bsd-3)))
+
+(define-public ghc-void
+ (package
+ (name "ghc-void")
+ (version "0.7.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/void/void-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0aygw0yb1h3yhmfl3bkwh5d3h0l4mmsxz7j53vdm6jryl1kgxzyk"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-hashable" ,ghc-hashable)))
+ (home-page "https://github.com/ekmett/void")
+ (synopsis
+ "Logically uninhabited data type")
+ (description
+ "A Haskell 98 logically uninhabited data type, used to indicate that a
+given term should not exist.")
+ (license license:bsd-3)))
+
+(define-public ghc-wave
+ (package
+ (name "ghc-wave")
+ (version "0.1.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/wave/wave-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "03zycmwrchhqvi37fdvlzz2d1vl4hy0i8xyys1zznw38qfq0h2i5"))))
+ (build-system haskell-build-system)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'update-constraints
+ (lambda _
+ (substitute* "wave.cabal"
+ (("temporary.* < 1\\.3")
+ "temporary >= 1.1 && < 1.4")))))))
+ (inputs
+ `(("ghc-cereal" ,ghc-cereal)
+ ("ghc-data-default-class"
+ ,ghc-data-default-class)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-temporary" ,ghc-temporary)))
+ (native-inputs
+ `(("hspec-discover" ,hspec-discover)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/mrkkrp/wave")
+ (synopsis "Work with WAVE and RF64 files in Haskell")
+ (description "This package allows you to work with WAVE and RF64
+files in Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-wcwidth
+ (package
+ (name "ghc-wcwidth")
+ (version "0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/wcwidth/wcwidth-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1n1fq7v64b59ajf5g50iqj9sa34wm7s2j3viay0kxpmvlcv8gipz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-setlocale" ,ghc-setlocale)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-attoparsec" ,ghc-attoparsec)))
+ (home-page "https://github.com/solidsnack/wcwidth/")
+ (synopsis "Haskell bindings to wcwidth")
+ (description "This package provides Haskell bindings to your system's
+native wcwidth and a command line tool to examine the widths assigned by it.
+The command line tool can compile a width table to Haskell code that assigns
+widths to the Char type.")
+ (license license:bsd-3)))
+
+(define-public ghc-wcwidth-bootstrap
+ (package
+ (inherit ghc-wcwidth)
+ (name "ghc-wcwidth-bootstrap")
+ (inputs
+ `(("ghc-setlocale" ,ghc-setlocale)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-attoparsec" ,ghc-attoparsec-bootstrap)))
+ (properties '(hidden? #t))))
+
+(define-public ghc-weigh
+ (package
+ (name "ghc-weigh")
+ (version "0.0.12")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/weigh/"
+ "weigh-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0zw2a997gxgdzqmd7j730kxgynzmjvvlkw84dajmfzf1v9pbij7x"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-split" ,ghc-split)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/fpco/weigh#readme")
+ (synopsis "Measure allocations of a Haskell functions/values")
+ (description "This package provides tools to measure the memory usage of a
+Haskell value or function.")
+ (license license:bsd-3)))
+
+(define-public ghc-wl-pprint
+ (package
+ (name "ghc-wl-pprint")
+ (version "1.2.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/wl-pprint/wl-pprint-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0kn7y8pdrv8f87zhd5mifcl8fy3b2zvnzmzwhdqhxxlyzwiq6z0c"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/wl-pprint")
+ (synopsis "Wadler/Leijen pretty printer")
+ (description
+ "This is a pretty printing library based on Wadler's paper @i{A Prettier
+Printer}. This version allows the library user to declare overlapping
+instances of the @code{Pretty} class.")
+ (license license:bsd-3)))
+
+(define-public ghc-wl-pprint-annotated
+ (package
+ (name "ghc-wl-pprint-annotated")
+ (version "0.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/wl-pprint-annotated/wl-pprint-annotated-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1br7qyf27iza213inwhf9bm2k6in0zbmfw6w4clqlc9f9cj2nrkb"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page
+ "https://github.com/minad/wl-pprint-annotated#readme")
+ (synopsis
+ "Wadler/Leijen pretty printer with annotation support")
+ (description
+ "Annotations are useful for coloring. This is a limited version of
+@code{wl-pprint-extras} without support for point effects and without the free
+monad. Like in @code{annotated-wl-pprint}, only annotations are supported.
+Compared to @code{annotated-wl-pprint} this library provides a slightly
+modernized interface.")
+ (license license:bsd-3)))
+
+(define-public ghc-wl-pprint-text
+ (package
+ (name "ghc-wl-pprint-text")
+ (version "1.2.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/wl-pprint-text/wl-pprint-text-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0g3w92rad6x5appfb22rbzcas2ix2h0hy91sdxhq8a4a5cnlrpa0"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)))
+ (home-page "https://hackage.haskell.org/package/wl-pprint-text")
+ (synopsis "Wadler/Leijen Pretty Printer for Text values")
+ (description
+ "A clone of wl-pprint for use with the text library.")
+ (license license:bsd-3)))
+
+(define-public ghc-word8
+ (package
+ (name "ghc-word8")
+ (version "0.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/word8/word8-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "12jx7f13d2h1djq4fh4dyrab61sm49mj1w61j3rzp2vjfm696c16"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://hackage.haskell.org/package/word8")
+ (synopsis "Word8 library for Haskell")
+ (description "Word8 library to be used with @code{Data.ByteString}.")
+ (license license:bsd-3)))
+
+(define-public ghc-x11
+ (package
+ (name "ghc-x11")
+ (version "1.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/X11/"
+ "X11-" version ".tar.gz"))
+ (sha256
+ (base32 "1f8dy6ckkyvpcv7zlniyv01cqjb9lgqscm8pml58cvwc7n38w4qh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("libx11" ,libx11)
+ ("libxrandr" ,libxrandr)
+ ("libxinerama" ,libxinerama)
+ ("libxscrnsaver" ,libxscrnsaver)
+ ("ghc-data-default" ,ghc-data-default)))
+ (home-page "https://github.com/haskell-pkg-janitors/X11")
+ (synopsis "Bindings to the X11 graphics library")
+ (description
+ "This package provides Haskell bindings to the X11 graphics library. The
+bindings are a direct translation of the C bindings.")
+ (license license:bsd-3)))
+
+(define-public ghc-x11-xft
+ (package
+ (name "ghc-x11-xft")
+ (version "0.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/X11-xft/"
+ "X11-xft-" version ".tar.gz"))
+ (sha256
+ (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
+ (inputs
+ `(("ghc-x11" ,ghc-x11)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("libx11" ,libx11)
+ ("libxft" ,libxft)
+ ("xorgproto" ,xorgproto)))
+ (native-inputs
+ `(("pkg-config" ,pkg-config)))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/X11-xft")
+ (synopsis "Bindings to Xft")
+ (description
+ "Bindings to the Xft, X Free Type interface library, and some Xrender
+parts.")
+ (license license:lgpl2.1)))
+
+(define-public ghc-xdg-basedir
+ (package
+ (name "ghc-xdg-basedir")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/xdg-basedir/"
+ "xdg-basedir-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0azlzaxp2dn4l1nr7shsxah2magk1szf6fx0mv75az00qsjw6qg4"))))
+ (build-system haskell-build-system)
+ (home-page "http://github.com/willdonnelly/xdg-basedir")
+ (synopsis "XDG Base Directory library for Haskell")
+ (description "This package provides a library implementing the XDG Base Directory spec.")
+ (license license:bsd-3)))
+
+(define-public ghc-xml
+ (package
+ (name "ghc-xml")
+ (version "1.3.14")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/xml/xml-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
+ (build-system haskell-build-system)
+ (home-page "http://code.galois.com")
+ (synopsis "Simple XML library for Haskell")
+ (description "This package provides a simple XML library for Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-xml-conduit
+ (package
+ (name "ghc-xml-conduit")
+ (version "1.8.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/xml-conduit/"
+ "xml-conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "177gmyigxql1pn3ncz0r8annwv5cbxnihbgrrg1dhm4gmc9jy2wq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-doctest" ,ghc-doctest)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-xml-types" ,ghc-xml-types)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/snoyberg/xml")
+ (synopsis "Utilities for dealing with XML with the conduit package")
+ (description
+ "This package provides pure-Haskell utilities for dealing with XML with
+the @code{conduit} package.")
+ (license license:expat)))
+
+(define-public ghc-xml-types
+ (package
+ (name "ghc-xml-types")
+ (version "0.3.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/xml-types/"
+ "xml-types-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1jgqxsa9p2q3h6nymbfmvhldqrqlwrhrzmwadlyc0li50x0d8dwr"))))
+ (build-system haskell-build-system)
+ (home-page "https://john-millikin.com/software/haskell-xml/")
+ (synopsis "Basic types for representing XML")
+ (description "This package provides basic types for representing XML
+documents.")
+ (license license:expat)))
+
+(define-public ghc-yaml
+ (package
+ (name "ghc-yaml")
+ (version "0.8.32")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "yaml/yaml-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0cbsyh4ilvjzq1q7pxls43k6pdqxg1l85xzibcwpbvmlvrizh86w"))))
+ (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-aeson" ,ghc-aeson)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
+ ("ghc-base-compat" ,ghc-base-compat)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-mockery" ,ghc-mockery)))
+ (home-page "https://github.com/snoyberg/yaml/")
+ (synopsis "Parsing and rendering YAML documents")
+ (description
+ "This package provides a library to parse and render YAML documents.")
+ (license license:bsd-3)))
+
+(define-public ghc-zip-archive
+ (package
+ (name "ghc-zip-archive")
+ (version "0.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/zip-archive/zip-archive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0kf8xyac168bng8a0za2jwrbss7a4ralvci9g54hnvl0gkkxx2lq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-digest" ,ghc-digest)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-zlib" ,ghc-zlib)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("unzip" ,unzip)))
+ (home-page "https://hackage.haskell.org/package/zip-archive")
+ (synopsis "Zip archive library for Haskell")
+ (description "The zip-archive library provides functions for creating,
+modifying, and extracting files from zip archives in Haskell.")
+ (license license:bsd-3)))
+
+(define-public ghc-zlib
+ (package
+ (name "ghc-zlib")
+ (version "0.6.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/zlib/zlib-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1vbzf0awb6zb456xf48za1kl22018646cfzq4frvxgb9ay97vk0d"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'strip-test-framework-constraints
+ (lambda _
+ (substitute* "zlib.cabal"
+ (("tasty >= 0\\.8 && < 0\\.12") "tasty")
+ (("tasty-hunit >= 0\\.8 && < 0\\.10") "tasty-hunit")
+ (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
+ (inputs `(("zlib" ,zlib)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://hackage.haskell.org/package/zlib")
+ (synopsis
+ "Compression and decompression in the gzip and zlib formats")
+ (description
+ "This package provides a pure interface for compressing and decompressing
+streams of data represented as lazy @code{ByteString}s. It uses the zlib C
+library so it has high performance. It supports the @code{zlib}, @code{gzip}
+and @code{raw} compression formats. It provides a convenient high level API
+suitable for most tasks and for the few cases where more control is needed it
+provides access to the full zlib feature set.")
+ (license license:bsd-3)))
+
(define-public ghc-zlib-bindings
(package
(name "ghc-zlib-bindings")
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index cffa7e8ed7..4d16cd656f 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -39,44 +39,23 @@
#:use-module (gnu packages)
#:use-module (gnu packages base)
#:use-module (gnu packages bootstrap)
- #:use-module (gnu packages check)
- #:use-module (gnu packages compression)
#:use-module (gnu packages elf)
- #:use-module (gnu packages emacs)
#:use-module (gnu packages gcc)
#:use-module (gnu packages ghostscript)
- #:use-module (gnu packages gl)
- #:use-module (gnu packages graphviz)
- #:use-module (gnu packages gtk)
- #:use-module (gnu packages haskell-apps)
- #:use-module (gnu packages haskell-check)
- #:use-module (gnu packages haskell-crypto)
- #:use-module (gnu packages haskell-web)
#:use-module (gnu packages libffi)
- #:use-module (gnu packages linux)
#:use-module (gnu packages lisp)
- #:use-module (gnu packages lua)
- #:use-module (gnu packages maths)
#:use-module (gnu packages multiprecision)
#:use-module (gnu packages ncurses)
- #:use-module (gnu packages pcre)
#:use-module (gnu packages perl)
- #:use-module (gnu packages pkg-config)
#:use-module (gnu packages python)
- #:use-module (gnu packages sdl)
- #:use-module (gnu packages tls)
- #:use-module (gnu packages xml)
- #:use-module (gnu packages xorg)
#:use-module (guix build-system gnu)
- #:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (guix utils)
#:use-module (ice-9 match)
- #:use-module (ice-9 regex)
- #:use-module ((srfi srfi-1) #:select (alist-delete)))
+ #:use-module (ice-9 regex))
(define-public cl-yale-haskell
(let ((commit "85f94c72a16c5f70301dd8db04cde9de2d7dd270")
@@ -623,11057 +602,4 @@ interactive environment for the functional language Haskell.")
(define-public ghc ghc-8)
-(define-public ghc-hostname
- (package
- (name "ghc-hostname")
- (version "1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/hostname/"
- "hostname-" version ".tar.gz"))
- (sha256
- (base32
- "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/hostname")
- (synopsis "Hostname in Haskell")
- (description "Network.HostName is a simple package providing a means to
-determine the hostname.")
- (license license:bsd-3)))
-
-(define-public ghc-convertible
- (package
- (name "ghc-convertible")
- (version "1.1.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/convertible/"
- "convertible-" version ".tar.gz"))
- (sha256
- (base32
- "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-old-time" ,ghc-old-time)
- ("ghc-old-locale" ,ghc-old-locale)))
- (home-page "https://hackage.haskell.org/package/convertible")
- (synopsis "Typeclasses and instances for converting between types")
- (description
- "This package provides a typeclass with a single function that is
-designed to help convert between different types: numeric values, dates and
-times, and the like. The conversions perform bounds checking and return a
-pure @code{Either} value. This means that you need not remember which specific
-function performs the conversion you desire.")
- (license license:bsd-3)))
-
-(define-public ghc-double-conversion
- (package
- (name "ghc-double-conversion")
- (version "2.0.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "double-conversion/double-conversion-"
- version ".tar.gz"))
- (sha256
- (base32
- "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/bos/double-conversion")
- (synopsis "Fast conversion between double precision floating point and text")
- (description
- "This package provides a library that performs fast, accurate conversion
-between double precision floating point and text.")
- (license license:bsd-3)))
-
-(define-public ghc-libxml
- (package
- (name "ghc-libxml")
- (version "0.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/libxml/"
- "libxml-" version ".tar.gz"))
- (sha256
- (base32
- "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
- (build-system haskell-build-system)
- (inputs
- `(("libxml2" ,libxml2)))
- (arguments
- `(#:configure-flags
- `(,(string-append "--extra-include-dirs="
- (assoc-ref %build-inputs "libxml2")
- "/include/libxml2"))))
- (home-page "https://hackage.haskell.org/package/libxml")
- (synopsis "Haskell bindings to libxml2")
- (description
- "This library provides minimal Haskell binding to libxml2.")
- (license license:bsd-3)))
-
-(define-public ghc-prelude-extras
- (package
- (name "ghc-prelude-extras")
- (version "0.4.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/prelude-extras/prelude-extras-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0xzqdf3nl2h0ra4gnslm1m1nsxlsgc0hh6ky3vn578vh11zhifq9"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/ekmett/prelude-extras")
- (synopsis "Higher order versions of Prelude classes")
- (description "This library provides higher order versions of
-@code{Prelude} classes to ease programming with polymorphic recursion and
-reduce @code{UndecidableInstances}.")
- (license license:bsd-3)))
-
-(define-public ghc-data-default
- (package
- (name "ghc-data-default")
- (version "0.7.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/data-default/data-default-"
- version
- ".tar.gz"))
- (sha256
- (base32 "04d5n8ybmcxba9qb6h389w9zfq1lvj81b82jh6maqp6pkhkmvydh"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-data-default-class"
- ,ghc-data-default-class)
- ("ghc-data-default-instances-base"
- ,ghc-data-default-instances-base)
- ("ghc-data-default-instances-containers"
- ,ghc-data-default-instances-containers)
- ("ghc-data-default-instances-dlist"
- ,ghc-data-default-instances-dlist)
- ("ghc-data-default-instances-old-locale"
- ,ghc-data-default-instances-old-locale)))
- (home-page "https://hackage.haskell.org/package/data-default")
- (synopsis "Types with default values")
- (description
- "This package defines a class for types with a default value, and
-provides instances for types from the base, containers, dlist and old-locale
-packages.")
- (license license:bsd-3)))
-
-(define-public ghc-data-default-class
- (package
- (name "ghc-data-default-class")
- (version "0.1.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/data-default-class/"
- "data-default-class-" version ".tar.gz"))
- (sha256
- (base32 "0miyjz8d4jyvqf2vp60lyfbnflx6cj2k8apmm9ly1hq0y0iv80ag"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/data-default-class")
- (synopsis "Types with default values")
- (description
- "This package defines a class for types with default values.")
- (license license:bsd-3)))
-
-(define-public ghc-data-default-instances-base
- (package
- (name "ghc-data-default-instances-base")
- (version "0.1.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "data-default-instances-base/"
- "data-default-instances-base-" version ".tar.gz"))
- (sha256
- (base32 "0ym1sw3ssdzzifxxhh76qlv8kkmb2iclc158incv1dklyr9y8kw4"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-data-default-class" ,ghc-data-default-class)))
- (home-page "https://hackage.haskell.org/package/data-default-instances-base")
- (synopsis "Default instances for types in base")
- (description
- "This package provides default instances for types from the base
-package.")
- (license license:bsd-3)))
-
-(define-public ghc-data-default-instances-containers
- (package
- (name "ghc-data-default-instances-containers")
- (version "0.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "data-default-instances-containers/"
- "data-default-instances-containers-" version ".tar.gz"))
- (sha256
- (base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-data-default-class" ,ghc-data-default-class)))
- (home-page "https://hackage.haskell.org/package/data-default-instances-containers")
- (synopsis "Default instances for types in containers")
- (description "Provides default instances for types from the containers
-package.")
- (license license:bsd-3)))
-
-(define-public ghc-data-default-instances-dlist
- (package
- (name "ghc-data-default-instances-dlist")
- (version "0.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "data-default-instances-dlist/"
- "data-default-instances-dlist-" version ".tar.gz"))
- (sha256
- (base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-dlist" ,ghc-dlist)))
- (home-page "https://hackage.haskell.org/package/data-default-instances-dlist")
- (synopsis "Default instances for types in dlist")
- (description "Provides default instances for types from the dlist
-package.")
- (license license:bsd-3)))
-
-(define-public ghc-code-page
- (package
- (name "ghc-code-page")
- (version "0.1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/code-page/code-page-"
- version ".tar.gz"))
- (sha256
- (base32
- "1491frk4jx6dlhifky9dvcxbsbcfssrz979a5hp5zn061rh8cp76"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/RyanGlScott/code-page")
- (synopsis "Windows code page library for Haskell")
- (description "A cross-platform library with functions for adjusting
-code pages on Windows. On all other operating systems, the library does
-nothing.")
- (license license:bsd-3)))
-
-(define-public ghc-libffi
- (package
- (name "ghc-libffi")
- (version "0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "libffi/libffi-" version ".tar.gz"))
- (sha256
- (base32
- "0g7jnhng3j7z5517aaqga0144aamibsbpgm3yynwyfzkq1kp0f28"))))
- (build-system haskell-build-system)
- (native-inputs `(("pkg-config" ,pkg-config)))
- (inputs `(("libffi" ,libffi)))
- (home-page "http://hackage.haskell.org/package/libffi")
- (synopsis "Haskell binding to libffi")
- (description
- "A binding to libffi, allowing C functions of types only known at runtime
-to be called from Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-newtype-generics
- (package
- (name "ghc-newtype-generics")
- (version "0.5.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "newtype-generics/newtype-generics-"
- version ".tar.gz"))
- (sha256
- (base32
- "0igyisw2djg19v9vkna1rwf47k97mvkvk4bbkmswznvbm00z15gj"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "http://github.com/sjakobi/newtype-generics")
- (synopsis "Typeclass and set of functions for working with newtypes")
- (description "The @code{Newtype} typeclass represents the packing and
-unpacking of a newtype, and allows you to operate under that newtype with
-functions such as @code{ala}. Generics support was added in version 0.4,
-making this package a full replacement for the original newtype package,
-and an alternative to newtype-th.")
- (license license:bsd-3)))
-
-(define-public ghc-memotrie
- (package
- (name "ghc-memotrie")
- (version "0.6.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/MemoTrie/MemoTrie-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "157p0pi6rrq74a35mq6zkkycv4ah7xhkbrcmnkb9xf7pznw4aq0x"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-newtype-generics" ,ghc-newtype-generics)))
- (home-page "https://github.com/conal/MemoTrie")
- (synopsis "Trie-based memo functions")
- (description "This package provides a functional library for creating
-efficient memo functions using tries.")
- (license license:bsd-3)))
-
-(define-public ghc-tree-diff
- (package
- (name "ghc-tree-diff")
- (version "0.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/tree-diff/tree-diff-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "049v44c520jy3icxlnrvbdblh3mjmvd7m6qmkzxbzkf02x63xqmz"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("4" "1rqxxyj6hqllahs11693g855cxz8mgnb490s7j1ksd300i5xgjsp")
- #:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "tree-diff.cabal"
- (("trifecta >=1\\.7\\.1\\.1 && <1\\.8")
- "trifecta >=1.7.1.1 && <=2")))))))
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-base-compat" ,ghc-base-compat)
- ("ghc-generics-sop" ,ghc-generics-sop)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-memotrie" ,ghc-memotrie)
- ("ghc-parsers" ,ghc-parsers)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-uuid-types" ,ghc-uuid-types)
- ("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
- ("ghc-trifecta" ,ghc-trifecta)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-golden" ,ghc-tasty-golden)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://github.com/phadej/tree-diff")
- (synopsis "Compute difference between (expression) trees")
- (description "This Haskell library provides a function for computing
-the difference between (expression) trees. It also provides a way to
-compute the difference between arbitrary abstract datatypes (ADTs) using
-@code{Generics}-derivable helpers.")
- (license license:bsd-3)))
-
-(define-public ghc-haddock-library
- (package
- (name "ghc-haddock-library")
- (version "1.5.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/haddock-library/haddock-library-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1cmbg8l5xrwpliclwy3l057raypjqy0hsg1h1743ahaj8gq10b7z"))
- (patches (search-patches
- "ghc-haddock-library-unbundle.patch"))
- (modules '((guix build utils)))
- (snippet '(begin
- (delete-file-recursively "vendor")
- #t))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'relax-test-suite-dependencies
- (lambda _
- (substitute* "haddock-library.cabal"
- (("base-compat\\s*\\^>= 0\\.9\\.3") "base-compat")
- (("hspec\\s*\\^>= 2\\.4\\.4") "hspec"))))
- ;; The release tarball does not contain the "fixtures/examples"
- ;; directory, which is required for testing. In the upstream
- ;; repository, the directory exists and is populated. Here, we
- ;; create an empty directory to placate the tests.
- (add-before 'check 'add-examples-directory
- (lambda _
- (mkdir "fixtures/examples")
- #t)))))
- (native-inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-optparse-applicative" ,ghc-optparse-applicative)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tree-diff" ,ghc-tree-diff)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://www.haskell.org/haddock/")
- (synopsis "Library exposing some functionality of Haddock")
- (description
- "Haddock is a documentation-generation tool for Haskell libraries. These
-modules expose some functionality of it without pulling in the GHC dependency.
-Please note that the API is likely to change so specify upper bounds in your
-project if you can't release often. For interacting with Haddock itself, see
-the ‘haddock’ package.")
- (license license:bsd-3)))
-
-(define-public ghc-haddock-api
- (package
- (name "ghc-haddock-api")
- (version "2.19.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/haddock-api/haddock-api-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "haddock-api.cabal"
- (("Cabal \\^>= 2\\.0\\.0")
- "Cabal ^>= 2.2.0")
- (("hspec \\^>= 2\\.4\\.4")
- "hspec >= 2.4.4 && < 2.6")))))))
- (inputs
- `(("ghc-paths" ,ghc-paths)
- ("ghc-haddock-library" ,ghc-haddock-library)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://www.haskell.org/haddock/")
- (synopsis "API for documentation-generation tool Haddock")
- (description "This package provides an API to Haddock, the
-documentation-generation tool for Haskell libraries.")
- (license license:bsd-3)))
-
-(define-public ghc-haddock
- (package
- (name "ghc-haddock")
- (version "2.19.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/haddock/haddock-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7"))))
- (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
- (lambda _
- (use-modules (ice-9 rdelim))
- (with-atomic-file-replacement "haddock.cabal"
- (lambda (in out)
- (let loop ((line (read-line in 'concat)) (deleting? #f))
- (cond
- ((eof-object? line) #t)
- ((string-every char-set:whitespace line)
- (unless deleting? (display line out))
- (loop (read-line in 'concat) #f))
- ((member line '("test-suite html-test\n"
- "test-suite hypsrc-test\n"
- "test-suite latex-test\n"
- "test-suite hoogle-test\n"))
- (loop (read-line in 'concat) #t))
- (else
- (unless deleting? (display line out))
- (loop (read-line in 'concat) deleting?)))))))))))
- (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)))
- (home-page "https://www.haskell.org/haddock/")
- (synopsis
- "Documentation-generation tool for Haskell libraries")
- (description
- "Haddock is a documentation-generation tool for Haskell libraries.")
- (license license:bsd-3)))
-
-(define-public ghc-simple-reflect
- (package
- (name "ghc-simple-reflect")
- (version "0.3.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/simple-reflect/simple-reflect-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0ayvrx5cm8n6db21jiyjmk5h93pw7cz1707hih09hlhk9jh5x0h7"))))
- (build-system haskell-build-system)
- (home-page
- "https://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
- (synopsis
- "Simple reflection of expressions containing variables")
- (description
- "This package allows simple reflection of expressions containing
-variables. Reflection here means that a Haskell expression is turned into a
-string. The primary aim of this package is teaching and understanding; there
-are no options for manipulating the reflected expressions beyond showing
-them.")
- (license license:bsd-3)))
-
-(define-public ghc-haskell-src
- (package
- (name "ghc-haskell-src")
- (version "1.0.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/haskell-src/haskell-src-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1g4dj1f0j68bhn4ixfac63wjzy6gsp6kwgxryb1k5nl3i0g99d5l"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-happy" ,ghc-happy)
- ("ghc-syb" ,ghc-syb)))
- (home-page
- "https://hackage.haskell.org/package/haskell-src")
- (synopsis
- "Support for manipulating Haskell source code")
- (description
- "The @code{haskell-src} package provides support for manipulating Haskell
-source code. The package provides a lexer, parser and pretty-printer, and a
-definition of a Haskell abstract syntax tree (AST). Common uses of this
-package are to parse or generate Haskell 98 code.")
- (license license:bsd-3)))
-
-(define-public ghc-alex
- (package
- (name "ghc-alex")
- (version "3.2.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/alex/alex-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0cpjixgsr0b2x4s6hz4aa6gnmjw9i7xd9nlfi8m37zqlidq4v3nm"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'check 'set-check-variables
- (lambda _
- (setenv "PATH" (string-append (getcwd) "/dist/build/alex:"
- (getenv "PATH")))
- (setenv "alex_datadir" (string-append (getcwd) "/data"))
- #t)))))
- (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
- (native-inputs
- `(("which" ,which)))
- (home-page "https://www.haskell.org/alex/")
- (synopsis
- "Tool for generating lexical analysers in Haskell")
- (description
- "Alex is a tool for generating lexical analysers in Haskell. It takes a
-description of tokens based on regular expressions and generates a Haskell
-module containing code for scanning text efficiently. It is similar to the
-tool lex or flex for C/C++.")
- (license license:bsd-3)))
-
-(define-public ghc-cgi
- (package
- (name "ghc-cgi")
- (version "3001.3.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/cgi/cgi-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1hbpplss1m4rdpm4ibip6fpimlhssqa14fl338kl2jbc463i64cj"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "cgi.cabal"
- (("exceptions < 0\\.9")
- "exceptions < 0.11")
- (("time >= 1\\.5 && < 1\\.7")
- "time >= 1.5 && < 1.9")
- (("doctest >= 0\\.8 && < 0\\.12")
- "doctest >= 0.8 && < 0.17")
- (("QuickCheck >= 2\\.8\\.1 && < 2\\.10")
- "QuickCheck >= 2.8.1 && < 2.12")))))))
- (inputs
- `(("ghc-exceptions" ,ghc-exceptions)
- ("ghc-multipart" ,ghc-multipart)
- ("ghc-network-uri" ,ghc-network-uri)
- ("ghc-network" ,ghc-network)))
- (native-inputs
- `(("ghc-doctest" ,ghc-doctest)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page
- "https://github.com/cheecheeo/haskell-cgi")
- (synopsis "Library for writing CGI programs")
- (description
- "This is a Haskell library for writing CGI programs.")
- (license license:bsd-3)))
-
-(define-public ghc-cmdargs
- (package
- (name "ghc-cmdargs")
- (version "0.10.20")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/cmdargs/cmdargs-"
- version ".tar.gz"))
- (sha256
- (base32
- "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf"))))
- (build-system haskell-build-system)
- (home-page
- "http://community.haskell.org/~ndm/cmdargs/")
- (synopsis "Command line argument processing")
- (description
- "This library provides an easy way to define command line parsers.")
- (license license:bsd-3)))
-
-(define-public ghc-concatenative
- (package
- (name "ghc-concatenative")
- (version "1.0.1")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/concatenative/concatenative-"
- version ".tar.gz"))
- (sha256
- (base32
- "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd"))))
- (build-system haskell-build-system)
- (home-page
- "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty")
- (synopsis "Library for postfix control flow")
- (description
- "Concatenative gives Haskell Factor-style combinators and arrows for
-postfix notation. For more information on stack based languages, see
-@uref{https://concatenative.org}.")
- (license license:bsd-3)))
-
-(define-public ghc-happy
- (package
- (name "ghc-happy")
- (version "1.19.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/happy/happy-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "138xpxdb7x62lpmgmb6b3v3vgdqqvqn4273jaap3mjmc2gla709y"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'skip-test-issue93
- (lambda _
- ;; Tests run out of memory on a system with 2GB of available RAM,
- ;; in 'issue93.a.hs' and 'issue93.n.hs'.
- (substitute* "tests/Makefile"
- ((" issue93.y ") " "))
- #t)))))
- (home-page "https://hackage.haskell.org/package/happy")
- (synopsis "Parser generator for Haskell")
- (description "Happy is a parser generator for Haskell. Given a grammar
-specification in BNF, Happy generates Haskell code to parse the grammar.
-Happy works in a similar way to the yacc tool for C.")
- (license license:bsd-3)))
-
-(define-public ghc-haskell-lexer
- (package
- (name "ghc-haskell-lexer")
- (version "1.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/haskell-lexer/haskell-lexer-"
- version ".tar.gz"))
- (sha256
- (base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
- (build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/haskell-lexer")
- (synopsis "Fully compliant Haskell 98 lexer")
- (description
- "This package provides a fully compliant Haskell 98 lexer.")
- (license license:bsd-3)))
-
-(define-public ghc-pretty-show
- (package
- (name "ghc-pretty-show")
- (version "1.7")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/pretty-show/"
- "pretty-show-" version ".tar.gz"))
- (sha256
- (base32
- "0br7pkxqqqhby2j2v1g847lgqsrasx56g1jw3dhmjh4flzs6warq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-haskell-lexer" ,ghc-haskell-lexer)
- ("ghc-happy" ,ghc-happy)))
- (home-page "http://wiki.github.com/yav/pretty-show")
- (synopsis "Tools for working with derived `Show` instances")
- (description
- "This package provides a library and an executable for working with
-derived @code{Show} instances. By using the library, derived @code{Show}
-instances can be parsed into a generic data structure. The @code{ppsh} tool
-uses the library to produce human-readable versions of @code{Show} instances,
-which can be quite handy for debugging Haskell programs. We can also render
-complex generic values into an interactive Html page, for easier
-examination.")
- (license license:expat)))
-
-(define-public ghc-haskell-src-exts
- (package
- (name "ghc-haskell-src-exts")
- (version "1.20.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1sm3z4v1p5yffg01ldgavz71s3bvfhjfa13k428rk14bpkl8crlz"))))
- (build-system haskell-build-system)
- (inputs
- `(("cpphs" ,cpphs)
- ("ghc-happy" ,ghc-happy)
- ("ghc-pretty-show" ,ghc-pretty-show)))
- (native-inputs
- `(("ghc-smallcheck" ,ghc-smallcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
- ("ghc-tasty-golden" ,ghc-tasty-golden)))
- (home-page "https://github.com/haskell-suite/haskell-src-exts")
- (synopsis "Library for manipulating Haskell source")
- (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
-extension of the standard @code{haskell-src} package, and handles most
-registered syntactic extensions to Haskell. All extensions implemented in GHC
-are supported. Apart from these standard extensions, it also handles regular
-patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
- (license license:bsd-3)))
-
-(define-public ghc-haskell-src-exts-util
- (package
- (name "ghc-haskell-src-exts-util")
- (version "0.2.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "haskell-src-exts-util/haskell-src-exts-util-"
- version ".tar.gz"))
- (sha256
- (base32
- "1803718paq89f8pdck4mb88hv2k1ah9lxzq0lgjgwi9n88ryycz8"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-data-default" ,ghc-data-default)
- ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-uniplate" ,ghc-uniplate)))
- (home-page "https://github.com/pepeiborra/haskell-src-exts-util")
- (synopsis "Helper functions for working with haskell-src-exts trees")
- (description
- "This package provides helper functions for working with
-@code{haskell-src-exts} trees.")
- (license license:bsd-3)))
-
-(define-public ghc-refact
- (package
- (name "ghc-refact")
- (version "0.3.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "refact/refact-"
- version ".tar.gz"))
- (sha256
- (base32
- "0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
- (build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/refact")
- (synopsis "Specify refactorings to perform with apply-refact")
- (description
- "This library provides a datatype which can be interpreted by
-@code{apply-refact}. It exists as a separate library so that applications can
-specify refactorings without depending on GHC.")
- (license license:bsd-3)))
-
-(define-public ghc-resourcet
- (package
- (name "ghc-resourcet")
- (version "1.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/resourcet/"
- "resourcet-" version ".tar.gz"))
- (sha256
- (base32
- "0rzjzh34s36ssign7akqjnwnjxf11c3511wk7ky0xxy0dqmc2rg7"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-mmorph" ,ghc-mmorph)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-unliftio-core" ,ghc-unliftio-core)))
- (native-inputs
- `(("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-hspec" ,ghc-hspec)))
- (home-page "https://github.com/snoyberg/conduit")
- (synopsis "Deterministic allocation and freeing of scarce resources")
- (description "ResourceT is a monad transformer which creates a region of
-code where you can safely allocate resources.")
- (license license:bsd-3)))
-
-(define-public ghc-objectname
- (package
- (name "ghc-objectname")
- (version "1.1.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/ObjectName/ObjectName-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "046jm94rmm46cicd31pl54vdvfjvhd9ffbfycy2lxzc0fliyznvj"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/ObjectName")
- (synopsis "Helper library for Haskell OpenGL")
- (description "This tiny package contains the class ObjectName, which
-corresponds to the general notion of explicitly handled identifiers for API
-objects, e.g. a texture object name in OpenGL or a buffer object name in
-OpenAL.")
- (license license:bsd-3)))
-
-(define-public ghc-sdl
- (package
- (name "ghc-sdl")
- (version "0.6.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/SDL/SDL-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "00y67v80a8l09i3k76z09lg25kw72ivl09nag8ckdlk4a0cfnzfq"))))
- (build-system haskell-build-system)
- (inputs
- `(("sdl" ,sdl)))
- (home-page "https://hackage.haskell.org/package/SDL")
- (synopsis "LibSDL for Haskell")
- (description "Simple DirectMedia Layer (libSDL) is a cross-platform
-multimedia library designed to provide low level access to audio, keyboard,
-mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
-by MPEG playback software, emulators, and many popular games, including the
-award winning Linux port of \"Civilization: Call To Power.\"")
- (license license:bsd-3)))
-
-(define-public ghc-sdl-mixer
- (package
- (name "ghc-sdl-mixer")
- (version "0.6.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0k26hqgdh789ka3mv4dsk6rin6x6vwcs6hjmnsqq7j3mnrh1342r"))))
- (build-system haskell-build-system)
- (arguments
- `(#:configure-flags
- (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
- (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
- (list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
- (inputs
- `(("ghc-sdl" ,ghc-sdl)
- ("sdl-mixer" ,sdl-mixer)))
- (home-page "https://hackage.haskell.org/package/SDL-mixer")
- (synopsis "Haskell bindings to libSDL_mixer")
- (description "SDL_mixer is a sample multi-channel audio mixer library. It
-supports any number of simultaneously playing channels of 16 bit stereo audio,
-plus a single channel of music, mixed by the popular MikMod MOD, Timidity
-MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
- (license license:bsd-3)))
-
-(define-public ghc-sdl-image
- (package
- (name "ghc-sdl-image")
- (version "0.6.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/SDL-image/SDL-image-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1gxwrvswgwjw6g7ym52gik22l9l3ljy592phv97jdmcf3gi6qcg1"))))
- (build-system haskell-build-system)
- (arguments
- `(#:configure-flags
- (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
- (sdl-image-include (string-append sdl-image "/include/SDL")))
- (list (string-append "--extra-include-dirs=" sdl-image-include)))))
- (inputs
- `(("ghc-sdl" ,ghc-sdl)
- ("sdl-image" ,sdl-image)))
- (home-page "https://hackage.haskell.org/package/SDL-image")
- (synopsis "Haskell bindings to libSDL_image")
- (description "SDL_image is an image file loading library. It loads images
-as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
-PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
- (license license:bsd-3)))
-
-(define-public ghc-half
- (package
- (name "ghc-half")
- (version "0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/half/half-"
- version ".tar.gz"))
- (sha256
- (base32
- "14r0nx8hm5fic9gz0ybjjw4kyc758zfgvhhwvzsshpx5caq6zch6"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/ekmett/half")
- (synopsis "Half-precision floating-point computations")
- (description "This library provides a half-precision floating-point
-computation library for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-fixed
- (package
- (name "ghc-fixed")
- (version "0.2.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/fixed/fixed-"
- version ".tar.gz"))
- (sha256
- (base32
- "1qhmwx8iqshns0crmr9d2f8hm65jxbcp3dvv0c39v34ra7if3a94"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/ekmett/fixed")
- (synopsis "Signed 15.16 precision fixed point arithmetic")
- (description
- "This package provides functions for signed 15.16 precision fixed point
-arithmetic.")
- (license license:bsd-3)))
-
-(define-public ghc-openglraw
- (package
- (name "ghc-openglraw")
- (version "3.3.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1x8w3x308jldj2c1xqcq3a3sc2jc06pdpgqkgjsmixi1skv4a1vb"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-half" ,ghc-half)
- ("ghc-fixed" ,ghc-fixed)
- ("glu" ,glu)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
- (synopsis "Raw Haskell bindings for the OpenGL graphics system")
- (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
-graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
-of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
-offers access to all necessary functions, tokens and types plus a general
-facility for loading extension entries. The module hierarchy closely mirrors
-the naming structure of the OpenGL extensions, making it easy to find the
-right module to import. All API entries are loaded dynamically, so no special
-C header files are needed for building this package. If an API entry is not
-found at runtime, a userError is thrown.")
- (license license:bsd-3)))
-
-(define-public ghc-glut
- (package
- (name "ghc-glut")
- (version "2.7.0.14")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/GLUT/GLUT-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "01i162fly4q1751fp60lgkzlb8kr0qqbvmxj74zc6skb19qggy2w"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-statevar" ,ghc-statevar)
- ("ghc-opengl" ,ghc-opengl)
- ("ghc-openglraw" ,ghc-openglraw)
- ("freeglut" ,freeglut)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
- (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
- (description "This library provides Haskell bindings for the OpenGL
-Utility Toolkit, a window system-independent toolkit for writing OpenGL
-programs.")
- (license license:bsd-3)))
-
-(define-public ghc-gluraw
- (package
- (name "ghc-gluraw")
- (version "2.0.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/GLURaw/GLURaw-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-openglraw" ,ghc-openglraw)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
- (synopsis "Raw Haskell bindings GLU")
- (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
-utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
-basis for a nicer interface.")
- (license license:bsd-3)))
-
-(define-public ghc-opengl
- (package
- (name "ghc-opengl")
- (version "3.0.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/OpenGL/OpenGL-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "19vxwvx2n8zq2klj176l25n2b64ybp0b8mhm4p46gvpcivz41fjc"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-objectname" ,ghc-objectname)
- ("ghc-gluraw" ,ghc-gluraw)
- ("ghc-statevar" ,ghc-statevar)
- ("ghc-openglraw" ,ghc-openglraw)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
- (synopsis "Haskell bindings for the OpenGL graphics system")
- (description "This package provides Haskell bindings for the OpenGL
-graphics system (GL, version 4.5) and its accompanying utility library (GLU,
-version 1.3).")
- (license license:bsd-3)))
-
-(define-public ghc-streaming-commons
- (package
- (name "ghc-streaming-commons")
- (version "0.2.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "streaming-commons/streaming-commons-"
- version ".tar.gz"))
- (sha256
- (base32
- "1lmyx3wkjsayhy5yilzvy0kf8qwmycwlk26r1d8f3cxbfhkr7s52"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-network" ,ghc-network)
- ("ghc-random" ,ghc-random)
- ("ghc-zlib" ,ghc-zlib)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/streaming-commons")
- (synopsis "Conduit and pipes needed by some streaming data libraries")
- (description "This package provides low-dependency functionality commonly
-needed by various Haskell streaming data libraries, such as @code{conduit} and
-@code{pipe}s.")
- (license license:expat)))
-
-(define-public ghc-reflection
- (package
- (name "ghc-reflection")
- (version "2.1.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/reflection/reflection-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0kf4a5ijw6jfnfibjcrpdy9vzh1n6v2pxia8dhyyqdissiwc8bzj"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-tagged" ,ghc-tagged)))
- (home-page "https://github.com/ekmett/reflection")
- (synopsis "Reify arbitrary terms into types that can be reflected back
-into terms")
- (description "This package addresses the 'configuration problem' which is
-propagating configurations that are available at run-time, allowing multiple
-configurations to coexist without resorting to mutable global variables or
-@code{System.IO.Unsafe.unsafePerformIO}.")
- (license license:bsd-3)))
-
-(define-public ghc-old-locale
- (package
- (name "ghc-old-locale")
- (version "1.0.0.7")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/old-locale/old-locale-"
- version
- ".tar.gz"))
- (sha256
- (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "04b9vn007hlvsrx4ksd3r8r3kbyaj2kvwxchdrmd4370qzi8p6gs")))
- (home-page "https://hackage.haskell.org/package/old-locale")
- (synopsis "Adapt to locale conventions")
- (description
- "This package provides the ability to adapt to locale conventions such as
-date and time formats.")
- (license license:bsd-3)))
-
-(define-public ghc-old-time
- (package
- (name "ghc-old-time")
- (version "1.1.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/old-time/old-time-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "1j6ln1dkvhdvnwl33bp0xf9lhc4sybqk0aw42p8cq81xwwzbn7y9")))
- (inputs
- `(("ghc-old-locale" ,ghc-old-locale)))
- (home-page "https://hackage.haskell.org/package/old-time")
- (synopsis "Time compatibility library for Haskell")
- (description "Old-time is a package for backwards compatibility with the
-old @code{time} library. For new projects, the newer
-@uref{https://hackage.haskell.org/package/time, time library} is recommended.")
- (license license:bsd-3)))
-
-(define-public ghc-data-default-instances-old-locale
- (package
- (name "ghc-data-default-instances-old-locale")
- (version "0.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "data-default-instances-old-locale/"
- "data-default-instances-old-locale-" version ".tar.gz"))
- (sha256
- (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-old-locale" ,ghc-old-locale)))
- (home-page
- "https://hackage.haskell.org/package/data-default-instances-old-locale")
- (synopsis "Default instances for types in old-locale")
- (description "Provides Default instances for types from the old-locale
- package.")
- (license license:bsd-3)))
-
-(define-public ghc-dlist
- (package
- (name "ghc-dlist")
- (version "0.8.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/dlist/dlist-"
- version
- ".tar.gz"))
- (sha256
- (base32 "0yirrh0s6acjy9hhvf5fqg2d6q5y6gm9xs04v6w1imndh1xqdwdc"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/spl/dlist")
- (synopsis "Difference lists")
- (description
- "Difference lists are a list-like type supporting O(1) append. This is
-particularly useful for efficient logging and pretty printing (e.g. with the
-Writer monad), where list append quickly becomes too expensive.")
- (license license:bsd-3)))
-
-(define-public ghc-extensible-exceptions
- (package
- (name "ghc-extensible-exceptions")
- (version "0.1.1.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "extensible-exceptions/extensible-exceptions-"
- version ".tar.gz"))
- (sha256
- (base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/extensible-exceptions")
- (synopsis "Extensible exceptions for Haskell")
- (description
- "This package provides extensible exceptions for both new and old
-versions of GHC (i.e., < 6.10).")
- (license license:bsd-3)))
-
-(define-public ghc-echo
- (package
- (name "ghc-echo")
- (version "0.1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/echo/echo-"
- version ".tar.gz"))
- (sha256
- (base32
- "1vw5ykpwhr39wc0hhcgq3r8dh59zq6ib4zxbz1qd2wl21wqhfkvh"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l")))
- (home-page "https://github.com/RyanGlScott/echo")
- (synopsis "Echo terminal input portably")
- (description "The @code{base} library exposes the @code{hGetEcho} and
-@code{hSetEcho} functions for querying and setting echo status, but
-unfortunately, neither function works with MinTTY consoles on Windows.
-This library provides an alternative interface which works with both
-MinTTY and other consoles.")
- (license license:bsd-3)))
-
-(define-public ghc-hackage-security
- (package
- (name "ghc-hackage-security")
- (version "0.5.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hackage-security/hackage-security-"
- version ".tar.gz"))
- (sha256
- (base32
- "08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v"))))
- (build-system haskell-build-system)
- (arguments
- `(#:tests? #f)) ; Tests fail because of framework updates.
- (inputs
- `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256)
- ("ghc-ed25519" ,ghc-ed25519)
- ("ghc-network" ,ghc-network)
- ("ghc-network-uri" ,ghc-network-uri)
- ("ghc-tar" ,ghc-tar)
- ("ghc-zlib" ,ghc-zlib)))
- (native-inputs
- `(("ghc-network-uri" ,ghc-network-uri)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tar" ,ghc-tar)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-zlib" ,ghc-zlib)))
- (home-page "https://github.com/haskell/hackage-security")
- (synopsis "Hackage security library")
- (description "This Hackage security library provides both server and
-client utilities for securing @uref{http://hackage.haskell.org/, the
-Hackage package server}. It is based on
-@uref{http://theupdateframework.com/, The Update Framework}, a set of
-recommendations developed by security researchers at various universities
-in the US as well as developers on the @uref{https://www.torproject.org/,
-Tor project}.")
- (license license:bsd-3)))
-
-(define-public ghc-resolv
- (package
- (name "ghc-resolv")
- (version "0.1.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/resolv/resolv-"
- version ".tar.gz"))
- (sha256
- (base32
- "0wh7wj56l3f2bylz563g5g04a4nydj8acv60hpwa7k3mn792xca9"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "15ay4n3x8c09cb3h4z1nan84yd3n9zpgvi6h114hk98bq10k8mma")
- #:tests? #f)) ; The required test frameworks are too old.
- (inputs
- `(("ghc-base16-bytestring" ,ghc-base16-bytestring)))
- (home-page "https://github.com/haskell/hackage-security")
- (synopsis "Domain Name Service (DNS) lookup via @code{libresolv}")
- (description "This package implements an API for accessing the
-@uref{https://tools.ietf.org/html/rfc1035, Domain Name Service (DNS)}
-resolver service via the standard @code{libresolv} system library (whose
-API is often available directly via the standard @code{libc} C library) on
-Unix systems.")
- (license license:gpl3)))
-
-(define-public ghc-parsec-numbers
- (package
- (name "ghc-parsec-numbers")
- (version "0.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "parsec-numbers/parsec-numbers-" version ".tar.gz"))
- (sha256
- (base32 "1gzy4v3r02kvdxvgg1nj83mmb6aph2v4ilf9c7y6nbvi2x49l0bp"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/parsec-numbers")
- (synopsis "Utilities for parsing numbers from strings")
- (description
- "This package provides the number parsers without the need to use a large
-(and unportable) token parser.")
- (license license:bsd-3)))
-
-(define-public ghc-paths
- (package
- (name "ghc-paths")
- (version "0.1.0.9")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/ghc-paths/ghc-paths-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/simonmar/ghc-paths")
- (synopsis
- "Knowledge of GHC's installation directories")
- (description
- "Knowledge of GHC's installation directories.")
- (license license:bsd-3)))
-
-(define-public ghc-utf8-string
- (package
- (name "ghc-utf8-string")
- (version "1.0.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/utf8-string/utf8-string-"
- version
- ".tar.gz"))
- (sha256
- (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("3" "02vhj5gykkqa2dyn7s6gn8is1b5fdn9xcqqvlls268g7cpv6rk38")))
- (home-page "https://github.com/glguy/utf8-string/")
- (synopsis "Support for reading and writing UTF8 Strings")
- (description
- "A UTF8 layer for Strings. The utf8-string package provides operations
-for encoding UTF8 strings to Word8 lists and back, and for reading and writing
-UTF8 without truncation.")
- (license license:bsd-3)))
-
-(define-public ghc-setenv
- (package
- (name "ghc-setenv")
- (version "0.1.1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/setenv/setenv-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/setenv")
- (synopsis "Library for setting environment variables")
- (description "This package provides a Haskell library for setting
-environment variables.")
- (license license:expat)))
-
-(define-public ghc-setlocale
- (package
- (name "ghc-setlocale")
- (version "1.0.0.8")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/setlocale-"
- version "/setlocale-" version ".tar.gz"))
- (sha256
- (base32
- "0sdrsmkhw08483d73ysgm2926fdbhii61br03lqpqw0lfzj4ilbd"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/setlocale")
- (synopsis "Haskell bindings to setlocale")
- (description "This package provides Haskell bindings to the
-@code{setlocale} C function.")
- (license license:bsd-3)))
-
-(define-public ghc-x11
- (package
- (name "ghc-x11")
- (version "1.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/X11/"
- "X11-" version ".tar.gz"))
- (sha256
- (base32 "1f8dy6ckkyvpcv7zlniyv01cqjb9lgqscm8pml58cvwc7n38w4qh"))))
- (build-system haskell-build-system)
- (inputs
- `(("libx11" ,libx11)
- ("libxrandr" ,libxrandr)
- ("libxinerama" ,libxinerama)
- ("libxscrnsaver" ,libxscrnsaver)
- ("ghc-data-default" ,ghc-data-default)))
- (home-page "https://github.com/haskell-pkg-janitors/X11")
- (synopsis "Bindings to the X11 graphics library")
- (description
- "This package provides Haskell bindings to the X11 graphics library. The
-bindings are a direct translation of the C bindings.")
- (license license:bsd-3)))
-
-(define-public ghc-x11-xft
- (package
- (name "ghc-x11-xft")
- (version "0.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/X11-xft/"
- "X11-xft-" version ".tar.gz"))
- (sha256
- (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
- (inputs
- `(("ghc-x11" ,ghc-x11)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("libx11" ,libx11)
- ("libxft" ,libxft)
- ("xorgproto" ,xorgproto)))
- (native-inputs
- `(("pkg-config" ,pkg-config)))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/X11-xft")
- (synopsis "Bindings to Xft")
- (description
- "Bindings to the Xft, X Free Type interface library, and some Xrender
-parts.")
- (license license:lgpl2.1)))
-
-(define-public ghc-stringbuilder
- (package
- (name "ghc-stringbuilder")
- (version "0.5.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/stringbuilder/stringbuilder-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1fh3csx1wcssn8xyvl4ip4aprh9l4qyz2kk8mgjvqvc0vb2bsy6q"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
- ; enabled
- (home-page "https://hackage.haskell.org/package/stringbuilder")
- (synopsis "Writer monad for multi-line string literals")
- (description "This package provides a writer monad for multi-line string
-literals.")
- (license license:expat)))
-
-(define-public ghc-zlib
- (package
- (name "ghc-zlib")
- (version "0.6.2")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/zlib/zlib-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1vbzf0awb6zb456xf48za1kl22018646cfzq4frvxgb9ay97vk0d"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'strip-test-framework-constraints
- (lambda _
- (substitute* "zlib.cabal"
- (("tasty >= 0\\.8 && < 0\\.12") "tasty")
- (("tasty-hunit >= 0\\.8 && < 0\\.10") "tasty-hunit")
- (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
- (inputs `(("zlib" ,zlib)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://hackage.haskell.org/package/zlib")
- (synopsis
- "Compression and decompression in the gzip and zlib formats")
- (description
- "This package provides a pure interface for compressing and decompressing
-streams of data represented as lazy @code{ByteString}s. It uses the zlib C
-library so it has high performance. It supports the @code{zlib}, @code{gzip}
-and @code{raw} compression formats. It provides a convenient high level API
-suitable for most tasks and for the few cases where more control is needed it
-provides access to the full zlib feature set.")
- (license license:bsd-3)))
-
-(define-public ghc-parallel
- (package
- (name "ghc-parallel")
- (version "3.2.2.0")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/parallel/parallel-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1xkfi96w6yfpppd0nw1rnszdxmvifwzm699ilv6332ra3akm610p"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/parallel")
- (synopsis "Parallel programming library")
- (description
- "This package provides a library for parallel programming.")
- (license license:bsd-3)))
-
-(define-public ghc-safesemaphore
- (package
- (name "ghc-safesemaphore")
- (version "0.10.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "SafeSemaphore/SafeSemaphore-" version ".tar.gz"))
- (sha256
- (base32
- "0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/ChrisKuklewicz/SafeSemaphore")
- (synopsis "Exception safe semaphores")
- (description "This library provides exception safe semaphores that can be
-used in place of @code{QSem}, @code{QSemN}, and @code{SampleVar}, all of which
-are not exception safe and can be broken by @code{killThread}.")
- (license license:bsd-3)))
-
-(define-public ghc-text-binary
- (package
- (name "ghc-text-binary")
- (version "0.2.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "text-binary/text-binary-"
- version ".tar.gz"))
- (sha256
- (base32
- "18gl10pwg3qwsk0za3c70j4n6a9129wwf1b7d3a461h816yv55xn"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/kawu/text-binary")
- (synopsis "Binary instances for text types")
- (description
- "This package provides a compatibility layer providing @code{Binary}
-instances for strict and lazy text types for versions older than 1.2.1 of the
-text package.")
- (license license:bsd-2)))
-
-(define-public ghc-strict
- (package
- (name "ghc-strict")
- (version "0.3.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/strict/strict-"
- version ".tar.gz"))
- (sha256
- (base32 "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/strict")
- (synopsis "Strict data types and String IO")
- (description
- "This package provides strict versions of some standard Haskell data
-types, such as pairs, @code{Maybe} and @code{Either}. It also contains strict
-IO operations.")
- (license license:bsd-3)))
-
-(define-public ghc-hashable
- (package
- (name "ghc-hashable")
- (version "1.2.7.0")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hashable/hashable-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1gra8gq3kb7b2sd845h55yxlrfqx3ii004c6vjhga8v0b30fzdgc"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-random" ,ghc-random)))
- (native-inputs
- `(("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/tibbe/hashable")
- (synopsis "Class for types that can be converted to a hash value")
- (description
- "This package defines a class, @code{Hashable}, for types that can be
-converted to a hash value. This class exists for the benefit of hashing-based
-data structures. The package provides instances for basic types and a way to
-combine hash values.")
- (license license:bsd-3)))
-
-(define-public ghc-hashable-bootstrap
- (package
- (inherit ghc-hashable)
- (name "ghc-hashable-bootstrap")
- (arguments `(#:tests? #f))
- (native-inputs '())
- (properties '((hidden? #t)))))
-
-(define-public ghc-hashable-time
- (package
- (name "ghc-hashable-time")
- (version "0.2.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hashable-time/hashable-time-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0k932nyd08l3xxbh2g3n76py2f4kd9yw4s5a065vjz0xp6wjnxdm"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "0rv40xkg3gj8jnqsry1gq3f5s5la6d5arg8fzkirnwdpcgha1as6")))
- (inputs `(("ghc-hashable" ,ghc-hashable)))
- (home-page "http://hackage.haskell.org/package/hashable-time")
- (synopsis "Hashable instances for Data.Time")
- (description
- "This package provides @code{Hashable} instances for types in
-@code{Data.Time}.")
- (license license:bsd-3)))
-
-(define-public ghc-data-hash
- (package
- (name "ghc-data-hash")
- (version "0.2.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/data-hash"
- "/data-hash-" version ".tar.gz"))
- (sha256
- (base32 "1ghbqvc48gf9p8wiy71hdpaj7by3b9cw6wgwi3qqz8iw054xs5wi"))))
- (build-system haskell-build-system)
- (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/data-hash")
- (synopsis "Combinators for building fast hashing functions")
- (description
- "This package provides combinators for building fast hashing functions.
-It includes hashing functions for all basic Haskell98 types.")
- (license license:bsd-3)))
-
-(define-public ghc-murmur-hash
- (package
- (name "ghc-murmur-hash")
- (version "0.1.0.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/murmur-hash"
- "/murmur-hash-" version ".tar.gz"))
- (sha256
- (base32 "1bb58kfnzvx3mpc0rc0dhqc1fk36nm8prd6gvf20gk6lxaadpfc9"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/nominolo/murmur-hash")
- (synopsis "MurmurHash2 implementation for Haskell")
- (description
- "This package provides an implementation of MurmurHash2, a good, fast,
-general-purpose, non-cryptographic hashing function. See
-@url{https://sites.google.com/site/murmurhash/} for details. This
-implementation is pure Haskell, so it might be a bit slower than a C FFI
-binding.")
- (license license:bsd-3)))
-
-(define-public ghc-random
- (package
- (name "ghc-random")
- (version "1.1")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/random/random-"
- version
- ".tar.gz"))
- (sha256
- (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/random")
- (synopsis "Random number library")
- (description "This package provides a basic random number generation
-library, including the ability to split random number generators.")
- (license license:bsd-3)))
-
-(define-public ghc-primitive
- (package
- (name "ghc-primitive")
- (version "0.6.4.0")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/primitive/primitive-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0r0cda7acvplgwaxy69kviv4jp7kkfi038by68gj4yfx4iwszgjc"))))
- (build-system haskell-build-system)
- (home-page
- "https://github.com/haskell/primitive")
- (synopsis "Primitive memory-related operations")
- (description
- "This package provides various primitive memory-related operations.")
- (license license:bsd-3)))
-
-(define-public ghc-tf-random
- (package
- (name "ghc-tf-random")
- (version "0.5")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/tf-random/tf-random-"
- version
- ".tar.gz"))
- (sha256
- (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-primitive" ,ghc-primitive)
- ("ghc-random" ,ghc-random)))
- (home-page "https://hackage.haskell.org/package/tf-random")
- (synopsis "High-quality splittable pseudorandom number generator")
- (description "This package contains an implementation of a high-quality
-splittable pseudorandom number generator. The generator is based on a
-cryptographic hash function built on top of the ThreeFish block cipher. See
-the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
-Hashing\" by Claessen, Pałka for details and the rationale of the design.")
- (license license:bsd-3)))
-
-(define-public ghc-transformers-base
- (package
- (name "ghc-transformers-base")
- (version "0.4.5.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/transformers-base/transformers-base-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page
- "https://hackage.haskell.org/package/transformers-compat")
- (synopsis
- "Backported transformer library")
- (description
- "Backported versions of types that were added to transformers in
-transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
-compatibility to run on old versions of the platform.")
- (license license:bsd-3)))
-
-(define-public ghc-transformers-compat
- (package
- (name "ghc-transformers-compat")
- (version "0.6.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/transformers-compat"
- "/transformers-compat-" version ".tar.gz"))
- (sha256
- (base32
- "1gp4a8kvniwgm8947ghb4iwv4b7wd6ry4kvv4nfnym4agf5j41nw"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/ekmett/transformers-compat/")
- (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
- (description "This package includes backported versions of types that were
-added to transformers in transformers 0.3 and 0.4 for users who need strict
-transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
-but also need those types.")
- (license license:bsd-3)))
-
-(define-public ghc-unix-time
- (package
- (name "ghc-unix-time")
- (version "0.3.8")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/unix-time/unix-time-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "051slgpid5cxiaw203ky0ql3823h28fcjs08axkzd4265wrvv8fw"))))
- (build-system haskell-build-system)
- (arguments
- `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
- ; is weird, that should be provided by GHC 7.10.2.
- (inputs
- `(("ghc-old-time" ,ghc-old-time)
- ("ghc-old-locale" ,ghc-old-locale)))
- (home-page "https://hackage.haskell.org/package/unix-time")
- (synopsis "Unix time parser/formatter and utilities")
- (description "This library provides fast parsing and formatting utilities
-for Unix time in Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-unix-compat
- (package
- (name "ghc-unix-compat")
- (version "0.5.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/unix-compat/unix-compat-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0llwl7rp63fy2ychwdclz1afj45pbin5pfl01dvn6rwhvmwhr7d3"))))
- (build-system haskell-build-system)
- (home-page
- "https://github.com/jystic/unix-compat")
- (synopsis "Portable POSIX-compatibility layer")
- (description
- "This package provides portable implementations of parts of the unix
-package. This package re-exports the unix package when available. When it
-isn't available, portable implementations are used.")
- (license license:bsd-3)))
-
-(define-public ghc-indents
- (package
- (name "ghc-indents")
- (version "0.5.0.0")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/indents/indents-"
- version ".tar.gz"))
- (sha256
- (base32
- "1ly3v41jacc6lrsvg4j3m5a6zs90gr8dyif5m6bf34hj1k5cgg0n"))))
- (build-system haskell-build-system)
- ;; This package needs an older version of tasty.
- (arguments '(#:tests? #f))
- (inputs
- `(("ghc-concatenative" ,ghc-concatenative)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "http://patch-tag.com/r/salazar/indents")
- (synopsis "Indentation sensitive parser-combinators for parsec")
- (description
- "This library provides functions for use in parsing indentation sensitive
-contexts. It parses blocks of lines all indented to the same level as well as
-lines continued at an indented level below.")
- (license license:bsd-3)))
-
-(define-public ghc-iproute
- (package
- (name "ghc-iproute")
- (version "1.7.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/iproute/iproute-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1vw1nm3s8vz1hqnjnqd3wh5rr4q3m2r4izn5ynhf93h9185qwqzd"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
- ; exported by ghc-byteorder. Doctest issue.
- (inputs
- `(("ghc-appar" ,ghc-appar)
- ("ghc-byteorder" ,ghc-byteorder)
- ("ghc-network" ,ghc-network)
- ("ghc-safe" ,ghc-safe)))
- (home-page "https://www.mew.org/~kazu/proj/iproute/")
- (synopsis "IP routing table")
- (description "IP Routing Table is a tree of IP ranges to search one of
-them on the longest match base. It is a kind of TRIE with one way branching
-removed. Both IPv4 and IPv6 are supported.")
- (license license:bsd-3)))
-
-(define-public ghc-iwlib
- (package
- (name "ghc-iwlib")
- (version "0.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/iwlib/iwlib-"
- version ".tar.gz"))
- (sha256
- (base32 "0khmfwql4vwj55idsxmhjhrbqzfir3g9wm5lmpvnf77mm95cfpdz"))))
- (build-system haskell-build-system)
- (inputs
- `(("wireless-tools" ,wireless-tools)))
- (home-page "https://github.com/jaor/iwlib")
- (synopsis "Haskell binding to the iw wireless networking library")
- (description
- "IWlib is a thin Haskell binding to the iw C library. It provides
-information about the current wireless network connections, and adapters on
-supported systems.")
- (license license:bsd-3)))
-
-(define-public ghc-regex-base
- (package
- (name "ghc-regex-base")
- (version "0.93.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-base/regex-base-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
- (build-system haskell-build-system)
- (home-page
- "https://sourceforge.net/projects/lazy-regex")
- (synopsis "Replaces/Enhances Text.Regex")
- (description "@code{Text.Regex.Base} provides the interface API for
-regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
- (license license:bsd-3)))
-
-(define-public ghc-regex-posix
- (package
- (name "ghc-regex-posix")
- (version "0.95.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-posix/regex-posix-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-base" ,ghc-regex-base)))
- (home-page "https://sourceforge.net/projects/lazy-regex")
- (synopsis "POSIX regular expressions for Haskell")
- (description "This library provides the POSIX regex backend used by the
-Haskell library @code{regex-base}.")
- (license license:bsd-3)))
-
-(define-public ghc-regex-compat
- (package
- (name "ghc-regex-compat")
- (version "0.95.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-compat/regex-compat-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-base" ,ghc-regex-base)
- ("ghc-regex-posix" ,ghc-regex-posix)))
- (home-page "https://sourceforge.net/projects/lazy-regex")
- (synopsis "Replaces/Enhances Text.Regex")
- (description "This library provides one module layer over
-@code{regex-posix} to replace @code{Text.Regex}.")
- (license license:bsd-3)))
-
-(define-public ghc-regex-tdfa-text
- (package
- (name "ghc-regex-tdfa-text")
- (version "1.0.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-tdfa-text/"
- "regex-tdfa-text-" version ".tar.gz"))
- (sha256
- (base32
- "0090g6lgbdm9lywpqm2d3724nnnh24nx3vnlqr96qc2w486pmmrq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-base" ,ghc-regex-base)
- ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
- (home-page
- "http://hackage.haskell.org/package/regex-tdfa-text")
- (synopsis "Text interface for regex-tdfa")
- (description
- "This provides an extra text interface for regex-tdfa.")
- (license license:bsd-3)))
-
-(define-public ghc-regex
- (package
- (name "ghc-regex")
- (version "1.0.1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/regex/"
- "regex-" version ".tar.gz"))
- (sha256
- (base32
- "1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'relax-dependencies
- (lambda _
- (substitute* "regex.cabal"
- (("base-compat.*>=.*0.6.*")
- "base-compat >= 0.6\n")
- (("template-haskell.*>=.*2.7.*")
- "template-haskell >= 2.7\n"))
- #t)))))
- (inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-regex-base" ,ghc-regex-base)
- ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
- ("ghc-regex-tdfa" ,ghc-regex-tdfa)
- ("ghc-regex-tdfa-text" ,ghc-regex-tdfa-text)
- ("ghc-time-locale-compat" ,ghc-time-locale-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-utf8-string" ,ghc-utf8-string)))
- (home-page "http://regex.uk")
- (synopsis "Toolkit for regex-base")
- (description
- "This package provides a regular expression toolkit for @code{regex-base}
-with compile-time checking of regular expression syntax, data types for
-matches and captures, a text replacement toolkit, portable options, high-level
-AWK-like tools for building text processing apps, regular expression macros
-with parsers and test bench, comprehensive documentation, tutorials and
-copious examples.")
- (license license:bsd-3)))
-
-(define-public ghc-parsers
- (package
- (name "ghc-parsers")
- (version "0.12.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/parsers/parsers-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1r05sc1mcglk8w596kq9a1brfn9c2vll8lq16j07ln0vsz4jzrc1"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
- ; -package attoparsec-0.13.0.1"
- (inputs
- `(("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-charset" ,ghc-charset)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (home-page "https://github.com/ekmett/parsers/")
- (synopsis "Parsing combinators")
- (description "This library provides convenient combinators for working
-with and building parsing combinator libraries. Given a few simple instances,
-you get access to a large number of canned definitions. Instances exist for
-the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
-@code{Text.Read}.")
- (license license:bsd-3)))
-
-(define-public ghc-trifecta
- (package
- (name "ghc-trifecta")
- (version "2")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/trifecta/"
- "trifecta-" version ".tar.gz"))
- (sha256
- (base32
- "0hznd8i65s81xy13i2qc7cvipw3lfb2yhkv53apbdsh6sbljz5sk"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; doctest suite fails to build on i686
- (inputs
- `(("ghc-reducers" ,ghc-reducers)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-charset" ,ghc-charset)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-fingertree" ,ghc-fingertree)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-lens" ,ghc-lens)
- ("ghc-parsers" ,ghc-parsers)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-utf8-string" ,ghc-utf8-string)))
- (native-inputs
- `(("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/ekmett/trifecta/")
- (synopsis "Parser combinator library with convenient diagnostics")
- (description "Trifecta is a modern parser combinator library for Haskell,
-with slicing and Clang-style colored diagnostics.")
- (license license:bsd-3)))
-
-(define-public ghc-time-locale-compat
- (package
- (name "ghc-time-locale-compat")
- (version "0.1.1.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "time-locale-compat/time-locale-compat-"
- version ".tar.gz"))
- (sha256
- (base32
- "0b2hmj8wwrfkndwzgm11qr496ca2ahwdxcj3m0ii91bxvrk1bzq7"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-old-locale" ,ghc-old-locale)))
- (home-page "https://github.com/khibino/haskell-time-locale-compat")
- (synopsis "Compatibility of TimeLocale between old-locale and time-1.5")
- (description "This package contains a wrapped name module for
-@code{TimeLocale}.")
- (license license:bsd-3)))
-
-(define-public ghc-attoparsec
- (package
- (name "ghc-attoparsec")
- (version "0.13.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/attoparsec/attoparsec-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0j6qcwd146yzlkc9mcvzvnixsyl65n2a68l28322q5v9p4g4g4yx"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-for-newer-quickcheck
- (lambda _
- (substitute* "attoparsec.cabal"
- (("QuickCheck >= 2\\.7 && < 2\\.10")
- "QuickCheck >= 2.7 && < 2.12"))
- ;; This test fails because of the newer QuickCheck:
- ;; <https://github.com/bos/attoparsec/issues/134>.
- (substitute* "tests/QC/ByteString.hs"
- ((", testProperty \"satisfyWith\" satisfyWith")
- "")))))))
- (inputs
- `(("ghc-scientific" ,ghc-scientific)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
- ("ghc-vector" ,ghc-vector)))
- (home-page "https://github.com/bos/attoparsec")
- (synopsis "Fast combinator parsing for bytestrings and text")
- (description "This library provides a fast parser combinator library,
-aimed particularly at dealing efficiently with network protocols and
-complicated text/binary file formats.")
- (license license:bsd-3)))
-
-(define-public ghc-attoparsec-bootstrap
- (package
- (inherit ghc-attoparsec)
- (name "ghc-attoparsec-bootstrap")
- (arguments `(#:tests? #f))
- (inputs
- `(("ghc-scientific" ,ghc-scientific-bootstrap)))
- (native-inputs '())
- (properties '(hidden? #t))))
-
-(define-public ghc-zip-archive
- (package
- (name "ghc-zip-archive")
- (version "0.3.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/zip-archive/zip-archive-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0kf8xyac168bng8a0za2jwrbss7a4ralvci9g54hnvl0gkkxx2lq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-digest" ,ghc-digest)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-zlib" ,ghc-zlib)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("unzip" ,unzip)))
- (home-page "https://hackage.haskell.org/package/zip-archive")
- (synopsis "Zip archive library for Haskell")
- (description "The zip-archive library provides functions for creating,
-modifying, and extracting files from zip archives in Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-distributive
- (package
- (name "ghc-distributive")
- (version "0.5.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/distributive/distributive-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0y566r97sfyvhsmd4yxiz4ns2mqgwf5bdbp56wgxl6wlkidq0wwi"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("6" "06bd38rf31yrvvy989r44pm0id3dsxwcp6nxg7wk6ccj3n2b8rzk")))
- (inputs
- `(("ghc-tagged" ,ghc-tagged)
- ("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-generic-deriving" ,ghc-generic-deriving)))
- (native-inputs
- `(("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/ekmett/distributive/")
- (synopsis "Distributive functors for Haskell")
- (description "This package provides distributive functors for Haskell.
-Dual to @code{Traversable}.")
- (license license:bsd-3)))
-
-(define-public ghc-cereal
- (package
- (name "ghc-cereal")
- (version "0.5.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/cereal/cereal-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1j7imh2mzqcljld7sx0av69699955rpy3hzivi5723i6a9nszgbs"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-fail" ,ghc-fail)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://hackage.haskell.org/package/cereal")
- (synopsis "Binary serialization library")
- (description "This package provides a binary serialization library,
-similar to @code{binary}, that introduces an @code{isolate} primitive for
-parser isolation, and labeled blocks for better error messages.")
- (license license:bsd-3)))
-
-(define-public ghc-comonad
- (package
- (name "ghc-comonad")
- (version "5.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/comonad/comonad-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "09g870c4flp4k3fgbibsd0mmfjani1qcpbcl685v8x89kxzrva3q"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)))
- (inputs
- `(("ghc-contravariant" ,ghc-contravariant)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/ekmett/comonad/")
- (synopsis "Comonads for Haskell")
- (description "This library provides @code{Comonad}s for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-polyparse
- (package
- (name "ghc-polyparse")
- (version "1.12")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/polyparse/polyparse-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "05dya1vdvq29hkhkdlsglzhw7bdn51rvs1javs0q75nf99c66k7m"))))
- (build-system haskell-build-system)
- (home-page
- "http://code.haskell.org/~malcolm/polyparse/")
- (synopsis
- "Alternative parser combinator libraries")
- (description
- "This package provides a variety of alternative parser combinator
-libraries, including the original HuttonMeijer set. The Poly sets have
-features like good error reporting, arbitrary token type, running state, lazy
-parsing, and so on. Finally, Text.Parse is a proposed replacement for the
-standard Read class, for better deserialisation of Haskell values from
-Strings.")
- (license license:lgpl2.1)))
-
-(define-public ghc-extra
- (package
- (name "ghc-extra")
- (version "1.6.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/extra/extra-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0xxcpb00pgwi9cmy6a7ghh6rblxry42p8pz5ssfgj20fs1xwzj1b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-clock" ,ghc-clock)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/ndmitchell/extra")
- (synopsis "Extra Haskell functions")
- (description "This library provides extra functions for the standard
-Haskell libraries. Most functions are simple additions, filling out missing
-functionality. A few functions are available in later versions of GHC, but
-this package makes them available back to GHC 7.2.")
- (license license:bsd-3)))
-
-(define-public ghc-profunctors
- (package
- (name "ghc-profunctors")
- (version "5.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/profunctors/profunctors-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0s1pwjidbn761xk43pmzyvn99hm3psdifjd78ylki7f97aiyd0g9"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "1ywlg9z8nlhd2avgb8c6gbkv8zyk7hvc25926bafyg0m0k8y1amq")))
- (inputs
- `(("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-tagged" ,ghc-tagged)))
- (home-page "https://github.com/ekmett/profunctors/")
- (synopsis "Profunctors for Haskell")
- (description "This library provides profunctors for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-reducers
- (package
- (name "ghc-reducers")
- (version "3.12.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/reducers/reducers-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "09wf8pl9ycglcv6qj5ba26gkg2s5iy81hsx9xp0q8na0cwvp71ki"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-fingertree" ,ghc-fingertree)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-semigroups" ,ghc-semigroups)))
- (home-page "https://github.com/ekmett/reducers/")
- (synopsis "Semigroups, specialized containers and a general map/reduce framework")
- (description "This library provides various semigroups, specialized
-containers and a general map/reduce framework for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-appar
- (package
- (name "ghc-appar")
- (version "0.1.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/appar/appar-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
- (build-system haskell-build-system)
- (home-page
- "https://hackage.haskell.org/package/appar")
- (synopsis "Simple applicative parser")
- (description "This package provides a simple applicative parser in Parsec
-style.")
- (license license:bsd-3)))
-
-(define-public ghc-safe
- (package
- (name "ghc-safe")
- (version "0.3.17")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/safe/safe-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0p3yaf5slvyz1cyy51jq64c5rlp8yzwim8iy2dlnk42if4gc9ibr"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/ndmitchell/safe#readme")
- (synopsis "Library of safe (exception free) functions")
- (description "This library provides wrappers around @code{Prelude} and
-@code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
-exceptions.")
- (license license:bsd-3)))
-
-(define-public ghc-generic-deriving
- (package
- (name "ghc-generic-deriving")
- (version "1.12.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/generic-deriving/generic-deriving-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1i7d6cpj9yhaqb79zays3nqchhaacacjz9bkc0zlwj73y5gvi22n"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-th-abstraction" ,ghc-th-abstraction)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/generic-deriving")
- (synopsis "Generalise the deriving mechanism to arbitrary classes")
- (description "This package provides functionality for generalising the
-deriving mechanism in Haskell to arbitrary classes.")
- (license license:bsd-3)))
-
-(define-public ghc-pcre-light
- (package
- (name "ghc-pcre-light")
- (version "0.4.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/pcre-light/pcre-light-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0xcyi1fivwg7a92mch5bcqzmrfxzqj42rmb3m8kgs61x4qwpxj82"))))
- (build-system haskell-build-system)
- (inputs
- `(("pcre" ,pcre)))
- (native-inputs
- `(("pkg-config" ,pkg-config)))
- (home-page "https://github.com/Daniel-Diaz/pcre-light")
- (synopsis "Haskell library for Perl 5 compatible regular expressions")
- (description "This package provides a small, efficient, and portable regex
-library for Perl 5 compatible regular expressions. The PCRE library is a set
-of functions that implement regular expression pattern matching using the same
-syntax and semantics as Perl 5.")
- (license license:bsd-3)))
-
-(define-public ghc-logict
- (package
- (name "ghc-logict")
- (version "0.6.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/logict/logict-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
- (build-system haskell-build-system)
- (home-page "http://code.haskell.org/~dolio/")
- (synopsis "Backtracking logic-programming monad")
- (description "This library provides a continuation-based, backtracking,
-logic programming monad. An adaptation of the two-continuation implementation
-found in the paper \"Backtracking, Interleaving, and Terminating Monad
-Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
-online}.")
- (license license:bsd-3)))
-
-(define-public ghc-xml
- (package
- (name "ghc-xml")
- (version "1.3.14")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/xml/xml-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
- (build-system haskell-build-system)
- (home-page "http://code.galois.com")
- (synopsis "Simple XML library for Haskell")
- (description "This package provides a simple XML library for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-feed
- (package
- (name "ghc-feed")
- (version "1.0.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "feed/feed-" version ".tar.gz"))
- (sha256
- (base32
- "05rgg7x1984mgfhkmz792xj8lhwjgznixhygzr8blf517lns2nck"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("4" "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d")))
- (inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-old-time" ,ghc-old-time)
- ("ghc-safe" ,ghc-safe)
- ("ghc-time-locale-compat" ,ghc-time-locale-compat)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-xml-conduit" ,ghc-xml-conduit)
- ("ghc-xml-types" ,ghc-xml-types)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://github.com/bergmark/feed")
- (synopsis "Haskell package for handling various syndication formats")
- (description "This Haskell package includes tools for generating and
-consuming feeds in both RSS (Really Simple Syndication) and Atom format.")
- (license license:bsd-3)))
-
-(define-public ghc-exceptions
- (package
- (name "ghc-exceptions")
- (version "0.10.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/exceptions/exceptions-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1ms9zansv0pwzwdjncvx4kf18lnkjy2p61hvjhvxmjx5bqp93p8y"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (inputs
- `(("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/ekmett/exceptions/")
- (synopsis "Extensible optionally-pure exceptions")
- (description "This library provides extensible optionally-pure exceptions
-for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-temporary
- (package
- (name "ghc-temporary")
- (version "1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/temporary/temporary-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "144qhwfwg37l3k313raf4ssiz16jbgwlm1nf4flgqpsbd69jji4c"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-exceptions" ,ghc-exceptions)
- ("ghc-random" ,ghc-random)))
- (native-inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "https://www.github.com/batterseapower/temporary")
- (synopsis "Temporary file and directory support")
- (description "The functions for creating temporary files and directories
-in the Haskelll base library are quite limited. This library just repackages
-the Cabal implementations of its own temporary file and folder functions so
-that you can use them without linking against Cabal or depending on it being
-installed.")
- (license license:bsd-3)))
-
-(define-public ghc-temporary-rc
- (package
- (name "ghc-temporary-rc")
- (version "1.2.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/temporary-rc/temporary-rc-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-exceptions" ,ghc-exceptions)))
- (home-page
- "https://www.github.com/feuerbach/temporary")
- (synopsis
- "Portable temporary file and directory support")
- (description
- "The functions for creating temporary files and directories in the base
-library are quite limited. The unixutils package contains some good ones, but
-they aren't portable to Windows. This library just repackages the Cabal
-implementations of its own temporary file and folder functions so that you can
-use them without linking against Cabal or depending on it being installed.
-This is a better maintained fork of the \"temporary\" package.")
- (license license:bsd-3)))
-
-(define-public ghc-smallcheck
- (package
- (name "ghc-smallcheck")
- (version "1.1.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/smallcheck/smallcheck-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "195fj7w3v03d1y1nm2ylavzrwxjcdbq0lb6zsw1dwyx5jmwfc84h"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-logict" ,ghc-logict)))
- (home-page
- "https://github.com/feuerbach/smallcheck")
- (synopsis "Property-based testing library")
- (description "SmallCheck is a testing library that allows to verify
-properties for all test cases up to some depth. The test cases are generated
-automatically by SmallCheck.")
- (license license:bsd-3)))
-
-(define-public ghc-silently
- (package
- (name "ghc-silently")
- (version "1.2.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/silently/silently-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ;; circular dependency with nanospec
- ;; (inputs
- ;; `(("ghc-temporary" ,ghc-temporary)))
- (home-page "https://github.com/hspec/silently")
- (synopsis "Prevent writing to stdout")
- (description "This package provides functions to prevent or capture
-writing to stdout and other handles.")
- (license license:bsd-3)))
-
-(define-public ghc-case-insensitive
- (package
- (name "ghc-case-insensitive")
- (version "1.2.0.11")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/case-insensitive/case-insensitive-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1qrpxfirsxckg7jv28f5ah2qc8lh95hp7rnqkbqs1ahcwlbnvkm7"))))
- (build-system haskell-build-system)
- ;; these inputs are necessary to use this library
- (inputs
- `(("ghc-hashable" ,ghc-hashable)))
- (arguments
- `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
- (home-page
- "https://github.com/basvandijk/case-insensitive")
- (synopsis "Case insensitive string comparison")
- (description
- "The module @code{Data.CaseInsensitive} provides the @code{CI} type
-constructor which can be parameterised by a string-like type like:
-@code{String}, @code{ByteString}, @code{Text}, etc. Comparisons of values of
-the resulting type will be insensitive to cases.")
- (license license:bsd-3)))
-
-(define-public ghc-syb
- (package
- (name "ghc-syb")
- (version "0.7")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/syb/syb-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1da2zz7gqm4xbkx5vpd74dayx1svaxyl145fl14mq15lbb77sxdq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page
- "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
- (synopsis "Scrap Your Boilerplate")
- (description "This package contains the generics system described in the
-/Scrap Your Boilerplate/ papers (see
-@uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It
-defines the @code{Data} class of types permitting folding and unfolding of
-constructor applications, instances of this class for primitive types, and a
-variety of traversals.")
- (license license:bsd-3)))
-
-(define-public ghc-fgl
- (package
- (name "ghc-fgl")
- (version "5.6.0.0")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/fgl/fgl-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1i6cp4b3w7sjk7y1dq3fh6bci2sm5h3lnbbaw9ln19nwncg2wwll"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "fgl.cabal"
- (("QuickCheck >= 2\\.8 && < 2\\.10")
- "QuickCheck >= 2.8 && < 2.12")
- (("hspec >= 2\\.1 && < 2\\.5")
- "hspec >= 2.1 && < 2.6")))))))
- (inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell")
- (synopsis
- "Martin Erwig's Functional Graph Library")
- (description "The functional graph library, FGL, is a collection of type
-and function definitions to address graph problems. The basis of the library
-is an inductive definition of graphs in the style of algebraic data types that
-encourages inductive, recursive definitions of graph algorithms.")
- (license license:bsd-3)))
-
-(define-public ghc-chasingbottoms
- (package
- (name "ghc-chasingbottoms")
- (version "1.3.1.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/ChasingBottoms/"
- "ChasingBottoms-" version ".tar.gz"))
- (sha256
- (base32
- "06cynx6hcbfpky7qq3b3mjjgwbnaxkwin3znbwq4b9ikiw0ng633"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-random" ,ghc-random)
- ("ghc-syb" ,ghc-syb)))
- (home-page "https://hackage.haskell.org/package/ChasingBottoms")
- (synopsis "Testing of partial and infinite values in Haskell")
- (description
- ;; FIXME: There should be a @comma{} in the uref text, but it is not
- ;; rendered properly.
- "This is a library for testing code involving bottoms or infinite values.
-For the underlying theory and a larger example involving use of QuickCheck,
-see the article
-@uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
-\"Chasing Bottoms A Case Study in Program Verification in the Presence of
-Partial and Infinite Values\"}.")
- (license license:expat)))
-
-(define-public ghc-unordered-containers
- (package
- (name "ghc-unordered-containers")
- (version "0.2.9.0")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/unordered-containers"
- "/unordered-containers-" version ".tar.gz"))
- (sha256
- (base32
- "0l4264p0av12cc6i8gls13q8y27x12z2ar4x34n3x59y99fcnc37"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
- ("ghc-hashable" ,ghc-hashable)))
- (home-page
- "https://github.com/tibbe/unordered-containers")
- (synopsis
- "Efficient hashing-based container types")
- (description
- "Efficient hashing-based container types. The containers have been
-optimized for performance critical use, both in terms of large data quantities
-and high speed.")
- (license license:bsd-3)))
-
-(define-public ghc-unordered-containers-bootstrap
- (package
- (inherit ghc-unordered-containers)
- (name "ghc-unordered-containers-bootstrap")
- (arguments `(#:tests? #f))
- (inputs
- `(("ghc-hashable" ,ghc-hashable-bootstrap)))
- (properties '(hidden? #t))))
-
-(define-public ghc-uniplate
- (package
- (name "ghc-uniplate")
- (version "1.6.12")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/uniplate/uniplate-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-syb" ,ghc-syb)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (home-page "http://community.haskell.org/~ndm/uniplate/")
- (synopsis "Simple, concise and fast generic operations")
- (description "Uniplate is a library for writing simple and concise generic
-operations. Uniplate has similar goals to the original Scrap Your Boilerplate
-work, but is substantially simpler and faster.")
- (license license:bsd-3)))
-
-(define-public ghc-base64-bytestring
- (package
- (name "ghc-base64-bytestring")
- (version "1.0.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
- version
- ".tar.gz"))
- (sha256
- (base32 "13305brzlac24pifiqd5a2z10c6k6amhpdy9cc0z5ryrkgnm8dhr"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
- (home-page "https://github.com/bos/base64-bytestring")
- (synopsis "Base64 encoding and decoding for ByteStrings")
- (description "This library provides fast base64 encoding and decoding for
-Haskell @code{ByteString}s.")
- (license license:bsd-3)))
-
-(define-public ghc-annotated-wl-pprint
- (package
- (name "ghc-annotated-wl-pprint")
- (version "0.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/annotated-wl-pprint"
- "/annotated-wl-pprint-" version
- ".tar.gz"))
- (sha256
- (base32
- "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
- (build-system haskell-build-system)
- (home-page
- "https://github.com/david-christiansen/annotated-wl-pprint")
- (synopsis
- "The Wadler/Leijen Pretty Printer, with annotation support")
- (description "This is a modified version of wl-pprint, which was based on
-Wadler's paper \"A Prettier Printer\". This version allows the library user
-to annotate the text with semantic information, which can later be rendered in
-a variety of ways.")
- (license license:bsd-3)))
-
-(define-public ghc-wl-pprint
- (package
- (name "ghc-wl-pprint")
- (version "1.2.1")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/wl-pprint/wl-pprint-"
- version ".tar.gz"))
- (sha256
- (base32
- "0kn7y8pdrv8f87zhd5mifcl8fy3b2zvnzmzwhdqhxxlyzwiq6z0c"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/wl-pprint")
- (synopsis "Wadler/Leijen pretty printer")
- (description
- "This is a pretty printing library based on Wadler's paper @i{A Prettier
-Printer}. This version allows the library user to declare overlapping
-instances of the @code{Pretty} class.")
- (license license:bsd-3)))
-
-(define-public ghc-ansi-wl-pprint
- (package
- (name "ghc-ansi-wl-pprint")
- (version "0.6.8.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "ansi-wl-pprint/ansi-wl-pprint-"
- version ".tar.gz"))
- (sha256
- (base32
- "0gnb4mkqryv08vncxnj0bzwcnd749613yw3cxfzw6y3nsldp4c56"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
- (home-page "https://github.com/ekmett/ansi-wl-pprint")
- (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
- (description "This is a pretty printing library based on Wadler's paper
-\"A Prettier Printer\". It has been enhanced with support for ANSI terminal
-colored output using the ansi-terminal package.")
- (license license:bsd-3)))
-
-(define-public ghc-split
- (package
- (name "ghc-split")
- (version "0.2.3.3")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/split/split-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "04qlmkcyklznl03gsjg95b4nzb6i96gdapqg60rny9szgi7ngk8x"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://hackage.haskell.org/package/split")
- (synopsis "Combinator library for splitting lists")
- (description "This package provides a collection of Haskell functions for
-splitting lists into parts, akin to the @code{split} function found in several
-mainstream languages.")
- (license license:bsd-3)))
-
-(define-public ghc-parser-combinators
- (package
- (name "ghc-parser-combinators")
- (version "1.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "parser-combinators/parser-combinators-"
- version ".tar.gz"))
- (sha256
- (base32
- "1pwfdsklqwvaynwpdzmx1bs35mp6dpsyaqdnzxnqcrxwf5h8sk75"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/mrkkrp/parser-combinators")
- (synopsis "Commonly useful parser combinators")
- (description
- "This is a lightweight package providing commonly useful parser
-combinators.")
- (license license:bsd-3)))
-
-(define-public ghc-megaparsec
- (package
- (name "ghc-megaparsec")
- (version "6.5.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "megaparsec/megaparsec-"
- version ".tar.gz"))
- (sha256
- (base32
- "12iggy7qpf8x93jm64zf0g215xwy779bqyfyjk2bhmxqqr1yzgdy"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("4" "0ij3asi5vwlhbgwsy6nhli9a0qb7926mg809fsgyl1rnhs9fvpx1")))
- (inputs
- `(("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-parser-combinators" ,ghc-parser-combinators)
- ("ghc-scientific" ,ghc-scientific)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-hspec-expectations" ,ghc-hspec-expectations)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/mrkkrp/megaparsec")
- (synopsis "Monadic parser combinators")
- (description
- "This is an industrial-strength monadic parser combinator library.
-Megaparsec is a feature-rich package that strikes a nice balance between
-speed, flexibility, and quality of parse errors.")
- (license license:bsd-2)))
-
-(define-public ghc-vector
- (package
- (name "ghc-vector")
- (version "0.12.0.1")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/vector/vector-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0yrx2ypiaxahvaz84af5bi855hd3107kxkbqc8km29nsp5wyw05i"))))
- (build-system haskell-build-system)
- ;; FIXME: To simplify upgrading all Haskell packages, we leave the tests
- ;; disabled for now.
- (arguments
- `(#:cabal-revision
- ("3" "0y5rh8k710i2a3p1h2rghvr5cfg78p5h0kbfi7ifxqqf6pzlyr1x")
- #:tests? #f))
- (inputs
- `(("ghc-primitive" ,ghc-primitive)
- ("ghc-random" ,ghc-random)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ;; ("ghc-hunit" ,ghc-hunit)
- ;; ("ghc-test-framework" ,ghc-test-framework)
- ;; ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ;; ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
- ))
- (home-page "https://github.com/haskell/vector")
- (synopsis "Efficient Arrays")
- (description "This library provides an efficient implementation of
-Int-indexed arrays (both mutable and immutable), with a powerful loop
-optimisation framework.")
- (license license:bsd-3)))
-
-(define-public ghc-vector-binary-instances
- (package
- (name "ghc-vector-binary-instances")
- (version "0.2.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "vector-binary-instances/vector-binary-instances-"
- version ".tar.gz"))
- (sha256
- (base32
- "1y236jb72iab9ska1mc48z6yb0xgwmj45laaqdyjxksd84z7hbrb"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "196frl4akhfk7xf1nxzn8lmq99dxhzhsimanswn9yy7ym8zhki4i")))
- (inputs
- `(("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://github.com/bos/vector-binary-instances")
- (synopsis "Instances of Data.Binary and Data.Serialize for vector")
- (description "This library provides instances of @code{Binary} for the
-types defined in the @code{vector} package, making it easy to serialize
-vectors to and from disk. We use the generic interface to vectors, so all
-vector types are supported. Specific instances are provided for unboxed,
-boxed and storable vectors.")
- (license license:bsd-3)))
-
-(define-public ghc-bloomfilter
- (package
- (name "ghc-bloomfilter")
- (version "2.0.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "bloomfilter/bloomfilter-" version ".tar.gz"))
- (sha256
- (base32
- "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-random" ,ghc-random)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/bos/bloomfilter")
- (synopsis "Pure and impure Bloom filter implementations")
- (description "This package provides both mutable and immutable Bloom
-filter data types, along with a family of hash functions and an easy-to-use
-interface.")
- (license license:bsd-3)))
-
-(define-public ghc-network
- (package
- (name "ghc-network")
- (version "2.6.3.6")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/network/network-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "198mam7ahny48p9fajznbqq16a8ya2gw0xm3gnm1si1rmc4hdplv"))))
- (build-system haskell-build-system)
- ;; The regression tests depend on an unpublished module.
- (arguments `(#:tests? #f))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://github.com/haskell/network")
- (synopsis "Low-level networking interface")
- (description
- "This package provides a low-level networking interface.")
- (license license:bsd-3)))
-
-(define-public ghc-network-uri
- (package
- (name "ghc-network-uri")
- (version "2.6.1.0")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/network-uri/network-uri-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1w27zkvn39kjr9lmw9421y8w43h572ycsfafsb7kyvr3a4ihlgj2"))))
- (build-system haskell-build-system)
- (arguments
- `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
- (inputs
- `(("ghc-network" ,ghc-network)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page
- "https://github.com/haskell/network-uri")
- (synopsis "Library for URI manipulation")
- (description "This package provides an URI manipulation interface. In
-@code{network-2.6} the @code{Network.URI} module was split off from the
-@code{network} package into this package.")
- (license license:bsd-3)))
-
-(define-public ghc-ansi-terminal
- (package
- (name "ghc-ansi-terminal")
- (version "0.8.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0428gq8m3fdnb7ldcsyk97qcch76hcxbgh2666p6f76fs2qbhg7b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-colour" ,ghc-colour)))
- (home-page "https://github.com/feuerbach/ansi-terminal")
- (synopsis "ANSI terminal support for Haskell")
- (description "This package provides ANSI terminal support for Haskell. It
-allows cursor movement, screen clearing, color output showing or hiding the
-cursor, and changing the title.")
- (license license:bsd-3)))
-
-(define-public ghc-vault
- (package
- (name "ghc-vault")
- (version "0.3.1.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/vault/vault-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "072mbrihsdsb8c6xvg6lvk0rqjgvxvi8qkg4n6wwym5hq0pfa04y"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-semigroupoids" ,ghc-semigroupoids)))
- (home-page
- "https://github.com/HeinrichApfelmus/vault")
- (synopsis "Persistent store for arbitrary values")
- (description "This package provides vaults for Haskell. A vault is a
-persistent store for values of arbitrary types. It's like having first-class
-access to the storage space behind @code{IORefs}. The data structure is
-analogous to a bank vault, where you can access different bank boxes with
-different keys; hence the name. Also provided is a @code{locker} type,
-representing a store for a single element.")
- (license license:bsd-3)))
-
-(define-public ghc-edisonapi
- (package
- (name "ghc-edisonapi")
- (version "1.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/EdisonAPI"
- "/EdisonAPI-" version ".tar.gz"))
- (sha256
- (base32 "0vmmlsj8ggbpwx6fkf5fvb6jp0zpx6iba6b28m80lllr2p8bi8wm"))))
- (build-system haskell-build-system)
- (home-page "http://rwd.rdockins.name/edison/home/")
- (synopsis "Library of efficient, purely-functional data structures (API)")
- (description
- "Edison is a library of purely functional data structures written by
-Chris Okasaki. It is named after Thomas Alva Edison and for the mnemonic
-value EDiSon (Efficient Data Structures). Edison provides several families of
-abstractions, each with multiple implementations. The main abstractions
-provided by Edison are: Sequences such as stacks, queues, and dequeues;
-Collections such as sets, bags and heaps; and Associative Collections such as
-finite maps and priority queues where the priority and element are distinct.")
- (license license:expat)))
-
-(define-public ghc-edisoncore
- (package
- (name "ghc-edisoncore")
- (version "1.3.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/EdisonCore"
- "/EdisonCore-" version ".tar.gz"))
- (sha256
- (base32 "0fgj5iwiv3v2gdgx7kjcr15dcs4x1kvmjspp3p99wyhh0x6h3ikk"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-edisonapi" ,ghc-edisonapi)))
- (home-page "http://rwd.rdockins.name/edison/home/")
- (synopsis "Library of efficient, purely-functional data structures")
- (description
- "This package provides the core Edison data structure implementations,
-including multiple sequence, set, bag, and finite map concrete implementations
-with various performance characteristics.")
- (license license:expat)))
-
-(define-public ghc-mmorph
- (package
- (name "ghc-mmorph")
- (version "1.1.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/mmorph/mmorph-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1gjz1ib968lqybma7my1n19qq6cdj6a7nskrlnwy4jy9jrwzs2n9"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://hackage.haskell.org/package/mmorph")
- (synopsis "Monad morphisms")
- (description
- "This library provides monad morphism utilities, most commonly used for
-manipulating monad transformer stacks.")
- (license license:bsd-3)))
-
-(define-public ghc-ifelse
- (package
- (name "ghc-ifelse")
- (version "0.85")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "IfElse/IfElse-" version ".tar.gz"))
- (sha256
- (base32
- "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
- (build-system haskell-build-system)
- (home-page "http://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
-@code{switch} function.")
- (license license:bsd-3)))
-
-(define-public ghc-monad-control
- (package
- (name "ghc-monad-control")
- (version "1.0.2.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/monad-control"
- "/monad-control-" version ".tar.gz"))
- (sha256
- (base32
- "1c92833gr6cadidjdp8mlznkpp8lyxl0w3y7d19y8yi3klc3843c"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/basvandijk/monad-control")
- (synopsis "Monad transformers to lift control operations like exception
-catching")
- (description "This package defines the type class @code{MonadBaseControl},
-a subset of @code{MonadBase} into which generic control operations such as
-@code{catch} can be lifted from @code{IO} or any other base monad.")
- (license license:bsd-3)))
-
-(define-public ghc-fail
- (package
- (name "ghc-fail")
- (version "4.9.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/fail/fail-"
- version ".tar.gz"))
- (sha256
- (base32 "18nlj6xvnggy61gwbyrpmvbdkq928wv0wx2zcsljb52kbhddnp3d"))))
- (build-system haskell-build-system)
- (arguments `(#:haddock? #f)) ; Package contains no documentation.
- (home-page "https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail")
- (synopsis "Forward-compatible MonadFail class")
- (description
- "This package contains the @code{Control.Monad.Fail} module providing the
-@uref{https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail, MonadFail}
-class that became available in
-@uref{https://hackage.haskell.org/package/base-4.9.0.0, base-4.9.0.0} for
-older @code{base} package versions. This package turns into an empty package
-when used with GHC versions which already provide the
-@code{Control.Monad.Fail} module.")
- (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-byteorder
- (package
- (name "ghc-byteorder")
- (version "1.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/byteorder/byteorder-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
- (build-system haskell-build-system)
- (home-page
- "http://community.haskell.org/~aslatter/code/byteorder")
- (synopsis
- "Exposes the native endianness of the system")
- (description
- "This package is for working with the native byte-ordering of the
-system.")
- (license license:bsd-3)))
-
-(define-public ghc-base-compat
- (package
- (name "ghc-base-compat")
- (version "0.10.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/base-compat/base-compat-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0ksp990gxs731mq19rzbxrbs43nazfljjc8krlx5bjqblw3kfs8d"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/base-compat")
- (synopsis "Haskell compiler compatibility library")
- (description "This library provides functions available in later versions
-of base to a wider range of compilers, without requiring the use of CPP
-pragmas in your code.")
- (license license:bsd-3)))
-
-(define-public ghc-blaze-builder
- (package
- (name "ghc-blaze-builder")
- (version "0.4.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/blaze-builder/blaze-builder-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "05681dih2d8s96an945wkbwl05w8ddbcfx8n3r3ck79ydyb8pz4i"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: Missing test libraries.
- (inputs
- `(("ghc-utf8-string" ,ghc-utf8-string)))
- (home-page "https://github.com/lpsmith/blaze-builder")
- (synopsis "Efficient buffered output")
- (description "This library provides an implementation of the older
-@code{blaze-builder} interface in terms of the new builder that shipped with
-@code{bytestring-0.10.4.0}. This implementation is mostly intended as a
-bridge to the new builder, so that code that uses the old interface can
-interoperate with code that uses the new implementation.")
- (license license:bsd-3)))
-
-(define-public ghc-blaze-markup
- (package
- (name "ghc-blaze-markup")
- (version "0.8.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "blaze-markup/blaze-markup-"
- version ".tar.gz"))
- (sha256
- (base32
- "0ih1c3qahkdgzbqihdhny5s313l2m66fbb88w8jbx7yz56y7rawh"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "blaze-markup.cabal"
- (("tasty >= 1\\.0 && < 1\\.1")
- "tasty >= 1.0 && < 1.2")))))))
- (inputs
- `(("ghc-blaze-builder" ,ghc-blaze-builder)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://jaspervdj.be/blaze")
- (synopsis "Fast markup combinator library for Haskell")
- (description "This library provides core modules of a markup combinator
-library for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-easy-file
- (package
- (name "ghc-easy-file")
- (version "0.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/easy-file/easy-file-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0zmlcz723051qpn8l8vi51c5rx1blwrw4094jcshkmj8p9r2xxaj"))))
- (build-system haskell-build-system)
- (home-page
- "https://github.com/kazu-yamamoto/easy-file")
- (synopsis "File handling library for Haskell")
- (description "This library provides file handling utilities for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-async
- (package
- (name "ghc-async")
- (version "2.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/async/async-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "09whscli1q5z7lzyq9rfk0bq1ydplh6pjmc6qv0x668k5818c2wg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hashable" ,ghc-hashable)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://github.com/simonmar/async")
- (synopsis "Library to run IO operations asynchronously")
- (description "Async provides a library to run IO operations
-asynchronously, and wait for their results. It is a higher-level interface
-over threads in Haskell, in which @code{Async a} is a concurrent thread that
-will eventually deliver a value of type @code{a}.")
- (license license:bsd-3)))
-
-(define-public ghc-fingertree
- (package
- (name "ghc-fingertree")
- (version "0.1.4.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/fingertree/fingertree-"
- version ".tar.gz"))
- (sha256
- (base32
- "192fyzv0pn1437wdpqg1l80rswkk4rw3w61r4bq7dhv354bdqy4p"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://hackage.haskell.org/package/fingertree")
- (synopsis "Generic finger-tree structure")
- (description "This library provides finger trees, a general sequence
-representation with arbitrary annotations, for use as a base for
-implementations of various collection types. It includes examples, as
-described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
-simple general-purpose data structure\".")
- (license license:bsd-3)))
-
-(define-public ghc-optparse-applicative
- (package
- (name "ghc-optparse-applicative")
- (version "0.14.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/optparse-applicative"
- "/optparse-applicative-" version ".tar.gz"))
- (sha256
- (base32
- "0c3z1mvynlyv1garjbdmdd3npm40dabgm75js4r07cf766c1wd71"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/pcapriotti/optparse-applicative")
- (synopsis "Utilities and combinators for parsing command line options")
- (description "This package provides utilities and combinators for parsing
-command line options in Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-base-orphans
- (package
- (name "ghc-base-orphans")
- (version "0.7")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/base-orphans/base-orphans-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "057f9npnqk71ccfh95djfkpd54dzazphj06grwxa3fyhwcwxrb8a"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/base-orphans")
- (synopsis "Orphan instances for backwards compatibility")
- (description "This package defines orphan instances that mimic instances
-available in later versions of base to a wider (older) range of compilers.")
- (license license:bsd-3)))
-
-(define-public ghc-auto-update
- (package
- (name "ghc-auto-update")
- (version "0.1.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/auto-update/auto-update-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "09dlh2alsx2mw5kvj931yhbj0aw7jmly2cm9xbscm2sf098w35jy"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/yesodweb/wai")
- (synopsis "Efficiently run periodic, on-demand actions")
- (description "This library provides mechanisms to efficiently run
-periodic, on-demand actions in Haskell.")
- (license license:expat)))
-
-(define-public ghc-tagged
- (package
- (name "ghc-tagged")
- (version "0.8.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/tagged/tagged-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "16cdzh0bw16nvjnyyy5j9s60malhz4nnazw96vxb0xzdap4m2z74"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "0r2knfcq0b4s652vlvlnfwxlc2mkc2ra9kl8bp4zdn1awmfy0ia5")))
- (inputs
- `(("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://hackage.haskell.org/package/tagged")
- (synopsis "Haskell phantom types to avoid passing dummy arguments")
- (description "This library provides phantom types for Haskell 98, to avoid
-having to unsafely pass dummy arguments.")
- (license license:bsd-3)))
-
-(define-public ghc-unbounded-delays
- (package
- (name "ghc-unbounded-delays")
- (version "0.1.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1ir9fghbrc214c97bwafk5ck6cacxz1pdnq4i18p604d1b8zg9wa"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/basvandijk/unbounded-delays")
- (synopsis "Unbounded thread delays and timeouts")
- (description "The @code{threadDelay} and @code{timeout} functions from the
-Haskell base library use the bounded @code{Int} type for specifying the delay
-or timeout period. This package provides alternative functions which use the
-unbounded @code{Integer} type.")
- (license license:bsd-3)))
-
-(define-public ghc-clock
- (package
- (name "ghc-clock")
- (version "0.7.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "clock/"
- "clock-" version ".tar.gz"))
- (sha256
- (base32 "07v91s20halsqjmziqb1sqjp2sjpckl9by7y28aaklwqi2bh2rl8"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://hackage.haskell.org/package/clock")
- (synopsis "High-resolution clock for Haskell")
- (description "A package for convenient access to high-resolution clock and
-timer functions of different operating systems via a unified API.")
- (license license:bsd-3)))
-
-;; This package builds `clock` without tests, since the tests rely on tasty
-;; and tasty-quickcheck, which in turn require clock to build.
-(define-public ghc-clock-bootstrap
- (package
- (inherit ghc-clock)
- (name "ghc-clock-bootstrap")
- (arguments '(#:tests? #f))
- (inputs '())
- (properties '((hidden? #t)))))
-
-(define-public ghc-charset
- (package
- (name "ghc-charset")
- (version "0.3.7.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/charset/charset-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-semigroups" ,ghc-semigroups)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (home-page "https://github.com/ekmett/charset")
- (synopsis "Fast unicode character sets for Haskell")
- (description "This package provides fast unicode character sets for
-Haskell, based on complemented PATRICIA tries.")
- (license license:bsd-3)))
-
-(define-public ghc-bytestring-builder
- (package
- (name "ghc-bytestring-builder")
- (version "0.10.8.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/bytestring-builder"
- "/bytestring-builder-" version ".tar.gz"))
- (sha256
- (base32
- "1hnvjac28y44yn78c9vdp1zvrknvlw98ky3g4n5vivr16rvh8x3d"))))
- (build-system haskell-build-system)
- (arguments `(#:haddock? #f)) ; Package contains no documentation.
- (home-page "https://hackage.haskell.org/package/bytestring-builder")
- (synopsis "The new bytestring builder, packaged outside of GHC")
- (description "This package provides the bytestring builder that is
-debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
-Compatibility package for older packages.")
- (license license:bsd-3)))
-
-(define-public ghc-nats
- (package
- (name "ghc-nats")
- (version "1.1.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/nats/nats-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1v40drmhixck3pz3mdfghamh73l4rp71mzcviipv1y8jhrfxilmr"))))
- (build-system haskell-build-system)
- (arguments `(#:haddock? #f))
- (inputs
- `(("ghc-hashable" ,ghc-hashable)))
- (home-page "https://hackage.haskell.org/package/nats")
- (synopsis "Natural numbers")
- (description "This library provides the natural numbers for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-nats-bootstrap
- (package
- (inherit ghc-nats)
- (name "ghc-nats-bootstrap")
- (inputs
- `(("ghc-hashable" ,ghc-hashable-bootstrap)))
- (properties '((hidden? #t)))))
-
-(define-public ghc-void
- (package
- (name "ghc-void")
- (version "0.7.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/void/void-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0aygw0yb1h3yhmfl3bkwh5d3h0l4mmsxz7j53vdm6jryl1kgxzyk"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-semigroups" ,ghc-semigroups)
- ("ghc-hashable" ,ghc-hashable)))
- (home-page "https://github.com/ekmett/void")
- (synopsis
- "Logically uninhabited data type")
- (description
- "A Haskell 98 logically uninhabited data type, used to indicate that a
-given term should not exist.")
- (license license:bsd-3)))
-
-(define-public ghc-invariant
- (package
- (name "ghc-invariant")
- (version "0.5.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/invariant/invariant-"
- version ".tar.gz"))
- (sha256
- (base32
- "0aqj7z55632qdg45074kgn9qfdxzb0a2f8lgjzr0l0i4mm2rr37b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-statevar" ,ghc-statevar)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-th-abstraction" ,ghc-th-abstraction)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/nfrisby/invariant-functors")
- (synopsis "Haskell98 invariant functors")
- (description "Haskell98 invariant functors (also known as exponential
-functors). For more information, see Edward Kmett's article
-@uref{http://comonad.com/reader/2008/rotten-bananas/, Rotten Bananas}.")
- (license license:bsd-2)))
-
-(define-public ghc-kan-extensions
- (package
- (name "ghc-kan-extensions")
- (version "5.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/kan-extensions/kan-extensions-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1lyvyiwwh962j2nnnsqzlvp5zq6z8p3spvhmji99cjvldxc7wwkb"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-adjunctions" ,ghc-adjunctions)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-free" ,ghc-free)
- ("ghc-invariant" ,ghc-invariant)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/ekmett/kan-extensions/")
- (synopsis "Kan extensions library")
- (description "This library provides Kan extensions, Kan lifts, various
-forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-call-stack
- (package
- (name "ghc-call-stack")
- (version "0.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "call-stack/call-stack-"
- version ".tar.gz"))
- (sha256
- (base32
- "1qmihf5jafmc79sk52l6gpx75f5bnla2lp62kh3p34x3j84mwpzj"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-nanospec" ,ghc-nanospec)))
- (home-page "https://github.com/sol/call-stack#readme")
- (synopsis "Use GHC call-stacks in a backward compatible way")
- (description "This package provides a compatibility layer for using GHC
-call stacks with different versions of the compiler.")
- (license license:expat)))
-
-;; This is used as an input to ghc-hunit. We cannot use ghc-call-stack there,
-;; because it depends on ghc-nanospec, which depends on ghc-hunit.
-(define-public ghc-call-stack-boot
- (hidden-package
- (package
- (inherit ghc-call-stack)
- (arguments '(#:tests? #f))
- (inputs '()))))
-
-(define-public ghc-statevar
- (package
- (name "ghc-statevar")
- (version "1.1.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/StateVar/StateVar-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "08r2iw0gdmfs4f6wraaq19vfmkjdbics3dbhw39y7mdjd98kcr7b"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/StateVar")
- (synopsis "State variables for Haskell")
- (description "This package provides state variables, which are references
-in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
- (license license:bsd-3)))
-
-(define-public ghc-lens
- (package
- (name "ghc-lens")
- (version "4.16.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/lens/lens-"
- version ".tar.gz"))
- (sha256
- (base32
- "1im4drhbydbawd6i0jsrzpqihnmx4ywpkg7yg94ddwsw3mxwkgpm"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri")))
- (inputs
- `(("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-free" ,ghc-free)
- ("ghc-kan-extensions" ,ghc-kan-extensions)
- ("ghc-parallel" ,ghc-parallel)
- ("ghc-reflection" ,ghc-reflection)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-vector" ,ghc-vector)
- ("ghc-call-stack" ,ghc-call-stack)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-void" ,ghc-void)
- ("ghc-generic-deriving" ,ghc-generic-deriving)
- ("ghc-nats" ,ghc-nats)
- ("ghc-simple-reflect" ,ghc-simple-reflect)
- ("hlint" ,hlint)))
- (native-inputs
- `(("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-th" ,ghc-test-framework-th)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/ekmett/lens/")
- (synopsis "Lenses, Folds and Traversals")
- (description "This library provides @code{Control.Lens}. The combinators
-in @code{Control.Lens} provide a highly generic toolbox for composing families
-of getters, folds, isomorphisms, traversals, setters and lenses and their
-indexed variants.")
- (license license:bsd-3)))
-
-(define-public ghc-cheapskate
- (package
- (name "ghc-cheapskate")
- (version "0.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/cheapskate/cheapskate-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1hiqi7h76shjzs2zj0j8g6wnq2hbiq1hmfafdazr97fba2zl2432"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-xss-sanitize" ,ghc-xss-sanitize)
- ("ghc-data-default" ,ghc-data-default)
- ("ghc-syb" ,ghc-syb)
- ("ghc-uniplate" ,ghc-uniplate)))
- (home-page "https://github.com/jgm/cheapskate")
- (synopsis "Experimental markdown processor")
- (description "Cheapskate is an experimental Markdown processor in pure
-Haskell. It aims to process Markdown efficiently and in the most forgiving
-possible way. It is designed to deal with any input, including garbage, with
-linear performance. Output is sanitized by default for protection against
-cross-site scripting (@dfn{XSS}) attacks.")
- (license license:bsd-3)))
-
-(define-public ghc-bifunctors
- (package
- (name "ghc-bifunctors")
- (version "5.5.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/bifunctors/bifunctors-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1jn9rxg643xnlhrknmjz88nblcpsr45xwjkwwnn5nxpasa7m4d6l"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-th-abstraction" ,ghc-th-abstraction)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-semigroups" ,ghc-semigroups)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/ekmett/bifunctors/")
- (synopsis "Bifunctors for Haskell")
- (description "This package provides bifunctors for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-semigroupoids
- (package
- (name "ghc-semigroupoids")
- (version "5.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/semigroupoids/semigroupoids-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "17i96y4iqj8clcs090lf6k0ij3j16nj14vsfwz0mm9nd6i4gbpp4"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("4" "0pqfrxzypjq6z8lgdkzq4vhcyqkpk5326hny0r6snpc3gm78r4ij")))
- (inputs
- `(("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (native-inputs
- `(("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)))
- (home-page "https://github.com/ekmett/semigroupoids")
- (synopsis "Semigroupoids operations for Haskell")
- (description "This library provides a wide array of (semi)groupoids and
-operations for working with them. A @code{Semigroupoid} is a @code{Category}
-without the requirement of identity arrows for every object in the category.
-A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
-Finally, to work with these weaker structures it is beneficial to have
-containers that can provide stronger guarantees about their contents, so
-versions of @code{Traversable} and @code{Foldable} that can be folded with
-just a @code{Semigroup} are added.")
- (license license:bsd-3)))
-
-(define-public ghc-contravariant
- (package
- (name "ghc-contravariant")
- (version "1.4.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/contravariant/contravariant-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1vfhk8c5cxmmakx7rflap1ipkx5q0j5vnlrcz7yz6y53kxhksgf9"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-void" ,ghc-void)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-statevar" ,ghc-statevar)
- ("ghc-semigroups" ,ghc-semigroups)))
- (home-page
- "https://github.com/ekmett/contravariant/")
- (synopsis "Contravariant functors")
- (description "Contravariant functors for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-semigroups
- (package
- (name "ghc-semigroups")
- (version "0.18.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/semigroups/semigroups-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "17g29h62g1k51ghhvzkw72zksjgi6vs6bfipkj81pqw1dsprcamb"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-nats" ,ghc-nats)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-hashable" ,ghc-hashable)))
- (home-page "https://github.com/ekmett/semigroups/")
- (synopsis "Semigroup operations for Haskell")
- (description "This package provides semigroups for Haskell. In
-mathematics, a semigroup is an algebraic structure consisting of a set
-together with an associative binary operation. A semigroup generalizes a
-monoid in that there might not exist an identity element. It
-also (originally) generalized a group (a monoid with all inverses) to a type
-where every element did not have to have an inverse, thus the name
-semigroup.")
- (license license:bsd-3)))
-
-(define-public ghc-semigroups-bootstrap
- (package
- (inherit ghc-semigroups)
- (name "ghc-semigroups-bootstrap")
- (inputs
- `(("ghc-nats" ,ghc-nats-bootstrap)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-unordered-containers" ,ghc-unordered-containers-bootstrap)
- ("ghc-hashable" ,ghc-hashable-bootstrap)))
- (properties '(hidden? #t))))
-
-(define-public ghc-free
- (package
- (name "ghc-free")
- (version "5.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/free/free-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "15m3n9vhz7z3kzv1w3wlfa3x8jp4cbrkwmrcjr7jlx39iqffn1gg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-prelude-extras" ,ghc-prelude-extras)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/ekmett/free/")
- (synopsis "Unrestricted monads for Haskell")
- (description "This library provides free monads, which are useful for many
-tree-like structures and domain specific languages. If @code{f} is a
-@code{Functor} then the free @code{Monad} on @code{f} is the type of trees
-whose nodes are labeled with the constructors of @code{f}. The word \"free\"
-is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
-f} makes no constraining assumptions beyond those given by @code{f} and the
-definition of @code{Monad}.")
- (license license:bsd-3)))
-
-(define-public ghc-adjunctions
- (package
- (name "ghc-adjunctions")
- (version "4.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/adjunctions/adjunctions-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-profunctors" ,ghc-profunctors)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-free" ,ghc-free)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-void" ,ghc-void)))
- (native-inputs
- `(("ghc-generic-deriving" ,ghc-generic-deriving)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/ekmett/adjunctions/")
- (synopsis "Adjunctions and representable functors")
- (description "This library provides adjunctions and representable functors
-for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-equivalence
- (package
- (name "ghc-equivalence")
- (version "0.3.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/equivalence"
- "/equivalence-" version ".tar.gz"))
- (sha256
- (base32 "0a85bdyyvjqs5z4kfhhf758210k9gi9dv42ik66a3jl0z7aix8kx"))))
- (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)))
- (home-page "https://github.com/pa-ba/equivalence")
- (synopsis "Maintaining an equivalence relation implemented as union-find")
- (description
- "This is an implementation of Tarjan's Union-Find algorithm (Robert E.@:
-Tarjan. \"Efficiency of a Good But Not Linear Set Union Algorithm\",JACM
-22(2), 1975) in order to maintain an equivalence relation. This
-implementation is a port of the @code{union-find} package using the @code{ST}
-monad transformer (instead of the IO monad).")
- (license license:bsd-3)))
-
-(define-public ghc-fast-logger
- (package
- (name "ghc-fast-logger")
- (version "2.4.11")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/fast-logger/fast-logger-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1ad2vq4nifdxshqk9yrmghqizhkgybfz134kpr6padglb2mxxrdv"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-auto-update" ,ghc-auto-update)
- ("ghc-easy-file" ,ghc-easy-file)
- ("ghc-unix-time" ,ghc-unix-time)))
- (native-inputs
- `(("hspec-discover" ,hspec-discover)
- ("ghc-hspec" ,ghc-hspec)))
- (home-page "https://hackage.haskell.org/package/fast-logger")
- (synopsis "Fast logging system")
- (description "This library provides a fast logging system for Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-doctest
- (package
- (name "ghc-doctest")
- (version "0.16.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/doctest/doctest-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0hkccch65s3kp0b36h7bqhilnpi4bx8kngncm7ma9vbd3dwacjdv"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: missing test framework
- (inputs
- `(("ghc-syb" ,ghc-syb)
- ("ghc-paths" ,ghc-paths)
- ("ghc-base-compat" ,ghc-base-compat)
- ("ghc-code-page" ,ghc-code-page)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-stringbuilder" ,ghc-stringbuilder)
- ("ghc-silently" ,ghc-silently)
- ("ghc-setenv" ,ghc-setenv)))
- (home-page
- "https://github.com/sol/doctest#readme")
- (synopsis "Test interactive Haskell examples")
- (description "The doctest program checks examples in source code comments.
-It is modeled after doctest for Python, see
-@uref{https://docs.python.org/library/doctest.html, the Doctest website}.")
- (license license:expat)))
-
-(define-public ghc-lifted-base
- (package
- (name "ghc-lifted-base")
- (version "0.2.3.12")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/lifted-base/lifted-base-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1i8p8d3rkdh21bhgjjh32vd7qqjr7jq7p59qds0aw2kmargsjd61"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
- (inputs
- `(("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/basvandijk/lifted-base")
- (synopsis "Lifted IO operations from the base library")
- (description "Lifted-base exports IO operations from the @code{base}
-library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
-Note that not all modules from @code{base} are converted yet. The package
-includes a copy of the @code{monad-peel} test suite written by Anders
-Kaseorg.")
- (license license:bsd-3)))
-
-(define-public ghc-word8
- (package
- (name "ghc-word8")
- (version "0.1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/word8/word8-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "12jx7f13d2h1djq4fh4dyrab61sm49mj1w61j3rzp2vjfm696c16"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/word8")
- (synopsis "Word8 library for Haskell")
- (description "Word8 library to be used with @code{Data.ByteString}.")
- (license license:bsd-3)))
-
-(define-public ghc-stringsearch
- (package
- (name "ghc-stringsearch")
- (version "0.3.6.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/stringsearch/stringsearch-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
- (build-system haskell-build-system)
- (home-page "https://bitbucket.org/dafis/stringsearch")
- (synopsis "Fast searching, splitting and replacing of ByteStrings")
- (description "This package provides several functions to quickly search
-for substrings in strict or lazy @code{ByteStrings}. It also provides
-functions for breaking or splitting on substrings and replacing all
-occurrences of a substring (the first in case of overlaps) with another.")
- (license license:bsd-3)))
-
-(define-public ghc-integer-logarithms
- (package
- (name "ghc-integer-logarithms")
- (version "1.0.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "integer-logarithms/integer-logarithms-"
- version ".tar.gz"))
- (sha256
- (base32
- "1wj8kgjg5bn2yrs4zh9qfjv85cx6w998j9pi39yrbv305944mb9j"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "integer-logarithms.cabal"
- (("tasty >= 0\\.10 && < 1\\.1")
- "tasty >= 0.10 && < 1.2")))))))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-smallcheck" ,ghc-smallcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)))
- (home-page "https://github.com/Bodigrim/integer-logarithms")
- (synopsis "Integer logarithms")
- (description
- "This package provides the following modules:
-@code{Math.NumberTheory.Logarithms} and
-@code{Math.NumberTheory.Powers.Integer} from the @code{arithmoi} package,
-@code{GHC.Integer.Logarithms.Compat} and
-@code{Math.NumberTheory.Power.Natural}, as well as some additional functions
-in migrated modules.")
- (license license:expat)))
-
-(define-public ghc-integer-logarithms-bootstrap
- (package
- (inherit ghc-integer-logarithms)
- (name "ghc-integer-logarithms-bootstrap")
- (arguments `(#:tests? #f))
- (native-inputs '())
- (properties '(hidden? #t))))
-
-(define-public ghc-scientific
- (package
- (name "ghc-scientific")
- (version "0.3.6.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/scientific/scientific-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "03ql2f0ac8bsl524idy9xxa3kxisb2sj3avflzw580j5hzy0m397"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-integer-logarithms" ,ghc-integer-logarithms)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-primitive" ,ghc-primitive)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-smallcheck" ,ghc-smallcheck)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/basvandijk/scientific")
- (synopsis "Numbers represented using scientific notation")
- (description "This package provides @code{Data.Scientific}, which provides
-the number type @code{Scientific}. Scientific numbers are arbitrary precision
-and space efficient. They are represented using
-@uref{https://en.wikipedia.org/wiki/Scientific_notation, scientific
-notation}.")
- (license license:bsd-3)))
-
-(define-public ghc-scientific-bootstrap
- (package
- (inherit ghc-scientific)
- (name "ghc-scientific-bootstrap")
- (arguments `(#:tests? #f))
- (inputs
- `(("ghc-integer-logarithms" ,ghc-integer-logarithms-bootstrap)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-primitive" ,ghc-primitive)))
- (native-inputs '())
- (properties '(hidden? #t))))
-
-(define-public ghc-boxes
- (package
- (name "ghc-boxes")
- (version "0.1.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/boxes/boxes-"
- version ".tar.gz"))
- (sha256
- (base32 "1hsnmw95i58d4bkpxby3ddsj1cawypw4mdyb18m393s5i8p7iq9q"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-split" ,ghc-split)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://hackage.haskell.org/package/boxes")
- (synopsis "2D text pretty-printing library")
- (description
- "Boxes is a pretty-printing library for laying out text in two dimensions,
-using a simple box model.")
- (license license:bsd-3)))
-
-(define-public ghc-deepseq-generics
- (package
- (name "ghc-deepseq-generics")
- (version "0.2.0.0")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "deepseq-generics/deepseq-generics-"
- version ".tar.gz"))
- (sha256
- (base32
- "17bwghc15mc9pchfd1w46jh2p3wzc86aj6a537wqwxn08rayzcxh"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "1pnidf8w8x0w5fsqgv8hhrw07slmhxwy5x4fikgk0bd6k76aqicb")))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://github.com/hvr/deepseq-generics")
- (synopsis "Generic RNF implementation")
- (description
- "This package provides a @code{GHC.Generics}-based
-@code{Control.DeepSeq.Generics.genericRnf} function which can be used for
-providing an @code{rnf} implementation.")
- (license license:bsd-3)))
-
-(define-public ghc-string-qq
- (package
- (name "ghc-string-qq")
- (version "0.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/string-qq/string-qq-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0662m3i5xrdrr95w829bszkhp88mj9iy1zya54vk2sl5hz9wlmwp"))))
- (build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/string-qq")
- (synopsis
- "QuasiQuoter for non-interpolated strings, texts and bytestrings.")
- (description
- "This package provides a quasiquoter for non-interpolated strings, texts
-and bytestrings.")
- (license license:public-domain)))
-
-(define-public ghc-pandoc-types
- (package
- (name "ghc-pandoc-types")
- (version "1.17.5.1")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "pandoc-types/pandoc-types-"
- version ".tar.gz"))
- (sha256
- (base32
- "1q6v2bynij724fv347mhqxdscwifzrx5jb9mq80608qf638fn717"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-syb" ,ghc-syb)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-string-qq" ,ghc-string-qq)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "http://johnmacfarlane.net/pandoc")
- (synopsis "Types for representing a structured document")
- (description
- "This module defines the @code{Pandoc} data structure, which is used by
-pandoc to represent structured documents. It also provides functions for
-building up, manipulating and serialising @code{Pandoc} structures.")
- (license license:bsd-3)))
-
-(define-public ghc-texmath
- (package
- (name "ghc-texmath")
- (version "0.11.0.1")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "texmath/texmath-" version ".tar.gz"))
- (sha256
- (base32
- "11dc09hfnyfsz20ch2c867w0zdgjkzq41506lm61i3dk87ngdisf"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-syb" ,ghc-syb)
- ("ghc-network-uri" ,ghc-network-uri)
- ("ghc-split" ,ghc-split)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-xml" ,ghc-xml)
- ("ghc-pandoc-types" ,ghc-pandoc-types)))
- (home-page "https://github.com/jgm/texmath")
- (synopsis "Conversion between formats used to represent mathematics")
- (description
- "The texmath library provides functions to read and write TeX math,
-presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
-Office). Support is also included for converting math formats to pandoc's
-native format (allowing conversion, via pandoc, to a variety of different
-markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
-it can parse and apply LaTeX macros.")
- (license license:gpl2+)))
-
-(define-public ghc-regex-pcre-builtin
- (package
- (name "ghc-regex-pcre-builtin")
- (version "0.94.4.8.8.35")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "regex-pcre-builtin/regex-pcre-builtin-"
- version ".tar.gz"))
- (sha256
- (base32
- "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-base" ,ghc-regex-base)))
- (home-page "https://hackage.haskell.org/package/regex-pcre")
- (synopsis "Enhancement of the builtin Text.Regex library")
- (description
- "This package is an enhancement of the @code{Text.Regex} library,
-providing the PCRE backend to accompany regex-base, with bundled code from
-@url{https://www.pcre.org}.")
- (license license:bsd-3)))
-
-(define-public ghc-diff
- (package
- (name "ghc-diff")
- (version "0.3.4")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "Diff/Diff-" version ".tar.gz"))
- (sha256
- (base32
- "0bqcdvhxx8dmqc3793m6axg813wv9ldz2j37f1wygbbrbbndmdvp"))))
- (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://hub.darcs.net/sterlingclover/Diff")
- (synopsis "O(ND) diff algorithm in Haskell")
- (description
- "This package provides an implementation of the standard diff algorithm,
-and utilities for pretty printing.")
- (license license:bsd-3)))
-
-(define-public ghc-highlighting-kate
- (package
- (name "ghc-highlighting-kate")
- (version "0.6.4")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "highlighting-kate/highlighting-kate-"
- version ".tar.gz"))
- (sha256
- (base32
- "1bqv00gfmrsf0jjr4qf3lhshvfkyzmhbi3pjb6mafbnsyn2k7f6q"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-diff" ,ghc-diff)
- ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
- (native-inputs
- `(("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-utf8-string" ,ghc-utf8-string)))
- (home-page "https://github.com/jgm/highlighting-kate")
- (synopsis "Syntax highlighting library")
- (description
- "Highlighting-kate is a syntax highlighting library with support for
-nearly one hundred languages. The syntax parsers are automatically generated
-from @uref{https://kate-editor.org/, Kate syntax descriptions}, so any syntax
-supported by Kate can be added. An (optional) command-line program is
-provided, along with a utility for generating new parsers from Kate XML syntax
-descriptions.")
- (license license:gpl2+)))
-
-(define-public ghc-cmark
- (package
- (name "ghc-cmark")
- (version "0.5.6")
- (source (origin
- (method url-fetch)
- ;; XXX As of version 0.5.6, this package bundles libcmark 0.28.0.
- ;; See cbits/cmark_version.h.
- (uri (string-append "https://hackage.haskell.org/package/"
- "cmark/cmark-" version ".tar.gz"))
- (sha256
- (base32
- "1c1j3a8b9qx5zk9myqm3gap8ymz7fipwrdmyfsq9wkkdr9x4np45"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/jgm/commonmark-hs")
- (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
- (description
- "This package provides Haskell bindings for
-@uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
-CommonMark, a fully specified variant of Markdown. It includes bundled libcmark
-sources, and does not require prior installation of the C library.")
- (license license:bsd-3)))
-
-(define-public ghc-cmark-gfm
- (package
- (name "ghc-cmark-gfm")
- (version "0.1.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "cmark-gfm/cmark-gfm-"
- version ".tar.gz"))
- (sha256
- (base32
- "13b0mqks5c1q989slgsa3ixr5vvkfyic4ynzgv00kgl5qrs7hqk7"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/kivikakk/cmark-gfm-hs")
- (synopsis
- "Fast, accurate GitHub Flavored Markdown parser and renderer")
- (description
- "This package provides Haskell bindings for libcmark-gfm, the reference
-parser for GitHub Flavored Markdown, a fully specified variant of Markdown.
-It includes sources for libcmark-gfm and does not require prior installation
-of the C library.")
- (license license:bsd-3)))
-
-(define-public ghc-executable-path
- (package
- (name "ghc-executable-path")
- (version "0.0.3.1")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "executable-path/executable-path-"
- version ".tar.gz"))
- (sha256
- (base32
- "0vxwmnsvx13cawcyhbyljkds0l1vr996ijldycx7nj0asjv45iww"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/executable-path")
- (synopsis "Find out the full path of the executable")
- (description
- "The documentation of @code{System.Environment.getProgName} says that
-\"However, this is hard-to-impossible to implement on some non-Unix OSes, so
-instead, for maximum portability, we just return the leafname of the program
-as invoked.\" This library tries to provide the missing path.")
- (license license:public-domain)))
-
-(define-public ghc-enclosed-exceptions
- (package
- (name "ghc-enclosed-exceptions")
- (version "1.0.3")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "enclosed-exceptions/enclosed-exceptions-"
- version ".tar.gz"))
- (sha256
- (base32
- "1fghjj7nkiddrf03ks8brjpr5x25yi9fs7xg6adbi4mc2gqr6vdg"))))
- (build-system haskell-build-system)
- ;; FIXME: one of the tests blocks forever:
- ;; "thread blocked indefinitely in an MVar operation"
- (arguments '(#:tests? #f))
- (inputs
- `(("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-async" ,ghc-async)
- ("ghc-transformers-base" ,ghc-transformers-base)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/jcristovao/enclosed-exceptions")
- (synopsis "Catch all exceptions from within an enclosed computation")
- (description
- "This library implements a technique to catch all exceptions raised
-within an enclosed computation, while remaining responsive to (external)
-asynchronous exceptions.")
- (license license:expat)))
-
-(define-public ghc-th-abstraction
- (package
- (name "ghc-th-abstraction")
- (version "0.2.8.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "th-abstraction/th-abstraction-"
- version ".tar.gz"))
- (sha256
- (base32
- "0n17w4q2ykd0nica4sck2wng6md56rfad8x0icl0l8vnzb9nn4ya"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/glguy/th-abstraction")
- (synopsis "Nicer interface for reified information about data types")
- (description
- "This package normalizes variations in the interface for inspecting
-datatype information via Template Haskell so that packages and support a
-single, easier to use informational datatype while supporting many versions of
-Template Haskell.")
- (license license:isc)))
-
-(define-public ghc-th-lift
- (package
- (name "ghc-th-lift")
- (version "0.7.11")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "th-lift/th-lift-" version ".tar.gz"))
- (sha256
- (base32
- "131360zxb0hazbqwbkk6ab2p77jkxr79bwwm618mrwrwkm3x2g6m"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-th-abstraction" ,ghc-th-abstraction)))
- (home-page "https://github.com/mboes/th-lift")
- (synopsis "Derive Template Haskell's Lift class for datatypes")
- (description
- "This is a Haskell library to derive Template Haskell's Lift class for
-datatypes.")
- (license license:bsd-3)))
-
-(define-public ghc-th-lift-instances
- (package
- (name "ghc-th-lift-instances")
- (version "0.1.11")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "th-lift-instances/th-lift-instances-"
- version ".tar.gz"))
- (sha256
- (base32
- "1f56cp6ckcalld5jchv0kxpjkwcsixd7smd0g7r8cg67ppx6m90x"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-th-lift" ,ghc-th-lift)
- ("ghc-vector" ,ghc-vector)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/bennofs/th-lift-instances/")
- (synopsis "Lift instances for template-haskell for common data types.")
- (description "Most data types in the Haskell platform do not have Lift
-instances. This package provides orphan instances for @code{containers},
-@code{text}, @code{bytestring} and @code{vector}.")
- (license license:bsd-3)))
-
-(define-public ghc-th-expand-syns
- (package
- (name "ghc-th-expand-syns")
- (version "0.4.4.0")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "th-expand-syns/th-expand-syns-"
- version ".tar.gz"))
- (sha256
- (base32
- "01prlvh3py5hq5ccjidfyp9ixq2zd88dkbsidyjrpkja6v8m43yc"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-syb" ,ghc-syb)))
- (home-page "https://hackage.haskell.org/package/th-expand-syns")
- (synopsis "Expands type synonyms in Template Haskell ASTs")
- (description
- "This package enables users to expand type synonyms in Template Haskell
-@dfn{abstract syntax trees} (ASTs).")
- (license license:bsd-3)))
-
-(define-public ghc-th-reify-many
- (package
- (name "ghc-th-reify-many")
- (version "0.1.8")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "th-reify-many/th-reify-many-"
- version ".tar.gz"))
- (sha256
- (base32
- "0hzy6hvhvcd6i60vx5cp2b7ggmnnjh9rx4h8bm8xw4grglcaxjnf"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-safe" ,ghc-safe)
- ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
- (home-page "https://github.com/mgsloan/th-reify-many")
- (synopsis "Recurseively reify template haskell datatype info")
- (description
- "th-reify-many provides functions for recursively reifying top level
-declarations. The main intended use case is for enumerating the names of
-datatypes reachable from an initial datatype, and passing these names to some
-function which generates instances.")
- (license license:bsd-3)))
-
-(define-public ghc-th-orphans
- (package
- (name "ghc-th-orphans")
- (version "0.13.6")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "th-orphans/th-orphans-" version ".tar.gz"))
- (sha256
- (base32
- "0sfl3pn9kq9da3ji3lsgzgzy82vz6yvsg80dmakc1jvk7awycibp"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-th-lift" ,ghc-th-lift)
- ("ghc-th-lift-instances" ,ghc-th-lift-instances)
- ("ghc-th-reify-many" ,ghc-th-reify-many)
- ("ghc-generic-deriving" ,ghc-generic-deriving)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)))
- (home-page "https://hackage.haskell.org/package/th-orphans")
- (synopsis "Orphan instances for TH datatypes")
- (description
- "This package provides orphan instances for Template Haskell datatypes. In particular,
-instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
-and @code{Eq} instances. These instances used to live in the haskell-src-meta
-package, and that's where the version number started.")
- (license license:bsd-3)))
-
-(define-public ghc-geniplate-mirror
- (package
- (name "ghc-geniplate-mirror")
- (version "0.7.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package"
- "/geniplate-mirror"
- "/geniplate-mirror-" version ".tar.gz"))
- (sha256
- (base32 "1y0m0bw5zpm1y1y6d9qmxj3swl8j8hlw1shxbr5awycf6k884ssb"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/danr/geniplate")
- (synopsis "Use Template Haskell to generate Uniplate-like functions")
- (description
- "Use Template Haskell to generate Uniplate-like functions. This is a
-maintained mirror of the @uref{https://hackage.haskell.org/package/geniplate,
-geniplate} package, written by Lennart Augustsson.")
- (license license:bsd-3)))
-
-(define-public ghc-gitrev
- (package
- (name "ghc-gitrev")
- (version "1.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/gitrev/gitrev-"
- version ".tar.gz"))
- (sha256
- (base32 "0cl3lfm6k1h8fxp2vxa6ihfp4v8igkz9h35iwyq2frzm4kdn96d8"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-base-compat" ,ghc-base-compat)))
- (home-page "https://github.com/acfoltzer/gitrev")
- (synopsis "Compile git revision info into Haskell projects")
- (description
- "This package provides some handy Template Haskell splices for including
-the current git hash and branch in the code of your project. This is useful
-for including in panic messages, @command{--version} output, or diagnostic
-info for more informative bug reports.")
- (license license:bsd-3)))
-
-(define-public ghc-haskell-src-meta
- (package
- (name "ghc-haskell-src-meta")
- (version "0.8.0.3")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "haskell-src-meta/haskell-src-meta-"
- version ".tar.gz"))
- (sha256
- (base32
- "08jq156zv4m0fjq6712n99c1jwxnpa6kj6sq8ch0r1l0a1ay6ww4"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
- ("ghc-syb" ,ghc-syb)
- ("ghc-th-orphans" ,ghc-th-orphans)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://hackage.haskell.org/package/haskell-src-meta")
- (synopsis "Parse source to template-haskell abstract syntax")
- (description
- "This package provides tools to parse Haskell sources to the
-template-haskell abstract syntax.")
- (license license:bsd-3)))
-
-(define-public ghc-conduit
- (package
- (name "ghc-conduit")
- (version "1.3.0.3")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "conduit/conduit-" version ".tar.gz"))
- (sha256
- (base32
- "1sangm0qqi9dzlq95746a3kl14k8b09592a423shxjf2a0b1yx5v"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-exceptions" ,ghc-exceptions)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-mono-traversable" ,ghc-mono-traversable)
- ("ghc-mmorph" ,ghc-mmorph)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-silently" ,ghc-silently)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-unliftio" ,ghc-unliftio)
- ("ghc-unliftio-core" ,ghc-unliftio-core)
- ("ghc-vector" ,ghc-vector)
- ("ghc-void" ,ghc-void)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-safe" ,ghc-safe)
- ("ghc-split" ,ghc-split)))
- (home-page "https://github.com/snoyberg/conduit")
- (synopsis "Streaming data library ")
- (description
- "The conduit package is a solution to the streaming data problem,
-allowing for production, transformation, and consumption of streams of data
-in constant memory. It is an alternative to lazy I/O which guarantees
-deterministic resource handling, and fits in the same general solution
-space as enumerator/iteratee and pipes.")
- (license license:expat)))
-
-(define-public ghc-logging-facade
- (package
- (name "ghc-logging-facade")
- (version "0.3.0")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "logging-facade/logging-facade-"
- version ".tar.gz"))
- (sha256
- (base32
- "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/logging-facade")
- (synopsis "Simple logging abstraction that allows multiple back-ends")
- (description
- "This package provides a simple logging abstraction that allows multiple
-back-ends.")
- (license license:expat)))
-
-(define-public ghc-mockery
- (package
- (name "ghc-mockery")
- (version "0.3.5")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "mockery/mockery-" version ".tar.gz"))
- (sha256
- (base32
- "09ypgm3z69gq8mj6y66ss58kbjnk15r8frwcwbqcfbfksfnfv8dp"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-temporary" ,ghc-temporary)
- ("ghc-logging-facade" ,ghc-logging-facade)
- ("ghc-base-compat" ,ghc-base-compat)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/mockery")
- (synopsis "Support functions for automated testing")
- (description
- "The mockery package provides support functions for automated testing.")
- (license license:expat)))
-
-(define-public ghc-yaml
- (package
- (name "ghc-yaml")
- (version "0.8.32")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "yaml/yaml-" version ".tar.gz"))
- (sha256
- (base32
- "0cbsyh4ilvjzq1q7pxls43k6pdqxg1l85xzibcwpbvmlvrizh86w"))))
- (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-aeson" ,ghc-aeson)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
- ("ghc-base-compat" ,ghc-base-compat)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit" ,ghc-hunit)
- ("hspec-discover" ,hspec-discover)
- ("ghc-mockery" ,ghc-mockery)))
- (home-page "https://github.com/snoyberg/yaml/")
- (synopsis "Parsing and rendering YAML documents")
- (description
- "This package provides a library to parse and render YAML documents.")
- (license license:bsd-3)))
-
-(define-public ghc-filemanip
- (package
- (name "ghc-filemanip")
- (version "0.3.6.3")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "filemanip/filemanip-" version ".tar.gz"))
- (sha256
- (base32
- "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-unix-compat" ,ghc-unix-compat)))
- (home-page "https://github.com/bos/filemanip")
- (synopsis "File and directory manipulation for Haskell")
- (description
- "This package provides a Haskell library for working with files and
-directories. It includes code for pattern matching, finding files, modifying
-file contents, and more.")
- (license license:bsd-3)))
-
-(define-public ghc-mmap
- (package
- (name "ghc-mmap")
- (version "0.5.9")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "mmap/mmap-" version ".tar.gz"))
- (sha256
- (base32
- "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/mmap")
- (synopsis "Memory mapped files for Haskell")
- (description
- "This library provides a wrapper to @code{mmap}, allowing files or
-devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
-@code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
-do on-demand loading.")
- (license license:bsd-3)))
-
-(define-public ghc-juicypixels
- (package
- (name "ghc-juicypixels")
- (version "3.2.9.5")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "JuicyPixels/JuicyPixels-"
- version ".tar.gz"))
- (sha256
- (base32
- "0mf3ihr0xy2wc2wzb9a17g0n3p60x7pvm8akwpvhdy8klvs6r744"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-zlib" ,ghc-zlib)
- ("ghc-vector" ,ghc-vector)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-mmap" ,ghc-mmap)))
- (home-page "https://github.com/Twinside/Juicy.Pixels")
- (synopsis "Picture loading and serialization library")
- (description
- "This library can load and store images in PNG, Bitmap, JPEG, Radiance,
-TIFF and GIF formats.")
- (license license:bsd-3)))
-
-(define-public ghc-hslua
- (package
- (name "ghc-hslua")
- (version "0.9.5.2")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hslua/hslua-" version ".tar.gz"))
- (sha256
- (base32
- "1rdvv01p214zfjh6fcqjjgqwi8y42wad6cqzhlcv5gvclzw2ck8f"))))
- (build-system haskell-build-system)
- (arguments
- `(#:configure-flags '("-fsystem-lua")))
- (inputs
- `(("lua" ,lua)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-fail" ,ghc-fail)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
- (home-page "https://hackage.haskell.org/package/hslua")
- (synopsis "Lua language interpreter embedding in Haskell")
- (description
- "The Scripting.Lua module is a wrapper of the Lua language interpreter as
-described in @url{https://www.lua.org/}.")
- (license license:expat)))
-
-(define-public ghc-hslua-module-text
- (package
- (name "ghc-hslua-module-text")
- (version "0.1.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hslua-module-text/hslua-module-text-"
- version ".tar.gz"))
- (sha256
- (base32
- "0bcfpb1dhnxp0gr376ai4w7vczr9zrjl1r3r6w7kcxivfkwq9cxf"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n")))
- (inputs
- `(("ghc-hslua" ,ghc-hslua)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "https://github.com/hslua/hslua-module-text")
- (synopsis "Lua module for text")
- (description
- "This package provides a UTF-8 aware subset of Lua's @code{string} module
-for Haskell. The functions provided by this module are @code{upper},
-@code{lower}, @code{len}, @code{reverse}, and @code{sub}.")
- (license license:expat)))
-
-(define-public ghc-byteable
- (package
- (name "ghc-byteable")
- (version "0.1.1")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "byteable/byteable-" version ".tar.gz"))
- (sha256
- (base32
- "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/vincenthz/hs-byteable")
- (synopsis "Type class for sequence of bytes")
- (description
- "This package provides an abstract class to manipulate sequence of bytes.
-The use case of this class is abstracting manipulation of types that are just
-wrapping a bytestring with stronger and more meaniful name.")
- (license license:bsd-3)))
-
-(define-public ghc-hourglass
- (package
- (name "ghc-hourglass")
- (version "0.2.12")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hourglass/hourglass-" version ".tar.gz"))
- (sha256
- (base32
- "0jnay5j13vpz6i1rkaj3j0d9v8jfpri499xn3l7wd01f81f5ncs4"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-old-locale" ,ghc-old-locale)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "https://github.com/vincenthz/hs-hourglass")
- (synopsis "Simple time-related library for Haskell")
- (description
- "This is a simple time library providing a simple but powerful and
-performant API. The backbone of the library are the @code{Timeable} and
-@code{Time} type classes. Each @code{Timeable} instances can be converted to
-a type that has a @code{Time} instances, and thus are different
-representations of current time.")
- (license license:bsd-3)))
-
-(define-public ghc-edit-distance
- (package
- (name "ghc-edit-distance")
- (version "0.2.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/edit-distance"
- "/edit-distance-" version ".tar.gz"))
- (sha256
- (base32 "0jkca97zyv23yyilp3jydcrzxqhyk27swhzh82llvban5zp8b21y"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "edit-distance.cabal"
- (("QuickCheck >= 2\\.4 && <2\\.9")
- "QuickCheck >= 2.4 && < 2.12")))))))
- (inputs
- `(("ghc-random" ,ghc-random)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/phadej/edit-distance")
- (synopsis "Levenshtein and restricted Damerau-Levenshtein edit distances")
- (description
- "This package provides optimized functions to determine the edit
-distances for fuzzy matching, including Levenshtein and restricted
-Damerau-Levenshtein algorithms.")
- (license license:bsd-3)))
-
-(define-public ghc-memory
- (package
- (name "ghc-memory")
- (version "0.14.16")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "memory/memory-" version ".tar.gz"))
- (sha256
- (base32
- "03rbszi5d4z9rlbfv8ydrl1xf84xsh8z57g07f7j9qccn9587c3v"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-basement" ,ghc-basement)
- ("ghc-foundation" ,ghc-foundation)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "https://github.com/vincenthz/hs-memory")
- (synopsis "Memory abstractions for Haskell")
- (description
- "This package provides memory abstractions, such as chunk of memory,
-polymorphic byte array management and manipulation functions. It contains a
-polymorphic byte array abstraction and functions similar to strict ByteString,
-different type of byte array abstraction, raw memory IO operations (memory
-set, memory copy, ..) and more")
- (license license:bsd-3)))
-
-(define-public ghc-socks
- (package
- (name "ghc-socks")
- (version "0.5.6")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "socks/socks-" version ".tar.gz"))
- (sha256
- (base32
- "0f44qy74i0n6ll3jym0a2ipafkpw1h67amcpqmj8iq95h21wsqzs"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-cereal" ,ghc-cereal)
- ("ghc-network" ,ghc-network)))
- (home-page "https://github.com/vincenthz/hs-socks")
- (synopsis "SOCKS proxy (version 5) implementation")
- (description
- "This library provides a SOCKS proxy (version 5) implementation.")
- (license license:bsd-3)))
-
-(define-public ghc-connection
- (package
- (name "ghc-connection")
- (version "0.2.8")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "connection/connection-"
- version ".tar.gz"))
- (sha256
- (base32
- "1swkb9w5vx9ph7x55y51dc0srj2z27nd9ibgn8c0qcl6hx7g9cbh"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-byteable" ,ghc-byteable)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-network" ,ghc-network)
- ("ghc-tls" ,ghc-tls)
- ("ghc-socks" ,ghc-socks)
- ("ghc-x509" ,ghc-x509)
- ("ghc-x509-store" ,ghc-x509-store)
- ("ghc-x509-system" ,ghc-x509-system)
- ("ghc-x509-validation" ,ghc-x509-validation)))
- (home-page "https://github.com/vincenthz/hs-connection")
- (synopsis "Simple and easy network connections API")
- (description
- "This package provides a simple network library for all your connection
-needs. It provides a very simple API to create sockets to a destination with
-the choice of SSL/TLS, and SOCKS.")
- (license license:bsd-3)))
-
-(define-public ghc-skylighting-core
- (package
- (name "ghc-skylighting-core")
- (version "0.7.2")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "skylighting-core/skylighting-core-"
- version ".tar.gz"))
- (sha256
- (base32
- "066fwmwsd7xcvwlinfk2izlzq0xp8697i6lnbgsbl71jdybyackq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-colour" ,ghc-colour)
- ("ghc-hxt" ,ghc-hxt)
- ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
- ("ghc-safe" ,ghc-safe)
- ("ghc-utf8-string" ,ghc-utf8-string)))
- (native-inputs
- `(("ghc-diff" ,ghc-diff)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-pretty-show" ,ghc-pretty-show)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-golden" ,ghc-tasty-golden)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://github.com/jgm/skylighting")
- (synopsis "Syntax highlighting library")
- (description "Skylighting is a syntax highlighting library with support
-for over one hundred languages. It derives its tokenizers from XML syntax
-definitions used by KDE's @code{KSyntaxHighlighting} framework, so any syntax
-supported by that framework can be added. An optional command-line program is
-provided. Skylighting is intended to be the successor to highlighting-kate.")
- (license license:gpl2)))
-
-(define-public ghc-skylighting
- (package
- (inherit ghc-skylighting-core)
- (name "ghc-skylighting")
- (version "0.7.2")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/skylighting-"
- version "/skylighting-" version ".tar.gz"))
- (sha256
- (base32
- "1rh3z1a7a4clvksdw1qlpmhxqkfahwypi70k91whgfamzsqpxdch"))))
- (inputs
- `(("ghc-skylighting-core" ,ghc-skylighting-core)
- ,@(package-inputs ghc-skylighting-core)))))
-
-(define-public ghc-doctemplates
- (package
- (name "ghc-doctemplates")
- (version "0.2.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "doctemplates/doctemplates-"
- version ".tar.gz"))
- (sha256
- (base32
- "1gyckfg3kgvzhxw14i7iwrw0crygvsp86sy53bbr1yn7bxbgn33b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-vector" ,ghc-vector)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-scientific" ,ghc-scientific)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)))
- (home-page "https://github.com/jgm/doctemplates#readme")
- (synopsis "Pandoc-style document templates")
- (description
- "This package provides a simple text templating system used by pandoc.")
- (license license:bsd-3)))
-
-(define-public ghc-pandoc
- (package
- (name "ghc-pandoc")
- (version "2.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
- version ".tar.gz"))
- (sha256
- (base32
- "1dqin92w513l7whg5wdgrngnxsj5mb8gppfvn7kjgyv2pdgpy0zy"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "pandoc.cabal"
- (("tasty >= 0\\.11 && < 1\\.1")
- "tasty >= 0.11 && < 1.1.1"))))
- (add-before 'configure 'patch-tests
- (lambda _
- ;; These tests fail benignly and have been adjusted upstream:
- ;; <https://github.com/commercialhaskell/stackage/issues/3719>.
- (substitute* "test/Tests/Old.hs"
- (("lhsWriterTests \"html\"") "[]")))))))
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-aeson-pretty" ,ghc-aeson-pretty)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("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-text" ,ghc-hslua-module-text)
- ("ghc-http" ,ghc-http)
- ("ghc-http-client" ,ghc-http-client)
- ("ghc-http-client-tls" ,ghc-http-client-tls)
- ("ghc-http-types" ,ghc-http-types)
- ("ghc-juicypixels" ,ghc-juicypixels)
- ("ghc-network" ,ghc-network)
- ("ghc-network-uri" ,ghc-network-uri)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-pandoc-types" ,ghc-pandoc-types)
- ("ghc-random" ,ghc-random)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-sha" ,ghc-sha)
- ("ghc-skylighting" ,ghc-skylighting)
- ("ghc-split" ,ghc-split)
- ("ghc-syb" ,ghc-syb)
- ("ghc-tagsoup" ,ghc-tagsoup)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-texmath" ,ghc-texmath)
- ("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-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "https://pandoc.org")
- (synopsis "Conversion between markup formats")
- (description
- "Pandoc is a Haskell library for converting from one markup format to
-another, and a command-line tool that uses this library. It can read and
-write Markdown and (subsets of) other formats, such as HTML, reStructuredText,
-LaTeX, DocBook, and many more.
-
-Pandoc extends standard Markdown syntax with footnotes, embedded LaTeX,
-definition lists, tables, and other features. A compatibility mode is
-provided for those who need a drop-in replacement for Markdown.pl.")
- (license license:gpl2+)))
-
-(define-public ghc-hs-bibutils
- (package
- (name "ghc-hs-bibutils")
- (version "6.6.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hs-bibutils/hs-bibutils-"
- version ".tar.gz"))
- (sha256
- (base32
- "0n2sz2zl4naspryd49ii858qkjp2lapns5a2gr8zm6vvn5sh1f0l"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-syb" ,ghc-syb)))
- (home-page "https://hackage.haskell.org/package/hs-bibutils")
- (synopsis "Haskell bindings to bibutils")
- (description
- "This package provides Haskell bindings to @code{bibutils}, a library
-that interconverts between various bibliography formats using a common
-MODS-format XML intermediate.")
- (license license:gpl2+)))
-
-(define-public ghc-rfc5051
- (package
- (name "ghc-rfc5051")
- (version "0.1.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/rfc5051/"
- "rfc5051-" version ".tar.gz"))
- (sha256
- (base32
- "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/rfc5051")
- (synopsis "Simple unicode collation as per RFC5051")
- (description
- "This library implements @code{unicode-casemap}, the simple, non
-locale-sensitive unicode collation algorithm described in RFC 5051. Proper
-unicode collation can be done using @code{text-icu}, but that is a big
-dependency that depends on a large C library, and @code{rfc5051} might be
-better for some purposes.")
- (license license:bsd-3)))
-
-(define-public ghc-typed-process
- (package
- (name "ghc-typed-process")
- (version "0.2.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "typed-process/typed-process-"
- version ".tar.gz"))
- (sha256
- (base32
- "0j36vrc9w841m5qbwqra1lwiznx31xfnhin1sm8x2c2739csbpn0"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)))
- (native-inputs
- `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page "https://haskell-lang.org/library/typed-process")
- (synopsis "Run external processes with strong typing of streams")
- (description
- "This library provides the ability to launch and interact with external
-processes. It wraps around the @code{process} library, and intends to improve
-upon it.")
- (license license:expat)))
-
-(define-public ghc-conduit-extra
- (package
- (name "ghc-conduit-extra")
- (version "1.3.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "conduit-extra/conduit-extra-"
- version ".tar.gz"))
- (sha256
- (base32
- "0jaj350vv6mbb26gdwcqz4gwzfzrjydv5pis2da49wz1npbakcfw"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-conduit" ,ghc-conduit)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-typed-process" ,ghc-typed-process)
- ("ghc-async" ,ghc-async)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-network" ,ghc-network)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-streaming-commons" ,ghc-streaming-commons)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-bytestring-builder" ,ghc-bytestring-builder)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (native-inputs
- `(("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/snoyberg/conduit")
- (synopsis "Conduit adapters for common libraries")
- (description
- "The @code{conduit} package itself maintains relative small dependencies.
-The purpose of this package is to collect commonly used utility functions
-wrapping other library dependencies, without depending on heavier-weight
-dependencies. The basic idea is that this package should only depend on
-@code{haskell-platform} packages and @code{conduit}.")
- (license license:expat)))
-
-(define-public ghc-xml-types
- (package
- (name "ghc-xml-types")
- (version "0.3.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/xml-types/"
- "xml-types-" version ".tar.gz"))
- (sha256
- (base32
- "1jgqxsa9p2q3h6nymbfmvhldqrqlwrhrzmwadlyc0li50x0d8dwr"))))
- (build-system haskell-build-system)
- (home-page "https://john-millikin.com/software/haskell-xml/")
- (synopsis "Basic types for representing XML")
- (description "This package provides basic types for representing XML
-documents.")
- (license license:expat)))
-
-(define-public ghc-xml-conduit
- (package
- (name "ghc-xml-conduit")
- (version "1.8.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/xml-conduit/"
- "xml-conduit-" version ".tar.gz"))
- (sha256
- (base32
- "177gmyigxql1pn3ncz0r8annwv5cbxnihbgrrg1dhm4gmc9jy2wq"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-xml-types" ,ghc-xml-types)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/snoyberg/xml")
- (synopsis "Utilities for dealing with XML with the conduit package")
- (description
- "This package provides pure-Haskell utilities for dealing with XML with
-the @code{conduit} package.")
- (license license:expat)))
-
-(define-public ghc-pandoc-citeproc
- (package
- (name "ghc-pandoc-citeproc")
- (version "0.14.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "pandoc-citeproc/pandoc-citeproc-"
- version ".tar.gz"))
- (sha256
- (base32
- "0yj6rckwsc9vig40cm15ry0j3d01xpk04qma9n4byhal6v4b5h22"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- ;; Many YAML tests (44) are failing do to changes in ghc-yaml:
- ;; <https://github.com/jgm/pandoc-citeproc/issues/342>.
- (add-before 'configure 'patch-tests
- (lambda _
- (substitute* "tests/test-pandoc-citeproc.hs"
- (("let allTests = citeprocTests \\+\\+ biblio2yamlTests")
- "let allTests = citeprocTests"))))
- ;; Tests need to be run after installation.
- (delete 'check)
- (add-after 'install 'post-install-check
- (assoc-ref %standard-phases 'check)))))
- (inputs
- `(("ghc-pandoc-types" ,ghc-pandoc-types)
- ("ghc-pandoc" ,ghc-pandoc)
- ("ghc-tagsoup" ,ghc-tagsoup)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-vector" ,ghc-vector)
- ("ghc-xml-conduit" ,ghc-xml-conduit)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-data-default" ,ghc-data-default)
- ("ghc-setenv" ,ghc-setenv)
- ("ghc-split" ,ghc-split)
- ("ghc-yaml" ,ghc-yaml)
- ("ghc-hs-bibutils" ,ghc-hs-bibutils)
- ("ghc-rfc5051" ,ghc-rfc5051)
- ("ghc-syb" ,ghc-syb)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-aeson-pretty" ,ghc-aeson-pretty)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page "https://github.com/jgm/pandoc-citeproc")
- (synopsis "Library for using pandoc with citeproc")
- (description
- "The @code{pandoc-citeproc} library exports functions for using the
-citeproc system with pandoc. It relies on @code{citeproc-hs}, a library for
-rendering bibliographic reference citations into a variety of styles using a
-macro language called @dfn{Citation Style Language} (CSL). This package also
-contains an executable @code{pandoc-citeproc}, which works as a pandoc filter,
-and also has a mode for converting bibliographic databases a YAML format
-suitable for inclusion in pandoc YAML metadata.")
- (license license:bsd-3)))
-
-(define-public ghc-union-find
- (package
- (name "ghc-union-find")
- (version "0.2")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/union-find/union-find-"
- version ".tar.gz"))
- (sha256
- (base32
- "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/nominolo/union-find")
- (synopsis "Efficient union and equivalence testing of sets")
- (description
- "The Union/Find algorithm implements these operations in (effectively)
-constant-time:
-@enumerate
-@item Check whether two elements are in the same equivalence class.
-@item Create a union of two equivalence classes.
-@item Look up the descriptor of the equivalence class.
-@end enumerate\n")
- (license license:bsd-3)))
-
-(define-public ghc-base16-bytestring
- (package
- (name "ghc-base16-bytestring")
- (version "0.1.1.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/base16-bytestring/"
- "base16-bytestring-" version ".tar.gz"))
- (sha256
- (base32
- "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/bos/base16-bytestring")
- (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings")
- (description
- "This package provides a Haskell library for working with base16-encoded
-data quickly and efficiently, using the ByteString type.")
- (license license:bsd-3)))
-
-(define-public ghc-data-ordlist
- (package
- (name "ghc-data-ordlist")
- (version "0.4.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/data-ordlist/data-ordlist-"
- version ".tar.gz"))
- (sha256
- (base32
- "03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/data-ordlist")
- (synopsis "Set and bag operations on ordered lists")
- (description
- "This module provides set and multiset operations on ordered lists.")
- (license license:bsd-3)))
-
-(define-public ghc-regex-applicative
- (package
- (name "ghc-regex-applicative")
- (version "0.3.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-applicative/"
- "regex-applicative-" version ".tar.gz"))
- (sha256
- (base32
- "1riv7jqf26lbv4rm54sd6mrx8xdh4dvh4xbzymzdfdw13k6a4nb6"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-smallcheck" ,ghc-smallcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "https://github.com/feuerbach/regex-applicative")
- (synopsis "Regex-based parsing with applicative interface")
- (description
- "@code{regex-applicative} is a Haskell library for parsing using
-regular expressions. Parsers can be built using Applicative interface.")
- (license license:expat)))
-
-(define-public ghc-regex-tdfa
- (package
- (name "ghc-regex-tdfa")
- (version "1.2.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-tdfa/regex-tdfa-"
- version ".tar.gz"))
- (sha256
- (base32
- "0l7ajnh4hpgggf2a1r9dg0hx2fy679vd2kada5y7r02hy3nfxala"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-base" ,ghc-regex-base)))
- (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
- (synopsis "POSIX extended regular expressions in Haskell.")
- (description
- "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
-extended regular expressions. It is a \"tagged\" DFA regex engine. It is
-inspired by libtre.")
- (license license:bsd-3)))
-
-(define-public ghc-regex-compat-tdfa
- (package
- (name "ghc-regex-compat-tdfa")
- (version "0.95.1.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/regex-compat-tdfa/regex-compat-tdfa-"
- version ".tar.gz"))
- (sha256
- (base32
- "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-base" ,ghc-regex-base)
- ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
- (home-page "https://hub.darcs.net/shelarcy/regex-compat-tdfa")
- (synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
- (description
- "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
-@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
-This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
-this problem.")
- (license license:bsd-3)))
-
-(define-public ghc-sandi
- (package
- (name "ghc-sandi")
- (version "0.4.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/sandi/sandi-"
- version ".tar.gz"))
- (sha256
- (base32
- "0dvkpk91n9kz2ha04rvp231ra9sgd1ilyc1qkzf9l03iir7zrh9b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-stringsearch" ,ghc-stringsearch)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-tasty-th" ,ghc-tasty-th)))
- (home-page "https://hackage.haskell.org/package/sandi")
- (synopsis "Data encoding library")
- (description "Reasonably fast data encoding library.")
- (license license:bsd-3)))
-
-(define-public ghc-bytestring-handle
- (package
- (name "ghc-bytestring-handle")
- (version "0.1.0.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/bytestring-handle/bytestring-handle-"
- version ".tar.gz"))
- (sha256
- (base32
- "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "bytestring-handle.cabal"
- (("QuickCheck >= 2\\.1\\.2 && < 2\\.11")
- "QuickCheck >= 2.1.2 && < 2.12")
- (("base >= 4\\.2 && < 4\\.11")
- "base >= 4.2 && < 4.12")))))))
- (inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://hub.darcs.net/ganesh/bytestring-handle")
- (synopsis "ByteString-backed Handles")
- (description "ByteString-backed Handles") ; There is no description
- (license license:bsd-3)))
-
-(define-public ghc-tar
- (package
- (name "ghc-tar")
- (version "0.5.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/tar/tar-"
- version ".tar.gz"))
- (sha256
- (base32
- "0s2brvaxg5fki2jdkccmnpssiy6a3wjh24p6a3dkkdvjcixnk7f8"))))
- (build-system haskell-build-system)
- ;; FIXME: 2/24 tests fail.
- (arguments `(#:tests? #f))
- (inputs
- `(("ghc-bytestring-handle" ,ghc-bytestring-handle)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://hackage.haskell.org/package/tar")
- (synopsis "Reading, writing and manipulating \".tar\" archive files")
- (description
- "This library is for working with \\\"@.tar@\\\" archive files.
-It can read and write a range of common variations of the tar archive format
-including V7, POSIX USTAR and GNU formats. It provides support for packing and
-unpacking portable archives. This makes it suitable for distribution but not
-backup because details like file ownership and exact permissions are not
-preserved. It also provides features for random access to archive content using
-an index.")
- (license license:bsd-3)))
-
-(define-public ghc-stmonadtrans
- (package
- (name "ghc-stmonadtrans")
- (version "0.4.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/STMonadTrans"
- "/STMonadTrans-" version ".tar.gz"))
- (sha256
- (base32 "1nr26fnmi5fdjc6d00w13kjhmfyvb5b837d0006w4dj0yxndaksp"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/STMonadTrans")
- (synopsis "Monad transformer version of the ST monad")
- (description
- "This package provides a monad transformer version of the @code{ST} monad
-for strict state threads.")
- (license license:bsd-3)))
-
-(define-public ghc-findbin
- (package
- (name "ghc-findbin")
- (version "0.0.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/FindBin/FindBin-"
- version ".tar.gz"))
- (sha256
- (base32
- "197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/audreyt/findbin")
- (synopsis "Get the absolute path of the running program")
- (description
- "This module locates the full directory of the running program, to allow
-the use of paths relative to it. FindBin supports invocation of Haskell
-programs via \"ghci\", via \"runhaskell/runghc\", as well as compiled as
-an executable.")
- (license license:bsd-3)))
-
-(define-public ghc-patience
- (package
- (name "ghc-patience")
- (version "0.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/patience/patience-"
- version ".tar.gz"))
- (sha256
- (base32
- "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/patience")
- (synopsis "Patience diff and longest increasing subsequence")
- (description
- "This library implements the 'patience diff' algorithm, as well as the
-patience algorithm for the longest increasing subsequence problem.
-Patience diff computes the difference between two lists, for example the lines
-of two versions of a source file. It provides a good balance between
-performance, nice output for humans, and simplicity of implementation.")
- (license license:bsd-3)))
-
-(define-public ghc-monads-tf
- (package
- (name "ghc-monads-tf")
- (version "0.1.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/monads-tf/monads-tf-"
- version ".tar.gz"))
- (sha256
- (base32
- "1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/monads-tf")
- (synopsis "Monad classes, using type families")
- (description
- "Monad classes using type families, with instances for various monad transformers,
-inspired by the paper 'Functional Programming with Overloading and Higher-Order
-Polymorphism', by Mark P Jones. This package is almost a compatible replacement for
-the @code{mtl-tf} package.")
- (license license:bsd-3)))
-
-(define-public ghc-colour
-(package
- (name "ghc-colour")
- (version "2.3.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/colour/colour-"
- version ".tar.gz"))
- (sha256
- (base32
- "1sy51nz096sv91nxqk6yk7b92b5a40axv9183xakvki2nc09yhqg"))))
- (arguments
- ;; The tests for this package have the following dependency cycle:
- ;; ghc-test-framework -> ghc-ansi-terminal -> ghc-colour.
- `(#:tests? #f))
- (build-system haskell-build-system)
- (home-page "https://www.haskell.org/haskellwiki/Colour")
- (synopsis "Model for human colour perception")
- (description
- "This package provides a data type for colours and transparency.
-Colours can be blended and composed. Various colour spaces are
-supported. A module of colour names (\"Data.Colour.Names\") is provided.")
- (license license:expat)))
-
-(define-public ghc-wl-pprint-text
- (package
- (name "ghc-wl-pprint-text")
- (version "1.2.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/wl-pprint-text/wl-pprint-text-"
- version ".tar.gz"))
- (sha256
- (base32
- "0g3w92rad6x5appfb22rbzcas2ix2h0hy91sdxhq8a4a5cnlrpa0"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-base-compat" ,ghc-base-compat)))
- (home-page "https://hackage.haskell.org/package/wl-pprint-text")
- (synopsis "Wadler/Leijen Pretty Printer for Text values")
- (description
- "A clone of wl-pprint for use with the text library.")
- (license license:bsd-3)))
-
-(define-public ghc-fgl-arbitrary
- (package
- (name "ghc-fgl-arbitrary")
- (version "0.2.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/fgl-arbitrary/fgl-arbitrary-"
- version ".tar.gz"))
- (sha256
- (base32
- "0ln1szgfy8fa78l3issq4fx3aqnnd54w3cb4wssrfi48vd5rkfjm"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "fgl-arbitrary.cabal"
- (("QuickCheck >= 2\\.3 && < 2\\.10")
- "QuickCheck >= 2.3 && < 2.12")
- (("hspec >= 2\\.1 && < 2\\.5")
- "hspec >= 2.1 && < 2.6")))))))
- (inputs
- `(("ghc-fgl" ,ghc-fgl)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)))
- (home-page "https://hackage.haskell.org/package/fgl-arbitrary")
- (synopsis "QuickCheck support for fgl")
- (description
- "Provides Arbitrary instances for fgl graphs to avoid adding a
-QuickCheck dependency for fgl whilst still making the instances
-available to others. Also available are non-fgl-specific functions
-for generating graph-like data structures.")
- (license license:bsd-3)))
-
-(define-public ghc-graphviz
- (package
- (name "ghc-graphviz")
- (version "2999.20.0.2")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "graphviz/graphviz-" version ".tar.gz"))
- (sha256
- (base32
- "0kj7ap0gnliviq2p8lscw1m06capnsa90vpvcys24nqy5nw2wrp7"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-colour" ,ghc-colour)
- ("ghc-dlist" ,ghc-dlist)
- ("ghc-fgl" ,ghc-fgl)
- ("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
- ("ghc-polyparse" ,ghc-polyparse)
- ("ghc-temporary" ,ghc-temporary)
- ("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("graphviz" ,graphviz)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://hackage.haskell.org/package/graphviz")
- (synopsis "Bindings to Graphviz for graph visualisation")
- (description
- "This library provides bindings for the Dot language used by
-the @uref{https://graphviz.org/, Graphviz} suite of programs for
-visualising graphs, as well as functions to call those programs.
-Main features of the graphviz library include:
-
-@enumerate
-@item Almost complete coverage of all Graphviz attributes and syntax
-@item Support for specifying clusters
-@item The ability to use a custom node type
-@item Functions for running a Graphviz layout tool with all specified output types
-@item Generate and parse Dot code with two options: strict and liberal
-@item Functions to convert FGL graphs and other graph-like data structures
-@item Round-trip support for passing an FGL graph through Graphviz to augment node
-and edge labels with positional information, etc.
-@end enumerate\n")
- (license license:bsd-3)))
-
-(define-public ghc-constraints
- (package
- (name "ghc-constraints")
- (version "0.10.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/constraints/constraints-"
- version ".tar.gz"))
- (sha256
- (base32
- "1xy3vv78jxc17hm0z7qqspxjwv7l2jbcbj670yrl2f053qkfr02q"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hashable" ,ghc-hashable)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/ekmett/constraints/")
- (synopsis "Constraint manipulation")
- (description
- "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
-They stopped crashing the compiler in GHC 7.6. This package provides
-a vocabulary for working with them.")
- (license license:bsd-3)))
-
-(define-public ghc-lifted-async
- (package
- (name "ghc-lifted-async")
- (version "0.10.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/lifted-async/lifted-async-"
- version ".tar.gz"))
- (sha256
- (base32
- "1073r512c1x2m1v0jar9bwqg656slg7jd1jhsyj6m8awgx1l1mwf"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-constraints" ,ghc-constraints)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-th" ,ghc-tasty-th)))
- (home-page "https://github.com/maoe/lifted-async")
- (synopsis "Run lifted IO operations asynchronously and wait for their results")
- (description
- "This package provides IO operations from @code{async} package lifted to any
-instance of @code{MonadBase} or @code{MonadBaseControl}.")
- (license license:bsd-3)))
-
-;; Ghc-shelly depends on ghc-system-filepath and ghc-system-fileio, who in turn depend on
-;; ghc-chell and ghc-chell-quickcheck for the test phase. Ghc-chell depends on ghc-options
-;; which depends on ghc-chell and ghc-chell-quickcheck.
-;; Therefore we bootstrap it with tests disabled.
-(define ghc-system-filepath-bootstrap
- (package
- (name "ghc-system-filepath-bootstrap")
- (version "0.4.14")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/system-filepath/system-filepath-"
- version ".tar.gz"))
- (sha256
- (base32
- "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn"))))
- (build-system haskell-build-system)
- (arguments
- `(#:tests? #f))
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/fpco/haskell-filesystem")
- (synopsis "High-level, byte-based file and directory path manipulations")
- (description
- "Provides a FilePath datatype and utility functions for operating on it.
-Unlike the filepath package, this package does not simply reuse String,
-increasing type safety.")
- (license license:expat)))
-
-;; See ghc-system-filepath-bootstrap. In addition this package depends on
-;; ghc-system-filepath.
-(define ghc-system-fileio-bootstrap
- (package
- (name "ghc-system-fileio-bootstrap")
- (version "0.3.16.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/system-fileio/system-fileio-"
- version ".tar.gz"))
- (sha256
- (base32
- "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
- (build-system haskell-build-system)
- (arguments
- `(#:tests? #f))
- (inputs
- `(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page "https://github.com/fpco/haskell-filesystem")
- (synopsis "Consistent file system interaction across GHC versions")
- (description
- "This is a small wrapper around the directory, unix, and Win32 packages,
-for use with system-filepath. It provides a consistent API to the various
-versions of these packages distributed with different versions of GHC.
-In particular, this library supports working with POSIX files that have paths
-which can't be decoded in the current locale encoding.")
- (license license:expat)))
-
-(define-public ghc-shelly
- (package
- (name "ghc-shelly")
- (version "1.8.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/shelly/shelly-"
- version ".tar.gz"))
- (sha256
- (base32
- "023fbvbqs5gdwm30j5517gbdcc7fvz0md70dgwgpypkskj3i926y"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
- ("ghc-system-fileio-bootstrap" ,ghc-system-fileio-bootstrap)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-lifted-async" ,ghc-lifted-async)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
- ("ghc-async" ,ghc-async)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-hspec-contrib" ,ghc-hspec-contrib)))
- (home-page "https://github.com/yesodweb/Shelly.hs")
- (synopsis "Shell-like (systems) programming in Haskell")
- (description
- "Shelly provides convenient systems programming in Haskell, similar in
-spirit to POSIX shells. Shelly is originally forked from the Shellish package.")
- (license license:bsd-3)))
-
-;; See ghc-system-filepath-bootstrap, chell and chell-quickcheck are required for tests.
-(define ghc-options-bootstrap
- (package
- (name "ghc-options-bootstrap")
- (version "1.2.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/options/options-"
- version ".tar.gz"))
- (sha256
- (base32
- "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
- (build-system haskell-build-system)
- (arguments
- `(#:tests? #f))
- (inputs
- `(("ghc-monads-tf" ,ghc-monads-tf)))
- (home-page "https://john-millikin.com/software/haskell-options/")
- (synopsis "Powerful and easy-to-use command-line option parser")
- (description
- "The @code{options} package lets library and application developers
-easily work with command-line options.")
- (license license:expat)))
-
-(define-public ghc-chell
- (package
- (name "ghc-chell")
- (version "0.4.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/chell/chell-"
- version ".tar.gz"))
- (sha256
- (base32
- "10ingy9qnbmc8cqh4i9pskcw43l0mzk8f3d76b3qz3fig5ary3j9"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-options-bootstrap" ,ghc-options-bootstrap)
- ("ghc-patience" ,ghc-patience)
- ("ghc-random" ,ghc-random)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)))
- (home-page "https://john-millikin.com/software/chell/")
- (synopsis "Simple and intuitive library for automated testing")
- (description
- "Chell is a simple and intuitive library for automated testing.
-It natively supports assertion-based testing, and can use companion
-libraries such as @code{chell-quickcheck} to support more complex
-testing strategies.")
- (license license:expat)))
-
-(define ghc-chell-quickcheck-bootstrap
- (package
- (name "ghc-chell-quickcheck-bootstrap")
- (version "0.2.5.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/chell-quickcheck/"
- "chell-quickcheck-" version ".tar.gz"))
- (sha256
- (base32
- "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-chell" ,ghc-chell)
- ("ghc-random" ,ghc-random)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (arguments
- `(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "chell-quickcheck.cabal"
- (("QuickCheck >= 2\\.3 && < 2\\.11")
- "QuickCheck >= 2.3 && < 2.12")))))))
- (home-page "https://john-millikin.com/software/chell/")
- (synopsis "QuickCheck support for the Chell testing library")
- (description "More complex tests for @code{chell}.")
- (license license:expat)))
-
-(define-public ghc-chell-quickcheck
- (package
- (name "ghc-chell-quickcheck")
- (version "0.2.5.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/chell-quickcheck/"
- "chell-quickcheck-" version ".tar.gz"))
- (sha256
- (base32
- "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "chell-quickcheck.cabal"
- (("QuickCheck >= 2\\.3 && < 2\\.11")
- "QuickCheck >= 2.3 && < 2.12")))))))
- (inputs
- `(("ghc-chell" ,ghc-chell)
- ("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap)
- ("ghc-random" ,ghc-random)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://john-millikin.com/software/chell/")
- (synopsis "QuickCheck support for the Chell testing library")
- (description "More complex tests for @code{chell}.")
- (license license:expat)))
-
-(define-public ghc-options
- (package
- (name "ghc-options")
- (version "1.2.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/options/options-"
- version ".tar.gz"))
- (sha256
- (base32
- "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-monads-tf" ,ghc-monads-tf)
- ("ghc-chell" ,ghc-chell)
- ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)))
- (home-page "https://john-millikin.com/software/haskell-options/")
- (synopsis "Powerful and easy-to-use command-line option parser")
- (description
- "The @code{options} package lets library and application developers
-easily work with command-line options.")
- (license license:expat)))
-
-(define-public ghc-system-filepath
- (package
- (name "ghc-system-filepath")
- (version "0.4.14")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/system-filepath/system-filepath-"
- version ".tar.gz"))
- (sha256
- (base32
- "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn"))))
- (build-system haskell-build-system)
- ;; FIXME: One of the tests fails:
- ;; [ FAIL ] tests.validity.posix
- ;; note: seed=7310214548328823169
- ;; *** Failed! Falsifiable (after 24 tests):
- ;; FilePath "/r2\ENQ52\t ;$/o\US=/okG\146\&6\n<u\DC3/5\182\223a\DELN\EOT#\NUL/`[m/\USEKV\ETX([)b6/\ACK\SOo\245\ETBO/f\128\STX`|\EM\"/*\EMA\USD3/\143\&4/\CAN?\SUBee\CANR/9/B0\187Kx4/Vqr\232'b:/\a\234\DLE.\"\179/\ENQ{J/|/G)@^\237/\219ml/\DC3pd\ESC"
- (arguments `(#:tests? #f))
- (inputs
- `(("ghc-chell" ,ghc-chell)
- ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/fpco/haskell-filesystem")
- (synopsis "High-level, byte-based file and directory path manipulations")
- (description
- "Provides a FilePath datatype and utility functions for operating on it.
-Unlike the filepath package, this package does not simply reuse String,
-increasing type safety.")
- (license license:expat)))
-
-(define-public ghc-system-fileio
- (package
- (name "ghc-system-fileio")
- (version "0.3.16.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/system-fileio/system-fileio-"
- version ".tar.gz"))
- (sha256
- (base32
- "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-system-filepath" ,ghc-system-filepath)
- ("ghc-chell" ,ghc-chell)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page "https://github.com/fpco/haskell-filesystem")
- (synopsis "Consistent file system interaction across GHC versions")
- (description
- "This is a small wrapper around the directory, unix, and Win32 packages,
-for use with system-filepath. It provides a consistent API to the various
-versions of these packages distributed with different versions of GHC.
-In particular, this library supports working with POSIX files that have paths
-which can't be decoded in the current locale encoding.")
- (license license:expat)))
-
-(define-public ghc-storable-complex
- (package
- (name "ghc-storable-complex")
- (version "0.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/storable-complex/storable-complex-"
- version ".tar.gz"))
- (sha256
- (base32 "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/cartazio/storable-complex")
- (synopsis "Haskell Storable instance for Complex")
- (description "This package provides a Haskell library including a
-Storable instance for Complex which is binary compatible with C99, C++
-and Fortran complex data types.")
- (license license:bsd-3)))
-
-(define-public ghc-hmatrix
- (package
- (name "ghc-hmatrix")
- (version "0.19.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hmatrix/hmatrix-"
- version ".tar.gz"))
- (sha256
- (base32 "10jd69nby29dggghcyjk6ykyr5wrn97nrv1dkpyrp0y5xm12xssj"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-random" ,ghc-random)
- ("ghc-split" ,ghc-split)
- ("ghc-storable-complex" ,ghc-storable-complex)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-vector" ,ghc-vector)
- ;;("openblas" ,openblas)
- ("lapack" ,lapack)))
- ;; Guix's OpenBLAS is built with the flag "NO_LAPACK=1" which
- ;; disables inclusion of the LAPACK functions.
- ;; (arguments `(#:configure-flags '("--flags=openblas")))
- (home-page "https://github.com/albertoruiz/hmatrix")
- (synopsis "Haskell numeric linear algebra library")
- (description "The HMatrix package provices a Haskell library for
-dealing with linear systems, matrix decompositions, and other
-numerical computations based on BLAS and LAPACK.")
- (license license:bsd-3)))
-
-(define-public ghc-hmatrix-gsl
- (package
- (name "ghc-hmatrix-gsl")
- (version "0.19.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-"
- version ".tar.gz"))
- (sha256
- (base32 "0v6dla426x4ywaq59jm89ql1i42n39iw6z0j378xwb676v9kfxhm"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hmatrix" ,ghc-hmatrix)
- ("ghc-vector" ,ghc-vector)
- ("ghc-random" ,ghc-random)
- ("gsl" ,gsl)))
- (native-inputs `(("pkg-config" ,pkg-config)))
- (home-page "https://github.com/albertoruiz/hmatrix")
- (synopsis "Haskell GSL binding")
- (description "This Haskell library provides a purely functional
-interface to selected numerical computations, internally implemented
-using GSL.")
- (license license:gpl3+)))
-
-(define-public ghc-hmatrix-special
- (package
- (name "ghc-hmatrix-special")
- (version "0.19.0.0")
- (source
- (origin
- (method url-fetch)
- (uri
- (string-append
- "https://hackage.haskell.org/package/hmatrix-special/hmatrix-special-"
- version ".tar.gz"))
- (sha256
- (base32 "1mywr61kr852sbff26n9x95kswx9l4ycbv6s68qsbkh02xzqq7qz"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hmatrix" ,ghc-hmatrix)
- ("ghc-hmatrix-gsl" ,ghc-hmatrix-gsl)))
- (home-page "https://github.com/albertoruiz/hmatrix")
- (synopsis "Haskell interface to GSL special functions")
- (description "This library provides an interface to GSL special
-functions for Haskell.")
- (license license:gpl3+)))
-
-(define-public ghc-hmatrix-gsl-stats
- (package
- (name "ghc-hmatrix-gsl-stats")
- (version "0.4.1.7")
- (source
- (origin
- (method url-fetch)
- (uri
- (string-append
- "https://hackage.haskell.org/package/hmatrix-gsl-stats/hmatrix-gsl-stats-"
- version ".tar.gz"))
- (sha256
- (base32 "1gslgk58lzin43cvbpivhw7nrn9qyaa6qwhy1z9ypvyal5p8n3sa"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-vector" ,ghc-vector)
- ("ghc-storable-complex" ,ghc-storable-complex)
- ("ghc-hmatrix" ,ghc-hmatrix)
- ("gsl" ,gsl)))
- (native-inputs `(("pkg-config" ,pkg-config)))
- (home-page "http://code.haskell.org/hmatrix-gsl-stats")
- (synopsis "GSL Statistics interface for Haskell")
- (description "This Haskell library provides a purely functional
-interface for statistics based on hmatrix and GSL.")
- (license license:bsd-3)))
-
-(define-public ghc-easyplot
- (package
- (name "ghc-easyplot")
- (version "1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/easyplot/easyplot-"
- version ".tar.gz"))
- (sha256
- (base32 "18kndgvdj2apjpfga6fp7m16y1gx8zrwp3c5vfj03sx4v6jvciqk"))))
- (build-system haskell-build-system)
- (propagated-inputs `(("gnuplot" ,gnuplot)))
- (arguments
- `(#:phases (modify-phases %standard-phases
- (add-after 'unpack 'fix-setup-suffix
- (lambda _ (rename-file "Setup.lhs" "Setup.hs") #t)))))
- (home-page "https://hub.darcs.net/scravy/easyplot")
- (synopsis "Haskell plotting library based on gnuplot")
- (description "This package provides a plotting library for
-Haskell, using gnuplot for rendering.")
- (license license:expat)))
-
-(define-public ghc-hashtables
- (package
- (name "ghc-hashtables")
- (version "1.2.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hashtables/hashtables-"
- version ".tar.gz"))
- (sha256
- (base32 "1giw9caajr07slf09j7zry9b0kvm4yj9q78zy1mawzi6gk3wglcg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hashable" ,ghc-hashable)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-vector" ,ghc-vector)))
- (home-page "https://github.com/gregorycollins/hashtables")
- (synopsis "Haskell Mutable hash tables in the ST monad")
- (description "This package provides a Haskell library including a
-couple of different implementations of mutable hash tables in the ST
-monad, as well as a typeclass abstracting their common operations, and
-a set of wrappers to use the hash tables in the IO monad.")
- (license license:bsd-3)))
-
-(define-public ghc-data-accessor
- (package
- (name "ghc-data-accessor")
- (version "0.2.2.7")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/data-accessor/data-accessor-"
- version ".tar.gz"))
- (sha256
- (base32 "1vf2g1gac3rm32g97rl0fll51m88q7ry4m6khnl5j47qsmx24r9l"))))
- (build-system haskell-build-system)
- (home-page "https://www.haskell.org/haskellwiki/Record_access")
- (synopsis
- "Haskell utilities for accessing and manipulating fields of records")
- (description "This package provides Haskell modules for accessing and
-manipulating fields of records.")
- (license license:bsd-3)))
-
-(define-public ghc-data-accessor-transformers
- (package
- (name "ghc-data-accessor-transformers")
- (version "0.2.1.7")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/data-accessor-transformers/"
- "data-accessor-transformers-" version ".tar.gz"))
- (sha256
- (base32 "0yp030vafbpddl27m606aibbbr5ar5j5bsv4bksscz3cq4yq5j10"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-data-accessor" ,ghc-data-accessor)))
- (home-page "https://www.haskell.org/haskellwiki/Record_access")
- (synopsis "Use Accessor to access state in transformers State monad")
- (description "This package provides Haskell modules to allow use of
-Accessor to access state in transformers State monad.")
- (license license:bsd-3)))
-
-(define-public ghc-utility-ht
- (package
- (name "ghc-utility-ht")
- (version "0.0.14")
- (home-page "https://hackage.haskell.org/package/utility-ht")
- (source
- (origin
- (method url-fetch)
- (uri (string-append home-page "/utility-ht-" version ".tar.gz"))
- (sha256
- (base32 "1a7bgk7wv7sqbxbiv7kankiimr3wij7zdm7s83zwsf886ghyxhk9"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
- (synopsis "Haskell helper functions for Lists, Maybes, Tuples, Functions")
- (description "This package includes Hakell modules providing various
-helper functions for Lists, Maybes, Tuples, Functions.")
- (license license:bsd-3)))
-
-(define-public ghc-gnuplot
- (package
- (name "ghc-gnuplot")
- (version "0.5.5.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/gnuplot/gnuplot-"
- version ".tar.gz"))
- (sha256
- (base32 "1mlppnc13ygjzmf6ldydys4wvy35yb3xjwwfgf9rbi7nfcqjr6mn"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-temporary" ,ghc-temporary)
- ("ghc-utility-ht" ,ghc-utility-ht)
- ("ghc-data-accessor-transformers" ,ghc-data-accessor-transformers)
- ("ghc-data-accessor" ,ghc-data-accessor)
- ("ghc-semigroups" ,ghc-semigroups)
- ("gnuplot" ,gnuplot)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'fix-path-to-gnuplot
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((gnuplot (assoc-ref inputs "gnuplot")))
- (substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
- (("(gnuplotName = ).*$" all cmd)
- (string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
- (home-page "https://www.haskell.org/haskellwiki/Gnuplot")
- (synopsis "2D and 3D plots using gnuplot")
- (description "This package provides a Haskell module for creating 2D and
-3D plots using gnuplot.")
- (license license:bsd-3)))
-
-(define-public ghc-hinotify
- (package
- (name "ghc-hinotify")
- (version "0.3.10")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hinotify/"
- "hinotify-" version ".tar.gz"))
- (sha256
- (base32
- "17ax3n68a5c2ddazp86aciliskrh6znd3bnry0wcllmb6dbpsaxg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)))
- (home-page "https://github.com/kolmodin/hinotify.git")
- (synopsis "Haskell binding to inotify")
- (description "This library provides a wrapper to the Linux kernel's inotify
-feature, allowing applications to subscribe to notifications when a file is
-accessed or modified.")
- (license license:bsd-3)))
-
-(define-public ghc-fsnotify
- (package
- (name "ghc-fsnotify")
- (version "0.3.0.1")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/fsnotify/"
- "fsnotify-" version ".tar.gz"))
- (sha256
- (base32
- "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)
- ("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-hinotify" ,ghc-hinotify)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-random" ,ghc-random)
- ("ghc-shelly" ,ghc-shelly)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page "https://github.com/haskell-fswatch/hfsnotify")
- (synopsis "Cross platform library for file change notification.")
- (description "Cross platform library for file creation, modification, and
-deletion notification. This library builds upon existing libraries for platform
-specific Windows, Mac, and Linux file system event notification.")
- (license license:bsd-3)))
-
-(define-public ghc-ieee754
- (package
- (name "ghc-ieee754")
- (version "0.8.0")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/ieee754/"
- "ieee754-" version ".tar.gz"))
- (sha256
- (base32
- "1lcs521g9lzy9d7337vg4w7q7s8500rfqy7rcifcz6pm6yfgyb8f"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/patperry/hs-ieee754")
- (synopsis "Utilities for dealing with IEEE floating point numbers")
- (description "Utilities for dealing with IEEE floating point numbers,
-ported from the Tango math library; approximate and exact equality comparisons
-for general types.")
- (license license:bsd-3)))
-
-(define-public ghc-terminal-size
- (package
- (name "ghc-terminal-size")
- (version "0.3.2.1")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/terminal-size/"
- "terminal-size-" version ".tar.gz"))
- (sha256
- (base32
- "0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/terminal-size")
- (synopsis "Get terminal window height and width")
- (description "Get terminal window height and width without ncurses
-dependency.")
- (license license:bsd-3)))
-
-(define-public ghc-language-c
- (package
- (name "ghc-language-c")
- (version "0.8.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "language-c/language-c-" version ".tar.gz"))
- (sha256
- (base32
- "0sdkjj0hq8p69fcdm6ljbjkjvrsrb8a6rl5dq6dj6byj32ajrm3d"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-syb" ,ghc-syb)))
- (native-inputs
- `(("ghc-happy" ,ghc-happy)
- ("ghc-alex" ,ghc-alex)))
- (home-page "https://visq.github.io/language-c/")
- (synopsis "Analysis and generation of C code")
- (description
- "Language C is a Haskell library for the analysis and generation of C code.
-It features a complete, well-tested parser and pretty printer for all of C99
-and a large set of GNU extensions.")
- (license license:bsd-3)))
-
-(define-public ghc-markdown-unlit
- (package
- (name "ghc-markdown-unlit")
- (version "0.5.0")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/markdown-unlit/"
- "markdown-unlit-" version ".tar.gz"))
- (sha256
- (base32
- "1gy79vr85vcp13rdjh0hz7zv6daqqffww4j0cqn2lpjjh9xhsbg7"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-silently" ,ghc-silently)
- ("ghc-stringbuilder" ,ghc-stringbuilder)
- ("ghc-temporary" ,ghc-temporary)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/sol/markdown-unlit#readme")
- (synopsis "Literate Haskell support for Markdown")
- (description "This package allows you to have a README.md that at the
-same time is a literate Haskell program.")
- (license license:expat)))
-
-(define-public ghc-wave
- (package
- (name "ghc-wave")
- (version "0.1.5")
- (source (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/wave/wave-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "03zycmwrchhqvi37fdvlzz2d1vl4hy0i8xyys1zznw38qfq0h2i5"))))
- (build-system haskell-build-system)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "wave.cabal"
- (("temporary.* < 1\\.3")
- "temporary >= 1.1 && < 1.4")))))))
- (inputs
- `(("ghc-cereal" ,ghc-cereal)
- ("ghc-data-default-class"
- ,ghc-data-default-class)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-temporary" ,ghc-temporary)))
- (native-inputs
- `(("hspec-discover" ,hspec-discover)
- ("ghc-hspec" ,ghc-hspec)))
- (home-page "https://github.com/mrkkrp/wave")
- (synopsis "Work with WAVE and RF64 files in Haskell")
- (description "This package allows you to work with WAVE and RF64
-files in Haskell.")
- (license license:bsd-3)))
-
-(define-public ghc-hslogger
- (package
- (name "ghc-hslogger")
- (version "1.2.10")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hslogger-" version "/" "hslogger-"
- version ".tar.gz"))
- (sha256 (base32
- "0as5gvlh6pi2gflakp695qnlizyyp059dqrhvjl4gjxalja6xjnp"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-network" ,ghc-network)
- ("ghc-old-locale" ,ghc-old-locale)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page "https://software.complete.org/hslogger")
- (synopsis "Logging framework for Haskell, similar to Python's logging module")
- (description "Hslogger lets each log message have a priority and source be
-associated with it. The programmer can then define global handlers that route
-or filter messages based on the priority and source. It also has a syslog
-handler built in.")
- (license license:bsd-3)))
-
-(define-public ghc-unexceptionalio
- (package
- (name "ghc-unexceptionalio")
- (version "0.4.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "unexceptionalio-" version "/" "unexceptionalio-"
- version ".tar.gz"))
- (sha256 (base32 "09gynk472l7nn5l2w320n4dwigwp0wh0shfp6dyw6r5h2jdxz18p"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/singpolyma/unexceptionalio")
- (synopsis "IO without any non-error, synchronous exceptions")
- (description "When you've caught all the exceptions that can be
-handled safely, this is what you're left with.")
- (license license:isc)))
-
-(define-public ghc-json
- (package
- (name "ghc-json")
- (version "0.9.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/json/"
- "json-" version ".tar.gz"))
- (sha256
- (base32
- "13kkfgx58z18jphbg56jn08jn72wi3kvfndlwwx87hqwg7x1dfz6"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-syb" ,ghc-syb)))
- (home-page "https://hackage.haskell.org/package/json")
- (synopsis "Serializes Haskell data to and from JSON")
- (description "This package provides a parser and pretty printer for
-converting between Haskell values and JSON.
-JSON (JavaScript Object Notation) is a lightweight data-interchange format.")
- (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
-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))))
-
-(define-public ghc-simple-sendfile
- (package
- (name "ghc-simple-sendfile")
- (version "0.2.27")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "simple-sendfile-" version "/"
- "simple-sendfile-" version ".tar.gz"))
- (sha256
- (base32
- "1bwwqzcm56m2w4ymsa054sxmpbj76h9pvb0jf8zxp8lr41cp51gn"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-network" ,ghc-network)
- ("ghc-resourcet" ,ghc-resourcet)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/kazu-yamamoto/simple-sendfile")
- (synopsis "Cross platform library for the sendfile system call")
- (description "This library tries to call minimum system calls which
-are the bottleneck of web servers.")
- (license license:bsd-3)))
-
-(define-public ghc-hex
- (package
- (name "ghc-hex")
- (version "0.1.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "hex-" version "/"
- "hex-" version ".tar.gz"))
- (sha256
- (base32
- "1v31xiaivrrn0q2jz8919wvkjplv1kxna5ajhsj701fqxm1i5vhj"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/hex")
- (synopsis "Convert strings into hexadecimal and back")
- (description "This package provides conversion functions between
-bytestrings and their hexademical representation.")
- (license license:bsd-3)))
-
-(define-public ghc-psqueues
- (package
- (name "ghc-psqueues")
- (version "0.2.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "psqueues-" version "/"
- "psqueues-" version ".tar.gz"))
- (sha256
- (base32
- "1sjgc9bxh63kkdp59nbirx3xazr02ia5yhp4f4a0jnq1hj465wsc"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hashable" ,ghc-hashable)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/jaspervdj/psqueues")
- (synopsis "Pure priority search queues")
- (description "The psqueues package provides
-@uref{https://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in
-three different flavors:
-
-@itemize
-@item @code{OrdPSQ k p v}, which uses the @code{Ord k} instance to provide
-fast insertion, deletion and lookup. This implementation is based on Ralf
-Hinze's @uref{http://citeseer.ist.psu.edu/hinze01simple.html, A Simple
-Implementation Technique for Priority Search Queues}.
-
-Hence, it is similar to the @uref{https://hackage.haskell.org/package/PSQueue,
-PSQueue} library, although it is considerably faster and provides a slightly
-different API.
-
-@item @code{IntPSQ p v} is a far more efficient implementation. It fixes the
-key type to @code{Int} and uses a
-@code{https://en.wikipedia.org/wiki/Radix_tree, radix tree} (like @code{IntMap})
-with an additional min-heap property.
-
-@item @code{HashPSQ k p v} is a fairly straightforward extension
-of @code{IntPSQ}: it simply uses the keys' hashes as indices in the
-@code{IntPSQ}. If there are any hash collisions, it uses an
-@code{OrdPSQ} to resolve those. The performance of this implementation
-is comparable to that of @code{IntPSQ}, but it is more widely
-applicable since the keys are not restricted to @code{Int},
-but rather to any @code{Hashable} datatype.
-@end itemize
-
-Each of the three implementations provides the same API, so they can
-be used interchangeably.
-
-Typical applications of Priority Search Queues include:
-
-@itemize
-@item Caches, and more specifically LRU Caches;
-@item Schedulers;
-@item Pathfinding algorithms, such as Dijkstra's and A*.
-@end itemize")
- (license license:bsd-3)))
-
-(define-public ghc-glob
- (package
- (name "ghc-glob")
- (version "0.9.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "Glob-" version "/"
- "Glob-" version ".tar.gz"))
- (sha256
- (base32
- "1rbwcq9w9951qsnp13vqcm9r01yax2yh1wk8s4zxa3ckk9717iwg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-dlist" ,ghc-dlist)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "http://iki.fi/matti.niemenmaa/glob/")
- (synopsis "Haskell library matching glob patterns against file paths")
- (description "This package provides a Haskell library for @dfn{globbing}:
-matching patterns against file paths.")
- (license license:bsd-3)))
-
-(define-public ghc-errors
- (package
- (name "ghc-errors")
- (version "2.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "errors-" version "/"
- "errors-" version ".tar.gz"))
- (sha256
- (base32
- "0x8znwn31qcx6kqx99wp7bc86kckfb39ncz3zxvj1s07kxlfawk7"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-exceptions" ,ghc-exceptions)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-unexceptionalio" ,ghc-unexceptionalio)
- ("ghc-safe" ,ghc-safe)))
- (home-page "https://github.com/gabriel439/haskell-errors-library")
- (synopsis "Error handling library for Haskell")
- (description "This library encourages an error-handling style that
-directly uses the type system, rather than out-of-band exceptions.")
- (license license:bsd-3)))
-
-(define-public ghc-vector-th-unbox
- (package
- (name "ghc-vector-th-unbox")
- (version "0.2.1.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "vector-th-unbox-" version "/"
- "vector-th-unbox-" version ".tar.gz"))
- (sha256
- (base32
- "0d82x55f5vvr1jvaia382m23rs690lg55pvavv8f4ph0y6kd91xy"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-vector" ,ghc-vector)
- ("ghc-data-default" ,ghc-data-default)))
- (home-page "https://github.com/liyang/vector-th-unbox")
- (synopsis "Deriver for Data.Vector.Unboxed using Template Haskell")
- (description "This Haskell library provides a Template Haskell
-deriver for unboxed vectors, given a pair of coercion functions to
-and from some existing type with an Unbox instance.")
- (license license:bsd-3)))
-
-(define-public ghc-erf
- (package
- (name "ghc-erf")
- (version "2.0.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "erf-" version "/"
- "erf-" version ".tar.gz"))
- (sha256
- (base32
- "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/erf")
- (synopsis "The error function, erf, and related functions for Haskell")
- (description "This Haskell library provides a type class for the
-error function, erf, and related functions. Instances for Float and
-Double.")
- (license license:bsd-3)))
-
-(define-public ghc-math-functions
- (package
- (name "ghc-math-functions")
- (version "0.2.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "math-functions-" version "/"
- "math-functions-" version ".tar.gz"))
- (sha256
- (base32
- "1sv5vabsx332v1lpb6v3jv4zrzvpx1n7yprzd8wlcda5vsc5a6zp"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: 1 test fails.
- (inputs
- `(("ghc-vector" ,ghc-vector)
- ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-erf" ,ghc-erf)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/bos/math-functions")
- (synopsis "Special functions and Chebyshev polynomials for Haskell")
- (description "This Haskell library provides implementations of
-special mathematical functions and Chebyshev polynomials. These
-functions are often useful in statistical and numerical computing.")
- (license license:bsd-3)))
-
-(define-public ghc-mwc-random
- (package
- (name "ghc-mwc-random")
- (version "0.13.6.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "mwc-random-" version "/"
- "mwc-random-" version ".tar.gz"))
- (sha256
- (base32
- "05j7yh0hh9nxic3dijmzv44kc6gzclvamdph7sq7w19wq57k6pq6"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-primitive" ,ghc-primitive)
- ("ghc-vector" ,ghc-vector)
- ("ghc-math-functions" ,ghc-math-functions)))
- (arguments
- `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/bos/mwc-random")
- (synopsis "Random number generation library for Haskell")
- (description "This Haskell package contains code for generating
-high quality random numbers that follow either a uniform or normal
-distribution. The generated numbers are suitable for use in
-statistical applications.
-
-The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222)
-multiply-with-carry generator, which has a period of 2^{8222} and
-fares well in tests of randomness. It is also extremely fast,
-between 2 and 3 times faster than the Mersenne Twister.")
- (license license:bsd-3)))
-
-(define-public ghc-vector-algorithms
- (package
- (name "ghc-vector-algorithms")
- (version "0.7.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "vector-algorithms-" version "/"
- "vector-algorithms-" version ".tar.gz"))
- (sha256
- (base32
- "0mfa8ig9v69l41p2vb5jl4qmaln5y1rlzarr2mlgm8g1nvq8qqdg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/bos/math-functions")
- (synopsis "Algorithms for vector arrays in Haskell")
- (description "This Haskell library algorithms for vector arrays.")
- (license license:bsd-3)))
-
-(define-public ghc-language-haskell-extract
- (package
- (name "ghc-language-haskell-extract")
- (version "0.2.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "language-haskell-extract-" version "/"
- "language-haskell-extract-" version ".tar.gz"))
- (sha256
- (base32
- "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-regex-posix" ,ghc-regex-posix)))
- (home-page "https://github.com/finnsson/template-helper")
- (synopsis "Haskell module to automatically extract functions from
-the local code")
- (description "This package contains helper functions on top of
-Template Haskell.
-
-For example, @code{functionExtractor} extracts all functions after a
-regexp-pattern, which can be useful if you wish to extract all functions
-beginning with @code{test} (for a test framework) or all functions beginning
-with @code{wc} (for a web service).")
- (license license:bsd-3)))
-
-(define-public ghc-abstract-par
- (package
- (name "ghc-abstract-par")
- (version "0.3.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "abstract-par-" version "/"
- "abstract-par-" version ".tar.gz"))
- (sha256
- (base32
- "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/simonmar/monad-par")
- (synopsis "Abstract parallelization interface for Haskell")
- (description "This Haskell package is an abstract interface
-only. It provides a number of type clasess, but not an
-implementation. The type classes separate different levels
-of @code{Par} functionality. See the @code{Control.Monad.Par.Class}
-module for more details.")
- (license license:bsd-3)))
-
-(define-public ghc-monad-par-extras
- (package
- (name "ghc-monad-par-extras")
- (version "0.3.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "monad-par-extras-" version "/"
- "monad-par-extras-" version ".tar.gz"))
- (sha256
- (base32
- "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
- ("ghc-cereal" ,ghc-cereal)
- ("ghc-random" ,ghc-random)))
- (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-abstract-deque
- (package
- (name "ghc-abstract-deque")
- (version "0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "abstract-deque-" version "/"
- "abstract-deque-" version ".tar.gz"))
- (sha256
- (base32
- "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-random" ,ghc-random)))
- (home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
- (synopsis "Abstract, parameterized interface to mutable Deques for Haskell")
- (description "This Haskell package provides an abstract interface to
-highly-parameterizable queues/deques.
-
-Background: There exists a feature space for queues that extends between:
-
-@itemize
-@item Simple, single-ended, non-concurrent, bounded queues
-
-@item Double-ended, thread-safe, growable queues with important points
-in between (such as the queues used for work stealing).
-@end itemize
-
-This package includes an interface for Deques that allows the programmer
-to use a single API for all of the above, while using the type system to
-select an efficient implementation given the requirements (using type families).
-
-This package also includes a simple reference implementation based on
-@code{IORef} and @code{Data.Sequence}.")
- (license license:bsd-3)))
-
-(define-public ghc-monad-par
- (package
- (name "ghc-monad-par")
- (version "0.3.4.8")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "monad-par-" version "/"
- "monad-par-" version ".tar.gz"))
- (sha256
- (base32
- "0ldrzqy24fsszvn2a2nr77m2ih7xm0h9bgkjyv1l274aj18xyk7q"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
- ("ghc-abstract-deque" ,ghc-abstract-deque)
- ("ghc-monad-par-extras" ,ghc-monad-par-extras)
- ("ghc-mwc-random" ,ghc-mwc-random)
- ("ghc-parallel" ,ghc-parallel)))
- (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2"
- ,ghc-test-framework-quickcheck2)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-th" ,ghc-test-framework-th)))
- (home-page "https://github.com/simonmar/monad-par")
- (synopsis "Haskell library for parallel programming based on a monad")
- (description "The @code{Par} monad offers an API for parallel
-programming. The library works for parallelising both pure and @code{IO}
-computations, although only the pure version is deterministic. The default
-implementation provides a work-stealing scheduler and supports forking tasks
-that are much lighter weight than IO-threads.")
- (license license:bsd-3)))
-
-(define-public ghc-statistics
- (package
- (name "ghc-statistics")
- (version "0.14.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "statistics-" version "/"
- "statistics-" version ".tar.gz"))
- (sha256
- (base32
- "0y27gafkib0x0fn39qfn2rkgsfrm09ng35sbb5dwr7rclhnxz59l"))))
- (build-system haskell-build-system)
- (arguments
- '(#:cabal-revision
- ("2" "1bx70yqkn62ii17fjv3pig4hklrzkqd09zj67zzjiyjzmn04fir3")
- ;; Two tests fail: "Discrete CDF is OK" and "Quantile is CDF inverse".
- #:tests? #f))
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-erf" ,ghc-erf)
- ("ghc-math-functions" ,ghc-math-functions)
- ("ghc-monad-par" ,ghc-monad-par)
- ("ghc-mwc-random" ,ghc-mwc-random)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-vector" ,ghc-vector)
- ("ghc-vector-algorithms" ,ghc-vector-algorithms)
- ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)
- ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-ieee754" ,ghc-ieee754)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/bos/mwc-random")
- (synopsis "Haskell library of statistical types, data, and functions")
- (description "This library provides a number of common functions
-and types useful in statistics. We focus on high performance, numerical
-robustness, and use of good algorithms. Where possible, we provide references
-to the statistical literature.
-
-The library's facilities can be divided into four broad categories:
-
-@itemize
-@item Working with widely used discrete and continuous probability
-distributions. (There are dozens of exotic distributions in use; we focus
-on the most common.)
-
-@item Computing with sample data: quantile estimation, kernel density
-estimation, histograms, bootstrap methods, significance testing,
-and regression and autocorrelation analysis.
-
-@item Random variate generation under several different distributions.
-
-@item Common statistical tests for significant differences between samples.
-@end itemize")
- (license license:bsd-2)))
-
-(define-public ghc-chunked-data
- (package
- (name "ghc-chunked-data")
- (version "0.3.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "chunked-data-" version "/"
- "chunked-data-" version ".tar.gz"))
- (sha256
- (base32
- "16m7y7fwrirbjbqqcsfmr4yxa9qvfax6r7pw0zl9ky71ms0wa47p"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-vector" ,ghc-vector)
- ("ghc-semigroups" ,ghc-semigroups)))
- (home-page "https://github.com/snoyberg/mono-traversable")
- (synopsis "Typeclasses for dealing with various chunked data
-representations for Haskell")
- (description "This Haskell package was originally present in
-classy-prelude.")
- (license license:expat)))
-
-(define-public ghc-base-prelude
- (package
- (name "ghc-base-prelude")
- (version "1.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "base-prelude-" version "/"
- "base-prelude-" version ".tar.gz"))
- (sha256
- (base32
- "1zk728sd09hh2r4xwz4lazsrrgg5cshydn64932sm0vckplndk73"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/nikita-volkov/base-prelude")
- (synopsis "The most complete prelude formed solely from the Haskell's base
-package")
- (description "This Haskell package aims to reexport all the non-conflicting
-and most general definitions from the \"base\" package.
-
-This includes APIs for applicatives, arrows, monoids, foldables, traversables,
-exceptions, generics, ST, MVars and STM.
-
-This package will never have any dependencies other than \"base\".
-
-Versioning policy:
-
-The versioning policy of this package deviates from PVP in the sense
-that its exports in part are transitively determined by the version of \"base\".
-Therefore it's recommended for the users of @code{ghc-base-prelude} to specify
-the bounds of \"base\" as well.")
- (license license:expat)))
-
-(define-public ghc-tuple-th
- (package
- (name "ghc-tuple-th")
- (version "0.2.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "tuple-th-" version "/"
- "tuple-th-" version ".tar.gz"))
- (sha256
- (base32
- "1mrl4vvxmby7sf1paf7hklzidnr6wq55822i73smqyz0xpf3gsjn"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/DanielSchuessler/tuple-th")
- (synopsis "Generate utility functions for tuples of statically known size
-for Haskell")
- (description "This Haskell package contains Template Haskell functions for
-generating functions similar to those in @code{Data.List} for tuples of
-statically known size.")
- (license license:bsd-3)))
-
-(define-public ghc-contravariant-extras
- (package
- (name "ghc-contravariant-extras")
- (version "0.3.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "contravariant-extras-" version "/"
- "contravariant-extras-" version ".tar.gz"))
- (sha256
- (base32
- "0gg62ccl94kvh7mnvdq09pifqxjx2kgs189si90nmg44bafj7a9n"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-tuple-th" ,ghc-tuple-th)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-base-prelude" ,ghc-base-prelude)
- ("ghc-semigroups" ,ghc-semigroups)))
- (home-page "https://github.com/nikita-volkov/contravariant-extras")
- (synopsis "Extras for the @code{ghc-contravariant} Haskell package")
- (description "This Haskell package provides extras for the
-@code{ghc-contravariant} package.")
- (license license:expat)))
-
-(define-public ghc-monadrandom
- (package
- (name "ghc-monadrandom")
- (version "0.5.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "MonadRandom-" version "/"
- "MonadRandom-" version ".tar.gz"))
- (sha256
- (base32
- "0w44jl1n3kqvqaflh82l1wj3xxbhzfs3kf4m8rk7w6fgg8llmnmb"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-fail" ,ghc-fail)
- ("ghc-random" ,ghc-random)))
- (home-page "https://github.com/byorgey/MonadRandom")
- (synopsis "Random-number generation monad for Haskell")
- (description "This Haskell package provides support for computations
-which consume random values.")
- (license license:bsd-3)))
-
-(define-public ghc-either
- (package
- (name "ghc-either")
- (version "5.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "either-" version "/"
- "either-" version ".tar.gz"))
- (sha256
- (base32
- "064hjfld7dkzs78sy30k5qkiva3hx24rax6dvzz5ygr2c0zypdkc"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-free" ,ghc-free)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-manodrandom" ,ghc-monadrandom)
- ("ghc-mmorph" ,ghc-mmorph)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-transformers-base" ,ghc-transformers-base)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/ekmett/either")
- (synopsis "Provides an either monad transformer for Haskell")
- (description "This Haskell package provides an either monad transformer.")
- (license license:bsd-3)))
-
-(define-public ghc-pretty-hex
- (package
- (name "ghc-pretty-hex")
- (version "1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "pretty-hex-" version "/"
- "pretty-hex-" version ".tar.gz"))
- (sha256
- (base32
- "0ylwkvvjvmpprha9nx83xb8gkhyanhk5fffc0r7lb96n4ch5z6pz"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/GaloisInc/hexdump")
- (synopsis "Haskell library for hex dumps of ByteStrings")
- (description "This Haskell library generates pretty hex dumps of
-ByteStrings in the style of other common *nix hex dump tools.")
- (license license:bsd-3)))
-
-(define-public ghc-network-info
- (package
- (name "ghc-network-info")
- (version "0.2.0.10")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "network-info-" version "/"
- "network-info-" version ".tar.gz"))
- (sha256
- (base32
- "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/jystic/network-info")
- (synopsis "Access the local computer's basic network configuration")
- (description "This Haskell library provides simple read-only access to the
-local computer's networking configuration. It is currently capable of
-getting a list of all the network interfaces and their respective
-IPv4, IPv6 and MAC addresses.")
- (license license:bsd-3)))
-
-(define-public ghc-uuid-types
- (package
- (name "ghc-uuid-types")
- (version "1.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "uuid-types-" version "/"
- "uuid-types-" version ".tar.gz"))
- (sha256
- (base32
- "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'strip-test-framework-constraints
- (lambda _
- (substitute* "uuid-types.cabal"
- (("HUnit >=1\\.2 && < 1\\.4") "HUnit")
- (("QuickCheck >=2\\.4 && < 2\\.9") "QuickCheck")
- (("tasty >= 0\\.10 && < 0\\.12") "tasty")
- (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit")
- (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
- (inputs `(("ghc-hashable" ,ghc-hashable)
- ("ghc-random" ,ghc-random)))
- (native-inputs `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://github.com/hvr/uuid")
- (synopsis "Haskell type definitions for UUIDs")
- (description "This Haskell library contains type definitions for
-@dfn{Universally Unique Identifiers} or
-@uref{https://en.wikipedia.org/wiki/UUID, UUIDs}, and basic conversion
-functions.")
- (license license:bsd-3)))
-
-(define-public ghc-uuid
- (package
- (name "ghc-uuid")
- (version "1.3.13")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "uuid-" version "/"
- "uuid-" version ".tar.gz"))
- (sha256
- (base32
- "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("2" "0m185q62jkfb5jsv358nxbnrkv8y8hd0qqvgvh22wvc5g9ipz0r9")
- #:phases
- (modify-phases %standard-phases
- (add-before 'configure 'strip-test-framework-constraints
- (lambda _
- (substitute* "uuid.cabal"
- (("HUnit >= 1\\.2 && < 1\\.4") "HUnit")
- (("QuickCheck >= 2\\.4 && < 2\\.10") "QuickCheck")
- (("tasty >= 0\\.10 && < 0\\.12") "tasty")
- (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit")
- (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck")))))))
- (inputs `(("ghc-cryptohash-sha1" ,ghc-cryptohash-sha1)
- ("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
- ("ghc-entropy" ,ghc-entropy)
- ("ghc-network-info" ,ghc-network-info)
- ("ghc-random" ,ghc-random)
- ("ghc-uuid-types" ,ghc-uuid-types)))
- (native-inputs `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://github.com/hvr/uuid")
- (synopsis "Haskell library to create, compare, parse, and print UUIDs")
- (description "This Haskell library provides utilities creating, comparing,
-parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.")
- (license license:bsd-3)))
-
-(define-public ghc-rebase
- (package
- (name "ghc-rebase")
- (version "1.2.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "rebase-" version "/"
- "rebase-" version ".tar.gz"))
- (sha256
- (base32
- "1gah2qwfpzwamnikbc5h4nv6dgvv9h16di9ka7946za3nibyasya"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-hashable" ,ghc-hashable)
- ("ghc-vector" ,ghc-vector)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-uuid" ,ghc-uuid)
- ("ghc-dlist" ,ghc-dlist)
- ("ghc-void" ,ghc-void)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-contravariant-extras" ,ghc-contravariant-extras)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-either" ,ghc-either)
- ("ghc-fail" ,ghc-fail)
- ("ghc-base-prelude" ,ghc-base-prelude)))
- (home-page "https://github.com/nikita-volkov/rebase")
- (synopsis "Progressive alternative to the base package
-for Haskell")
- (description "This Haskell package is intended for those who are
-tired of keeping long lists of dependencies to the same essential libraries
-in each package as well as the endless imports of the same APIs all over again.
-
-It also supports the modern tendencies in the language.
-
-To solve those problems this package does the following:
-
-@itemize
-@item Reexport the original APIs under the @code{Rebase} namespace.
-
-@item Export all the possible non-conflicting symbols from the
-@code{Rebase.Prelude} module.
-
-@item Give priority to the modern practices in the conflicting cases.
-@end itemize
-
-The policy behind the package is only to reexport the non-ambiguous and
-non-controversial APIs, which the community has obviously settled on.
-The package is intended to rapidly evolve with the contribution from
-the community, with the missing features being added with pull-requests.")
- (license license:expat)))
-
-(define-public ghc-rerebase
- (package
- (name "ghc-rerebase")
- (version "1.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/rerebase/rerebase-"
- version ".tar.gz"))
- (sha256
- (base32
- "11v6rmz7ql2rdx6mhb3lsal952lwihclfhh0m7fcnii5br0906ks"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-rebase" ,ghc-rebase)))
- (home-page "https://github.com/nikita-volkov/rerebase")
- (synopsis "Reexports from ``base'' with many other standard libraries")
- (description "A rich drop-in replacement for @code{base}. For details and
-documentation please visit @uref{https://github.com/nikita-volkov/rerebase,
-the project's home page}.")
- (license license:expat)))
-
-(define-public ghc-vector-builder
- (package
- (name "ghc-vector-builder")
- (version "0.3.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "vector-builder-" version "/"
- "vector-builder-" version ".tar.gz"))
- (sha256
- (base32
- "06d2pa1fb3ydrl7l6rjazqyxv5i73v65x2f5fp0ypjxfbm6jsmn8"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-vector" ,ghc-vector)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-base-prelude" ,ghc-base-prelude)))
- (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
- ("ghc-rerebase" ,ghc-rerebase)))
- (home-page "https://github.com/nikita-volkov/vector-builder")
- (synopsis "Vector builder for Haskell")
- (description "This Haskell package provides an API for constructing vectors.
-It provides the composable @code{Builder} abstraction, which has instances of the
-@code{Monoid} and @code{Semigroup} classes.
-
-You would first use the @code{Builder} abstraction to specify the structure of
-the vector; then you can execute the builder to actually produce the
-vector. ")
- (license license:expat)))
-
-(define-public ghc-foldl
- (package
- (name "ghc-foldl")
- (version "1.4.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "foldl-" version "/"
- "foldl-" version ".tar.gz"))
- (sha256
- (base32
- "13n0ca3hw5jzqf6rxsdbhbwkn61a9zlm13f0f205s60j3sc72jzk"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-vector" ,ghc-vector)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-contravariant" ,ghc-contravariant)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-profunctors" ,ghc-profunctors)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-comonad" ,ghc-comonad)
- ("ghc-vector-builder" ,ghc-vector-builder)))
- (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library")
- (synopsis "Composable, streaming, and efficient left folds for Haskell")
- (description "This Haskell library provides strict left folds that stream
-in constant memory, and you can combine folds using @code{Applicative} style
-to derive new folds. Derived folds still traverse the container just once
-and are often as efficient as hand-written folds.")
- (license license:bsd-3)))
-
-(define-public ghc-mono-traversable
- (package
- (name "ghc-mono-traversable")
- (version "1.0.9.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "mono-traversable-" version "/"
- "mono-traversable-" version ".tar.gz"))
- (sha256
- (base32
- "0180ks0dyvpk1r20w5jw2w2n79mjnk69n9vhspaxzlyxqgim5psa"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-vector" ,ghc-vector)
- ("ghc-vector-algorithms" ,ghc-vector-algorithms)
- ("ghc-split" ,ghc-split)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-foldl" ,ghc-foldl)))
- (home-page "https://github.com/snoyberg/mono-traversable")
- (synopsis "Haskell classes for mapping, folding, and traversing monomorphic
-containers")
- (description "This Haskell package provides Monomorphic variants of the
-Functor, Foldable, and Traversable typeclasses. If you understand Haskell's
-basic typeclasses, you understand mono-traversable. In addition to what
-you are used to, it adds on an IsSequence typeclass and has code for marking
-data structures as non-empty.")
- (license license:expat)))
-
-(define-public ghc-conduit-combinators
- (package
- (name "ghc-conduit-combinators")
- (version "1.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "conduit-combinators-" version "/"
- "conduit-combinators-" version ".tar.gz"))
- (sha256
- (base32
- "1lz70vwp4y4lpsivxl0cshq7aq3968rh48r6rjvpyaj2l0bdj5wp"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-vector" ,ghc-vector)
- ("ghc-void" ,ghc-void)
- ("ghc-mwc-random" ,ghc-mwc-random)
- ("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-base16-bytestring" ,ghc-base16-bytestring)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-chunked-data" ,ghc-chunked-data)
- ("ghc-mono-traversable" ,ghc-mono-traversable)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-silently" ,ghc-silently)
- ("ghc-safe" ,ghc-safe)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/snoyberg/mono-traversable")
- (synopsis "Commonly used conduit functions, for both chunked and
-unchunked data")
- (description "This Haskell package provides a replacement for Data.Conduit.List,
-as well as a convenient Conduit module.")
- (license license:expat)))
-
-(define-public ghc-aws
- (package
- (name "ghc-aws")
- (version "0.20")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "aws-" version "/aws-" version ".tar.gz"))
- (sha256 (base32
- "0pwpabmypi1w8rni9qfwabgn95jks4h8dyw6889mn8xzsrhdhyf0"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; Tests require AWS credentials.
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-base16-bytestring" ,ghc-base16-bytestring)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-byteable" ,ghc-byteable)
- ("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-cereal" ,ghc-cereal)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-cryptonite" ,ghc-cryptonite)
- ("ghc-data-default" ,ghc-data-default)
- ("ghc-http-conduit" ,ghc-http-conduit)
- ("ghc-http-types" ,ghc-http-types)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-network" ,ghc-network)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-safe" ,ghc-safe)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-vector" ,ghc-vector)
- ("ghc-xml-conduit" ,ghc-xml-conduit)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-errors" ,ghc-errors)
- ("ghc-http-client" ,ghc-http-client)
- ("ghc-http-client-tls" ,ghc-http-client-tls)
- ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-conduit-combinators" ,ghc-conduit-combinators)))
- (home-page "https://github.com/aristidb/aws")
- (synopsis "Amazon Web Services for Haskell")
- (description "This package attempts to provide support for using
-Amazon Web Services like S3 (storage), SQS (queuing) and others to
-Haskell programmers. The ultimate goal is to support all Amazon
-Web Services.")
- (license license:bsd-3)))
-
-(define-public ghc-basement
- (package
- (name "ghc-basement")
- (version "0.0.8")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "basement/basement-" version ".tar.gz"))
- (sha256
- (base32
- "194jw567di4q2758943q9rrwkbf9gl261my7qc21i9xhyabipx67"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/haskell-foundation/foundation")
- (synopsis "Basic primitives for Foundation starter pack")
- (description
- "This package contains basic primitives for the Foundation set of
-packages.")
- (license license:bsd-3)))
-
-(define-public ghc-foundation
- (package
- (name "ghc-foundation")
- (version "0.0.21")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "foundation/foundation-" version ".tar.gz"))
- (sha256
- (base32
- "1q43y8wfj0wf9gdq2kzphwjwq6m5pvryy1lqgk954aq5z3ks1lsf"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-basement" ,ghc-basement)))
- (home-page "https://github.com/haskell-foundation/foundation")
- (synopsis "Alternative prelude with batteries and no dependencies")
- (description
- "This package provides a custom prelude with no dependencies apart from
-the base package.
-
-Foundation has the following goals:
-
-@enumerate
-@item provide a base like sets of modules that provide a consistent set of
- features and bugfixes across multiple versions of GHC (unlike base).
-@item provide a better and more efficient prelude than base's prelude.
-@item be self-sufficient: no external dependencies apart from base;
-@item provide better data-types: packed unicode string by default, arrays;
-@item Numerical classes that better represent mathematical things (no more
- all-in-one @code{Num});
-@item I/O system with less lazy IO.
-@end enumerate\n")
- (license license:bsd-3)))
-
-(define-public ghc-stm-chans
- (package
- (name "ghc-stm-chans")
- (version "3.0.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "stm-chans-" version "/"
- "stm-chans-" version ".tar.gz"))
- (sha256
- (base32
- "0f27sp09yha43xk9q55sc185jyjs5h7gq2dhsyx6bm9kz9dzqi13"))))
- (build-system haskell-build-system)
- (home-page "https://hackage.haskell.org/package/stm-chans")
- (synopsis "Additional types of channels for ghc-stm")
- (description "This Haskell package offers a collection of channel types,
-similar to @code{Control.Concurrent.STM.@{TChan,TQueue@}} but with additional
-features.")
- (license license:bsd-3)))
-
-(define-public ghc-monad-loops
- (package
- (name "ghc-monad-loops")
- (version "0.4.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "monad-loops-" version "/"
- "monad-loops-" version ".tar.gz"))
- (sha256
- (base32
- "062c2sn3hc8h50p1mhqkpyv6x8dydz2zh3ridvlfjq9nqimszaky"))))
- (build-system haskell-build-system)
- (native-inputs `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "https://github.com/mokus0/monad-loops")
- (synopsis "Monadic loops for Haskell")
- (description "This Haskell package provides some useful control
-operators for looping.")
- (license license:public-domain)))
-
-(define-public ghc-monad-logger
- (package
- (name "ghc-monad-logger")
- (version "0.3.29")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "monad-logger-" version "/"
- "monad-logger-" version ".tar.gz"))
- (sha256
- (base32
- "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-stm-chans" ,ghc-stm-chans)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-fast-logger" ,ghc-fast-logger)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-monad-loops" ,ghc-monad-loops)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-exceptions" ,ghc-exceptions)))
- (home-page "https://github.com/kazu-yamamoto/logger")
- (synopsis "Provides a class of monads which can log messages for Haskell")
- (description "This Haskell package uses a monad transformer approach
-for logging.
-
-This package provides Template Haskell functions for determining source
-code locations of messages.")
- (license license:expat)))
-
-(define-public ghc-shakespeare
- (package
- (name "ghc-shakespeare")
- (version "2.0.15")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "shakespeare-" version "/"
- "shakespeare-" version ".tar.gz"))
- (sha256
- (base32
- "1vk4b19zvwy4mpwaq9z3l3kfmz75gfyf7alhh0y112gspgpccm23"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-aeson" ,ghc-aeson)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-vector" ,ghc-vector)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-scientific" ,ghc-scientific)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit" ,ghc-hunit)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://www.yesodweb.com/book/shakespearean-templates")
- (synopsis "Family of type-safe template languages for Haskell")
- (description "This Haskell package provides a family of type-safe
-templates with simple variable interpolation. Shakespeare templates can
-be used inline with a quasi-quoter or in an external file and it
-interpolates variables according to the type being inserted.")
- (license license:expat)))
-
-(define-public ghc-securemem
- (package
- (name "ghc-securemem")
- (version "0.1.10")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "securemem-" version "/"
- "securemem-" version ".tar.gz"))
- (sha256
- (base32
- "19hnw2cfbsfjynxq1bq9f6djbxhsc1k751ml0y1ab3ah913mm29j"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-byteable" ,ghc-byteable)
- ("ghc-memory" ,ghc-memory)))
- (home-page "https://github.com/vincenthz/hs-securemem")
- (synopsis "Auto-scrubbing and const-time-eq memory chunk abstraction for
-Haskell")
- (description "SecureMem is similar to ByteString, except that it provides
-a memory chunk that will be auto-scrubbed after it run out of scope.")
- (license license:bsd-3)))
-
-(define-public ghc-resource-pool
- (package
- (name "ghc-resource-pool")
- (version "0.2.3.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "resource-pool-" version "/"
- "resource-pool-" version ".tar.gz"))
- (sha256
- (base32
- "04mw8b9djb14zp4rdi6h7mc3zizh597ffiinfbr4m0m8psifw9w6"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-hashable" ,ghc-hashable)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-vector" ,ghc-vector)))
- (home-page "https://github.com/bos/pool")
- (synopsis "Striped resource pooling implementation in Haskell")
- (description "This Haskell package provides striped pooling abstraction
-for managing flexibly-sized collections of resources such as database
-connections.")
- (license license:bsd-3)))
-
-(define-public ghc-attoparsec-iso8601
- (package
- (name "ghc-attoparsec-iso8601")
- (version "1.0.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "attoparsec-iso8601-" version "/"
- "attoparsec-iso8601-" version ".tar.gz"))
- (sha256
- (base32
- "12l55b76bhya9q89mfmqmy6sl5v39b6gzrw5rf3f70vkb23nsv5a"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4")))
- (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-base-compat" ,ghc-base-compat)))
- (home-page "https://github.com/bos/aeson")
- (synopsis "Parse ISO 8601 dates")
- (description "Haskell library for parsing of ISO 8601 dates, originally
-from aeson.")
- (license license:bsd-3)))
-
-(define-public ghc-generics-sop
- (package
- (name "ghc-generics-sop")
- (version "0.3.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "generics-sop-" version "/"
- "generics-sop-" version ".tar.gz"))
- (sha256
- (base32
- "168v62i845jh9jbfaz3ldz8svz4wmzq9mf2vhb7pxlnbkk8fqq1h"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/well-typed/generics-sop")
- (synopsis "Generic Programming using True Sums of Products for Haskell")
- (description "This Haskell package supports the definition of generic
-functions. Datatypes are viewed in a uniform, structured way: the choice
-between constructors is represented using an n-ary sum, and the arguments of
-each constructor are represented using an n-ary product.")
- (license license:bsd-3)))
-
-(define-public ghc-uri-bytestring
- (package
- (name "ghc-uri-bytestring")
- (version "0.3.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "uri-bytestring-" version "/"
- "uri-bytestring-" version ".tar.gz"))
- (sha256
- (base32
- "1q04j5ybvk37zk2m0bkjwyhblz0ymdj0cn4rvsvdca1ikn5xdv5c"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-fail" ,ghc-fail)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-th-lift-instances" ,ghc-th-lift-instances)))
- (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
- ("ghc-base-compat" ,ghc-base-compat)
- ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-generics-sop" ,ghc-generics-sop)))
- (home-page "https://github.com/Soostone/uri-bytestring")
- (synopsis "Haskell URI parsing as ByteStrings")
- (description "This Haskell package aims to be an RFC3986 compliant URI
-parser that uses ByteStrings for parsing and representing the URI data.")
- (license license:bsd-3)))
-
-(define-public ghc-http-api-data
- (package
- (name "ghc-http-api-data")
- (version "0.3.8.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "http-api-data-" version "/"
- "http-api-data-" version ".tar.gz"))
- (sha256
- (base32
- "1cq6459b8wz6nvkvpi89dg189n5q2xdq4rdq435hf150555vmskf"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: Tests require QuickCheck >= 2.9
- (inputs `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-attoparsec-iso8601" ,ghc-attoparsec-iso8601)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-http-types" ,ghc-http-types)
- ("ghc-time-locale-compat" ,ghc-time-locale-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-uri-bytestring" ,ghc-uri-bytestring)
- ("ghc-uuid-types" ,ghc-uuid-types)))
- (home-page "https://github.com/fizruk/http-api-data")
- (synopsis "Convert to/from HTTP API data like URL pieces, headers and
-query parameters")
- (description "This Haskell package defines typeclasses used for converting
-Haskell data types to and from HTTP API data.")
- (license license:bsd-3)))
-
-(define-public ghc-persistent
- (package
- (name "ghc-persistent")
- (version "2.8.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "persistent-" version "/"
- "persistent-" version ".tar.gz"))
- (sha256
- (base32
- "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-old-locale" ,ghc-old-locale)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-resource-pool" ,ghc-resource-pool)
- ("ghc-path-pieces" ,ghc-path-pieces)
- ("ghc-http-api-data" ,ghc-http-api-data)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-silently" ,ghc-silently)
- ("ghc-fast-logger" ,ghc-fast-logger)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-void" ,ghc-void)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)))
- (home-page "https://www.yesodweb.com/book/persistent")
- (synopsis "Type-safe, multi-backend data serialization for Haskell")
- (description "This Haskell package allows Haskell programs to access data
-storage systems like PostgreSQL, SQLite, MySQL and MongoDB in a type-safe
-way.")
- (license license:expat)))
-
-(define-public ghc-aeson-compat
- (package
- (name "ghc-aeson-compat")
- (version "0.3.8")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "aeson-compat-" version "/"
- "aeson-compat-" version ".tar.gz"))
- (sha256
- (base32
- "0j4v13pgk21zy8hqkbx8hw0n05jdl17qphxz9rj4h333pr547r3i"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: Tests require QuickCheck >= 2.10
- (inputs `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-attoparsec" ,ghc-attoparsec-iso8601)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-time-locale-compat" ,ghc-time-locale-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-nats" ,ghc-nats)))
- (home-page "https://github.com/phadej/aeson-compat")
- (synopsis "Compatibility layer for ghc-aeson")
- (description "This Haskell package provides compatibility layer for
-ghc-aeson.")
- (license license:bsd-3)))
-
-(define-public ghc-persistent-template
- (package
- (name "ghc-persistent-template")
- (version "2.5.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "persistent-template-" version "/"
- "persistent-template-" version ".tar.gz"))
- (sha256
- (base32
- "008afcy7zbw7bzp9jww8gdldb51kfm0fg4p0x4xcp61gx4679bjc"))))
- (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)
- ("ghc-aeson-compat" ,ghc-aeson-compat)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-path-pieces" ,ghc-path-pieces)
- ("ghc-http-api-data" ,ghc-http-api-data)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://www.yesodweb.com/book/persistent")
- (synopsis "Type-safe, non-relational, multi-backend persistence")
- (description "This Haskell package provides interfaces and helper
-functions for the ghc-persistent package.")
- (license license:expat)))
-
-(define-public ghc-unliftio-core
- (package
- (name "ghc-unliftio-core")
- (version "0.1.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "unliftio-core-" version "/"
- "unliftio-core-" version ".tar.gz"))
- (sha256
- (base32
- "1193fplsjm1lcr05xwvkj1rsyzx74i755f6kw3ikmxbsv0bv0l3m"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "16bjwcsaghqqmyi69rq65dn3ydifyfaabq3ns37apdm00mwqbcj2")))
- (home-page
- "https://github.com/fpco/unliftio/tree/master/unliftio-core#readme")
- (synopsis "The MonadUnliftIO typeclass for unlifting monads to IO")
- (description "This Haskell package provides the core @code{MonadUnliftIO}
-typeclass, instances for base and transformers, and basic utility
-functions.")
- (license license:expat)))
-
-(define-public ghc-microlens
- (package
- (name "ghc-microlens")
- (version "0.4.9.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "microlens-" version "/"
- "microlens-" version ".tar.gz"))
- (sha256
- (base32
- "0j2nzf0vpx2anvsrg2w0vy2z4jn3kkcs2n6glkzblhn1j9piqh51"))))
- (build-system haskell-build-system)
- (home-page
- "https://github.com/aelve/microlens")
- (synopsis "Provides a tiny lens Haskell library with no dependencies")
- (description "This Haskell package provides a lens library, just like
-@code{ghc-lens}, but smaller. It provides essential lenses and
-traversals (like @code{_1} and @code{_Just}), as well as ones which are simply
-nice to have (like @code{each}, @code{at}, and @code{ix}), and some
-combinators (like @code{failing} and @code{singular}), but everything else is
-stripped. As the result, this package has no dependencies.")
- (license license:bsd-3)))
-
-(define-public ghc-microlens-th
- (package
- (name "ghc-microlens-th")
- (version "0.4.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "microlens-th-" version "/"
- "microlens-th-" version ".tar.gz"))
- (sha256
- (base32
- "02nj7lnl61yffi3c6wn341arxhld5r0vj6nzcb5zmqjhnqsv8c05"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-microlens" ,ghc-microlens)
- ("ghc-th-abstraction" ,ghc-th-abstraction)))
- (home-page
- "https://github.com/aelve/microlens")
- (synopsis "Automatic generation of record lenses for
-@code{ghc-microlens}")
- (description "This Haskell package lets you automatically generate lenses
-for data types; code was extracted from the lens package, and therefore
-generated lenses are fully compatible with ones generated by lens (and can be
-used both from lens and microlens).")
- (license license:bsd-3)))
-
-(define-public ghc-unliftio
- (package
- (name "ghc-unliftio")
- (version "0.2.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/unliftio/unliftio-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0qql93lq5w7qghl454cc3s1i8v1jb4h08n82fqkw0kli4g3g9njs"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH
- (inputs
- `(("ghc-async" ,ghc-async)
- ("ghc-unliftio-core" ,ghc-unliftio-core)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)))
- (home-page "https://github.com/fpco/unliftio")
- (synopsis "Provides MonadUnliftIO typecplass for unlifting monads to
-IO (batteries included)")
- (description "This Haskell package provides the core @code{MonadUnliftIO}
-typeclass, a number of common instances, and a collection of common functions
-working with it.")
- (license license:expat)))
-
-(define-public ghc-persistent-sqlite
- (package
- (name "ghc-persistent-sqlite")
- (version "2.8.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "persistent-sqlite-" version "/"
- "persistent-sqlite-" version ".tar.gz"))
- (sha256
- (base32
- "1chbmvjz46smhgnzhha3bbkhys3fys6dip1jr4v7xp1jf78zbyp6"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-persistent" ,ghc-persistent)
- ("ghc-unliftio-core" ,ghc-unliftio-core)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-microlens-th" ,ghc-microlens-th)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-resource-pool" ,ghc-resource-pool)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-persistent-template" ,ghc-persistent-template)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page
- "https://www.yesodweb.com/book/persistent")
- (synopsis "Backend for the persistent library using sqlite3")
- (description "This Haskell package includes a thin sqlite3 wrapper based
-on the direct-sqlite package, as well as the entire C library, so there are no
-system dependencies.")
- (license license:expat)))
-
-(define-public ghc-email-validate
- (package
- (name "ghc-email-validate")
- (version "2.3.2.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "email-validate/email-validate-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0chgylvc8xmhp933rdbmpg5sv4y7yg2h6kbf0ip1dzmbd5p55pa5"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-doctest" ,ghc-doctest)))
- (home-page
- "https://github.com/Porges/email-validate-hs")
- (synopsis "Email address validator for Haskell")
- (description
- "This Haskell package provides a validator that can validate an email
-address string against RFC 5322.")
- (license license:bsd-3)))
-
-(define-public ghc-bytes
- (package
- (name "ghc-bytes")
- (version "0.15.5")
- (source
- (origin
- (method url-fetch)
- (uri
- (string-append "https://hackage.haskell.org/package/bytes-"
- version "/bytes-"
- version ".tar.gz"))
- (file-name (string-append name "-" version ".tar.gz"))
- (sha256
- (base32
- "063il2vrn0p88r9gzndh4ijs0mxj37khkc9ym9bqdsv7ngk3b683"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-cereal" ,ghc-cereal)
- ("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-void" ,ghc-void)
- ("ghc-vector" ,ghc-vector)))
- (synopsis "Serialization between @code{binary} and @code{cereal}")
- (description "This package provides a simple compatibility shim that lets
-you work with both @code{binary} and @code{cereal} with one chunk of
-serialization code.")
- (home-page "https://hackage.haskell.org/package/bytes")
- (license license:bsd-3)))
-
-(define-public ghc-disk-free-space
- (package
- (name "ghc-disk-free-space")
- (version "0.1.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "disk-free-space/disk-free-space-"
- version ".tar.gz"))
- (sha256
- (base32
- "07rqj8k1vh3cykq9yidpjxhgh1f7vgmjs6y1nv5kq2217ff4yypi"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/redneb/disk-free-space")
- (synopsis "Retrieve information about disk space usage")
- (description "A cross-platform library for retrieving information about
-disk space usage.")
- (license license:bsd-3)))
-
-(define-public ghc-xdg-basedir
- (package
- (name "ghc-xdg-basedir")
- (version "0.2.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/xdg-basedir/"
- "xdg-basedir-" version ".tar.gz"))
- (sha256
- (base32
- "0azlzaxp2dn4l1nr7shsxah2magk1szf6fx0mv75az00qsjw6qg4"))))
- (build-system haskell-build-system)
- (home-page "http://github.com/willdonnelly/xdg-basedir")
- (synopsis "XDG Base Directory library for Haskell")
- (description "This package provides a library implementing the XDG Base Directory spec.")
- (license license:bsd-3)))
-
-(define-public ghc-errorcall-eq-instance
- (package
- (name "ghc-errorcall-eq-instance")
- (version "0.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "errorcall-eq-instance/errorcall-eq-instance-"
- version ".tar.gz"))
- (sha256
- (base32
- "0hqw82m8bbrxy5vgdwb83bhzdx070ibqrm9rshyja7cb808ahijm"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-base-orphans" ,ghc-base-orphans)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "http://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}.
-This package provides an orphan instance.")
- (license license:expat)))
-
-(define-public ghc-missingh
- (package
- (name "ghc-missingh")
- (version "1.4.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/MissingH/"
- "MissingH-" version ".tar.gz"))
- (sha256
- (base32
- "0wcvgrmav480w7nf4bl14yi0jq2yzanysxwzwas9hpb28vyjlgr8"))))
- (build-system haskell-build-system)
- ;; Tests require the unmaintained testpack package, which depends on the
- ;; outdated QuickCheck version 2.7, which can no longer be built with
- ;; recent versions of GHC and Haskell libraries.
- (arguments '(#:tests? #f))
- (inputs
- `(("ghc-network" ,ghc-network)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-regex-compat" ,ghc-regex-compat)
- ("ghc-hslogger" ,ghc-hslogger)
- ("ghc-random" ,ghc-random)
- ("ghc-old-time" ,ghc-old-time)
- ("ghc-old-locale" ,ghc-old-locale)))
- (native-inputs
- `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "http://software.complete.org/missingh")
- (synopsis "Large utility library")
- (description
- "MissingH is a library of all sorts of utility functions for Haskell
-programmers. It is written in pure Haskell and thus should be extremely
-portable and easy to use.")
- (license license:bsd-3)))
-
-(define-public ghc-intervalmap
- (package
- (name "ghc-intervalmap")
- (version "0.6.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/IntervalMap/"
- "IntervalMap-" version ".tar.gz"))
- (sha256
- (base32
- "06hin9wf1by8aqa7820fsi2339bh82184frkwz3jsb9sqa0hszcg"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "http://www.chr-breitkopf.de/comp/IntervalMap")
- (synopsis "Containers for intervals, with efficient search")
- (description
- "This package provides ordered containers of intervals, with efficient
-search for all keys containing a point or overlapping an interval. See the
-example code on the home page for a quick introduction.")
- (license license:bsd-3)))
-
-(define-public ghc-operational
- (package
- (name "ghc-operational")
- (version "0.2.3.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/operational/"
- "operational-" version ".tar.gz"))
- (sha256
- (base32
- "1x2abg2q9d26h1vzj40r6k7k3gqgappbs4g9d853vvg77837km4i"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-random" ,ghc-random)))
- (home-page "http://wiki.haskell.org/Operational")
- (synopsis "Implementation of difficult monads made easy with operational semantics")
- (description
- "This library makes it easy to implement monads with tricky control
-flow. This is useful for: writing web applications in a sequential style,
-programming games with a uniform interface for human and AI players and easy
-replay capababilities, implementing fast parser monads, designing monadic
-DSLs, etc.")
- (license license:bsd-3)))
-
-(define-public ghc-gtk2hs-buildtools
- (package
- (name "ghc-gtk2hs-buildtools")
- (version "0.13.4.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "gtk2hs-buildtools/gtk2hs-buildtools-"
- version ".tar.gz"))
- (sha256
- (base32
- "0yg6xmylgpylmnh5g33qwwn5x9bqckdvvv4czqzd9vrr12lnnghg"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-random" ,ghc-random)
- ("ghc-hashtables" ,ghc-hashtables)))
- (native-inputs
- `(("ghc-alex" ,ghc-alex)
- ("ghc-happy" ,ghc-happy)))
- (home-page "http://projects.haskell.org/gtk2hs/")
- (synopsis "Tools to build the Gtk2Hs suite of user interface libraries")
- (description
- "This package provides a set of helper programs necessary to build the
-Gtk2Hs suite of libraries. These tools include a modified c2hs binding tool
-that is used to generate FFI declarations, a tool to build a type hierarchy
-that mirrors the C type hierarchy of GObjects found in glib, and a generator
-for signal declarations that are used to call back from C to Haskell. These
-tools are not needed to actually run Gtk2Hs programs.")
- (license license:gpl2)))
-
-(define-public ghc-chart
- (package
- (name "ghc-chart")
- (version "1.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/Chart/"
- "Chart-" version ".tar.gz"))
- (sha256
- (base32
- "1f5azj17y8xsb3gjhf7gg1gnnlq12rxkmfjmgcly314d7vghs05z"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-old-locale" ,ghc-old-locale)
- ("ghc-lens" ,ghc-lens)
- ("ghc-colour" ,ghc-colour)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-operational" ,ghc-operational)
- ("ghc-vector" ,ghc-vector)))
- (home-page "https://github.com/timbod7/haskell-chart/wiki")
- (synopsis "Library for generating 2D charts and plots")
- (description
- "This package provides a library for generating 2D charts and plots, with
-backends provided by the @code{Cairo} and @code{Diagrams} libraries.")
- (license license:bsd-3)))
-
-(define-public ghc-wcwidth
- (package
- (name "ghc-wcwidth")
- (version "0.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/wcwidth/wcwidth-"
- version ".tar.gz"))
- (sha256
- (base32
- "1n1fq7v64b59ajf5g50iqj9sa34wm7s2j3viay0kxpmvlcv8gipz"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-setlocale" ,ghc-setlocale)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-attoparsec" ,ghc-attoparsec)))
- (home-page "https://github.com/solidsnack/wcwidth/")
- (synopsis "Haskell bindings to wcwidth")
- (description "This package provides Haskell bindings to your system's
-native wcwidth and a command line tool to examine the widths assigned by it.
-The command line tool can compile a width table to Haskell code that assigns
-widths to the Char type.")
- (license license:bsd-3)))
-
-(define-public ghc-wcwidth-bootstrap
- (package
- (inherit ghc-wcwidth)
- (name "ghc-wcwidth-bootstrap")
- (inputs
- `(("ghc-setlocale" ,ghc-setlocale)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-attoparsec" ,ghc-attoparsec-bootstrap)))
- (properties '(hidden? #t))))
-
-(define-public ghc-rio
- (package
- (name "ghc-rio")
- (version "0.1.5.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/rio/rio-"
- version ".tar.gz"))
- (sha256
- (base32
- "064h8a4hp53a479d3ak0vmqbx8hi0cpg7zn4wp23rjy26dka8p7g"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-exceptions" ,ghc-exceptions)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-microlens" ,ghc-microlens)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-typed-process" ,ghc-typed-process)
- ("ghc-unliftio" ,ghc-unliftio)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/commercialhaskell/rio#readme")
- (synopsis "A standard library for Haskell")
- (description "This package works as a prelude replacement for Haskell,
-providing more functionality and types out of the box than the standard
-prelude (such as common data types like @code{ByteString} and
-@code{Text}), as well as removing common ``gotchas'', like partial
-functions and lazy I/O. The guiding principle here is:
-@itemize
-@item If something is safe to use in general and has no expected naming
-conflicts, expose it.
-@item If something should not always be used, or has naming conflicts,
-expose it from another module in the hierarchy.
-@end itemize")
- (license license:expat)))
-
-(define-public ghc-cairo
- (package
- (name "ghc-cairo")
- (version "0.13.5.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/cairo/"
- "cairo-" version ".tar.gz"))
- (sha256
- (base32
- "1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2"))))
- (build-system haskell-build-system)
- (arguments
- `(#:modules ((guix build haskell-build-system)
- (guix build utils)
- (ice-9 match)
- (srfi srfi-26))
- #:phases
- (modify-phases %standard-phases
- ;; FIXME: This is a copy of the standard configure phase with a tiny
- ;; difference: this package needs the -package-db flag to be passed
- ;; to "runhaskell" in addition to the "configure" action, because it
- ;; depends on gtk2hs-buildtools, which provide setup hooks. Without
- ;; this option the Setup.hs file cannot be evaluated. The
- ;; haskell-build-system should be changed to pass "-package-db" to
- ;; "runhaskell" in any case.
- (replace 'configure
- (lambda* (#:key outputs inputs tests? (configure-flags '())
- #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (name-version (strip-store-file-name out))
- (input-dirs (match inputs
- (((_ . dir) ...)
- dir)
- (_ '())))
- (ghc-path (getenv "GHC_PACKAGE_PATH"))
- (params (append `(,(string-append "--prefix=" out))
- `(,(string-append "--libdir=" out "/lib"))
- `(,(string-append "--bindir=" out "/bin"))
- `(,(string-append
- "--docdir=" out
- "/share/doc/" name-version))
- '("--libsubdir=$compiler/$pkg-$version")
- '("--package-db=../package.conf.d")
- '("--global")
- `(,@(map
- (cut string-append "--extra-include-dirs=" <>)
- (search-path-as-list '("include") input-dirs)))
- `(,@(map
- (cut string-append "--extra-lib-dirs=" <>)
- (search-path-as-list '("lib") input-dirs)))
- (if tests?
- '("--enable-tests")
- '())
- configure-flags)))
- (unsetenv "GHC_PACKAGE_PATH")
- (apply invoke "runhaskell" "-package-db=../package.conf.d"
- "Setup.hs" "configure" params)
- (setenv "GHC_PACKAGE_PATH" ghc-path)
- #t))))))
- (inputs
- `(("ghc-utf8-string" ,ghc-utf8-string)
- ("cairo" ,cairo)))
- (native-inputs
- `(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools)
- ("pkg-config" ,pkg-config)))
- (home-page "http://projects.haskell.org/gtk2hs/")
- (synopsis "Haskell bindings to the Cairo vector graphics library")
- (description
- "Cairo is a library to render high quality vector graphics. There exist
-various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG
-documents, amongst others.")
- (license license:bsd-3)))
-
-(define-public ghc-chart-cairo
- (package
- (name "ghc-chart-cairo")
- (version "1.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/Chart-cairo/"
- "Chart-cairo-" version ".tar.gz"))
- (sha256
- (base32
- "0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-old-locale" ,ghc-old-locale)
- ("ghc-cairo" ,ghc-cairo)
- ("ghc-colour" ,ghc-colour)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-operational" ,ghc-operational)
- ("ghc-lens" ,ghc-lens)
- ("ghc-chart" ,ghc-chart)))
- (home-page "https://github.com/timbod7/haskell-chart/wiki")
- (synopsis "Cairo backend for Charts")
- (description "This package provides a Cairo vector graphics rendering
-backend for the Charts library.")
- (license license:bsd-3)))
-
-(define-public ghc-atomic-write
- (package
- (name "ghc-atomic-write")
- (version "0.2.0.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/atomic-write/atomic-write-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1iaq0hprxcv0sl1sgwcgmm87zraf738va1bciwnx2jkk3k1v9iyv"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-temporary" ,ghc-temporary)
- ("ghc-unix-compat" ,ghc-unix-compat)))
- (native-inputs
- `(("ghc-temporary" ,ghc-temporary)
- ("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/stackbuilders/atomic-write")
- (synopsis "Atomically write to a file")
- (description
- "Atomically write to a file on POSIX-compliant systems while preserving
-permissions. @code{mv} is an atomic operation. This makes it simple to write
-to a file atomically just by using the @code{mv} operation. However, this
-will destroy the permissions on the original file. This library preserves
-permissions while atomically writing to a file.")
- (license license:expat)))
-
-(define-public ghc-cereal-conduit
- (package
- (name "ghc-cereal-conduit")
- (version "0.8.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "cereal-conduit/cereal-conduit-"
- version ".tar.gz"))
- (sha256
- (base32
- "1srr7agvgfw78q5s1npjq5sgynvhjgllpihiv37ylkwqm4c4ap6r"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-conduit" ,ghc-conduit)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-cereal" ,ghc-cereal)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/snoyberg/conduit")
- (synopsis "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits")
- (description
- "This package turn @code{Data.Serialize} @code{Gets} and @code{Puts} into
-@code{Sources}, @code{Sinks}, and @code{Conduits}.")
- (license license:bsd-3)))
-
-(define-public ghc-lzma
- (package
- (name "ghc-lzma")
- (version "0.0.0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/lzma/"
- "lzma-" version ".tar.gz"))
- (sha256
- (base32
- "0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg"))))
- (build-system haskell-build-system)
- (arguments
- '(#:tests? #f ; requires older versions of QuickCheck and tasty.
- #:cabal-revision
- ("3" "1sify6gnsalyp6dakfzi0mdy5jcz2kcp9jsdsgkmxd40nfzgd44m")))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "https://github.com/hvr/lzma")
- (synopsis "LZMA/XZ compression and decompression")
- (description
- "This package provides a pure interface for compressing and
-decompressing LZMA streams of data represented as lazy @code{ByteString}s. A
-monadic incremental interface is provided as well.")
- (license license:bsd-3)))
-
-(define-public ghc-stm-conduit
- (package
- (name "ghc-stm-conduit")
- (version "4.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/stm-conduit/"
- "stm-conduit-" version ".tar.gz"))
- (sha256
- (base32
- "0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-stm-chans" ,ghc-stm-chans)
- ("ghc-cereal" ,ghc-cereal)
- ("ghc-cereal-conduit" ,ghc-cereal-conduit)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-async" ,ghc-async)
- ("ghc-monad-loops" ,ghc-monad-loops)
- ("ghc-unliftio" ,ghc-unliftio)))
- (native-inputs
- `(("ghc-doctest" ,ghc-doctest)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "https://github.com/cgaebel/stm-conduit")
- (synopsis "Introduces conduits to channels and promotes using conduits concurrently")
- (description
- "This package provides two simple conduit wrappers around STM channels: a
-source and a sink.")
- (license license:bsd-3)))
-
-(define-public ghc-bindings-dsl
- (package
- (name "ghc-bindings-dsl")
- (version "1.0.25")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/bindings-DSL/"
- "bindings-DSL-" version ".tar.gz"))
- (sha256
- (base32
- "0kqrd78nspl3lk4a0fqn47d8dirjg3b24dkvkigcrlb81hw35pk3"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/jwiegley/bindings-dsl/wiki")
- (synopsis "FFI domain specific language, on top of hsc2hs")
- (description
- "This is a set of macros to be used when writing Haskell FFI. They were
-designed to be able to fully describe C interfaces, so that @code{hsc2hs} can
-extract from them all Haskell code needed to mimic such interfaces. All
-Haskell names used are automatically derived from C names, structures are
-mapped to Haskell instances of @code{Storable}, and there are also macros you
-can use with C code to help write bindings to inline functions or macro
-functions.")
- (license license:bsd-3)))
-
-(define-public ghc-lzma-conduit
- (package
- (name "ghc-lzma-conduit")
- (version "1.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/lzma-conduit/"
- "lzma-conduit-" version ".tar.gz"))
- (sha256
- (base32
- "0hm72da7xk9l3zxjh274yg444vf405djxqbkf3q3p2qhicmxlmg9"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-conduit" ,ghc-conduit)
- ("ghc-lzma" ,ghc-lzma)
- ("ghc-resourcet" ,ghc-resourcet)))
- (native-inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://github.com/alphaHeavy/lzma-conduit")
- (synopsis "Conduit interface for lzma/xz compression")
- (description
- "This package provides a @code{Conduit} interface for the LZMA
-compression algorithm used in the @code{.xz} file format.")
- (license license:bsd-3)))
-
-(define-public ghc-bzlib-conduit
- (package
- (name "ghc-bzlib-conduit")
- (version "0.3.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/bzlib-conduit/"
- "bzlib-conduit-" version ".tar.gz"))
- (sha256
- (base32
- "0fd2hnr782s7qgipazg2yxwia9qqhkvm9bcm90773c3zkxa13n23"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-bindings-dsl" ,ghc-bindings-dsl)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-resourcet" ,ghc-resourcet)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-random" ,ghc-random)))
- (home-page "https://github.com/snoyberg/bzlib-conduit")
- (synopsis "Streaming compression/decompression via conduits")
- (description
- "This package provides Haskell bindings to bzlib and Conduit support for
-streaming compression and decompression.")
- (license license:bsd-3)))
-
-(define-public ghc-pqueue
- (package
- (name "ghc-pqueue")
- (version "1.4.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "pqueue/pqueue-" version ".tar.gz"))
- (sha256
- (base32
- "1zvwm1zcqqq5n101s1brjhgbay8rf9fviq6gxbplf40i63m57p1x"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "https://hackage.haskell.org/package/pqueue")
- (synopsis "Reliable, persistent, fast priority queues")
- (description
- "This package provides a fast, reliable priority queue implementation
-based on a binomial heap.")
- (license license:bsd-3)))
-
-(define-public ghc-conduit-algorithms
- (package
- (name "ghc-conduit-algorithms")
- (version "0.0.8.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "conduit-algorithms/conduit-algorithms-"
- version ".tar.gz"))
- (sha256
- (base32
- "07gx2q3d1bbfw14q41rmqg0i4m018pci10lswc0k1ij6lw7sb9fd"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)
- ("ghc-bzlib-conduit" ,ghc-bzlib-conduit)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-combinators" ,ghc-conduit-combinators)
- ("ghc-conduit-extra" ,ghc-conduit-extra)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-lzma-conduit" ,ghc-lzma-conduit)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-pqueue" ,ghc-pqueue)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-stm-conduit" ,ghc-stm-conduit)
- ("ghc-streaming-commons" ,ghc-streaming-commons)
- ("ghc-unliftio-core" ,ghc-unliftio-core)
- ("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("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-algorithms#readme")
- (synopsis "Conduit-based algorithms")
- (description
- "This package provides algorithms on @code{Conduits}, including higher
-level asynchronous processing and some other utilities.")
- (license license:expat)))
-
-(define-public ghc-interpolate
- (package
- (name "ghc-interpolate")
- (version "0.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/interpolate/"
- "interpolate-" version ".tar.gz"))
- (sha256
- (base32
- "1gkaj98yz363v38fv78sqby236mp8yqwqcilx7kr2b9z0w3204bf"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
- (native-inputs
- `(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/sol/interpolate")
- (synopsis "String interpolation library")
- (description "This package provides a string interpolation library for
-Haskell.")
- (license license:expat)))
-
-(define-public ghc-hpack
- (package
- (name "ghc-hpack")
- (version "0.28.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/hpack/"
- "hpack-" version ".tar.gz"))
- (sha256
- (base32
- "18w0h76jdp3mk9vin8da9iz3cwhcxmw787xy8wlh8bxcpcr16q5r"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-cryptonite" ,ghc-cryptonite)
- ("ghc-glob" ,ghc-glob)
- ("ghc-http-client" ,ghc-http-client)
- ("ghc-http-client-tls" ,ghc-http-client-tls)
- ("ghc-http-types" ,ghc-http-types)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-yaml" ,ghc-yaml)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-interpolate" ,ghc-interpolate)
- ("ghc-mockery" ,ghc-mockery)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-temporary" ,ghc-temporary)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/sol/hpack")
- (synopsis "Tools for an alternative Haskell package format")
- (description
- "Hpack is a format for Haskell packages. It is an alternative to the
-Cabal package format and follows different design principles. Hpack packages
-are described in a file named @code{package.yaml}. Both @code{cabal2nix} and
-@code{stack} support @code{package.yaml} natively. For other build tools the
-@code{hpack} executable can be used to generate a @code{.cabal} file from
-@code{package.yaml}.")
- (license license:expat)))
-
-(define-public ghc-raw-strings-qq
- (package
- (name "ghc-raw-strings-qq")
- (version "1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "raw-strings-qq/raw-strings-qq-"
- version ".tar.gz"))
- (sha256
- (base32
- "1lxy1wy3awf52968iy5y9r5z4qgnn2sxkdrh7js3m9gadb11w09f"))))
- (build-system haskell-build-system)
- (native-inputs `(("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/23Skidoo/raw-strings-qq")
- (synopsis "Raw string literals for Haskell")
- (description
- "This package provides a quasiquoter for raw string literals, i.e. string
-literals that don't recognise the standard escape sequences. Basically, they
-make your code more readable by freeing you from the responsibility to escape
-backslashes. They are useful when working with regular expressions,
-DOS/Windows paths and markup languages (such as XML).")
- (license license:bsd-3)))
-
-(define-public ghc-inline-c
- (package
- (name "ghc-inline-c")
- (version "0.6.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/inline-c/"
- "inline-c-" version ".tar.gz"))
- (sha256
- (base32
- "0vbfrsqsi7mdziqsnj68bsqlwbqxxhvrmy9rv6w8z18d1m8w3n6h"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
- ("ghc-cryptohash" ,ghc-cryptohash)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-parsers" ,ghc-parsers)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("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")
- (synopsis "Write Haskell source files including C code inline")
- (description
- "inline-c lets you seamlessly call C libraries and embed high-performance
-inline C code in Haskell modules. Haskell and C can be freely intermixed in
-the same source file, and data passed to and from code in either language with
-minimal overhead. No FFI required.")
- (license license:expat)))
-
-(define-public ghc-weigh
- (package
- (name "ghc-weigh")
- (version "0.0.12")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/weigh/"
- "weigh-" version ".tar.gz"))
- (sha256
- (base32
- "0zw2a997gxgdzqmd7j730kxgynzmjvvlkw84dajmfzf1v9pbij7x"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-split" ,ghc-split)
- ("ghc-temporary" ,ghc-temporary)))
- (home-page "https://github.com/fpco/weigh#readme")
- (synopsis "Measure allocations of a Haskell functions/values")
- (description "This package provides tools to measure the memory usage of a
-Haskell value or function.")
- (license license:bsd-3)))
-
-(define-public ghc-linear
- (package
- (name "ghc-linear")
- (version "1.20.8")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/linear/"
- "linear-" version ".tar.gz"))
- (sha256
- (base32
- "046vkvxlb0s286qr55s0c6db0rlwbm1cmlmwhrrkqbkzhfcipgay"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-adjunctions" ,ghc-adjunctions)
- ("ghc-base-orphans" ,ghc-base-orphans)
- ("ghc-bytes" ,ghc-bytes)
- ("ghc-cereal" ,ghc-cereal)
- ("ghc-distributive" ,ghc-distributive)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-lens" ,ghc-lens)
- ("ghc-reflection" ,ghc-reflection)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-void" ,ghc-void)))
- (native-inputs
- `(("cabal-doctest" ,cabal-doctest)
- ("ghc-doctest" ,ghc-doctest)
- ("ghc-simple-reflect" ,ghc-simple-reflect)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "http://github.com/ekmett/linear/")
- (synopsis "Linear algebra library for Haskell")
- (description
- "This package provides types and combinators for linear algebra on free
-vector spaces.")
- (license license:bsd-3)))
-
-(define-public ghc-safe-exceptions
- (package
- (name "ghc-safe-exceptions")
- (version "0.1.7.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "safe-exceptions/safe-exceptions-"
- version ".tar.gz"))
- (sha256
- (base32
- "0sd0zfsm9pcll5bzzj523rbn45adjrnavdkz52hgmdjjgdcdrk8q"))))
- (build-system haskell-build-system)
- (arguments
- '(#:cabal-revision
- ("4" "0fid41gishzsyb47wzxhd5falandfirqcp760hcja81qjpfmqd32")))
- (inputs `(("ghc-exceptions" ,ghc-exceptions)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-void" ,ghc-void)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/fpco/safe-exceptions")
- (synopsis "Safe, consistent, and easy exception handling")
- (description "Runtime exceptions - as exposed in @code{base} by the
-@code{Control.Exception} module - have long been an intimidating part of the
-Haskell ecosystem. This package is intended to overcome this. It provides a
-safe and simple API on top of the existing exception handling machinery. The
-API is equivalent to the underlying implementation in terms of power but
-encourages best practices to minimize the chances of getting the exception
-handling wrong.")
- (license license:expat)))
-
-(define-public ghc-inline-c-cpp
- (package
- (name "ghc-inline-c-cpp")
- (version "0.2.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/inline-c-cpp/"
- "inline-c-cpp-" version ".tar.gz"))
- (sha256
- (base32
- "1rk7fmpkmxw9hhwr8df29kadnf0ybnwj64ggdbnsdrpfyhnkisci"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-inline-c" ,ghc-inline-c)
- ("ghc-safe-exceptions" ,ghc-safe-exceptions)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)))
- (home-page "https://hackage.haskell.org/package/inline-c-cpp")
- (synopsis "Lets you embed C++ code into Haskell")
- (description
- "This package provides utilities to inline C++ code into Haskell using
-@code{inline-c}.")
- (license license:expat)))
-
-(define-public ghc-bytestring-lexing
- (package
- (name "ghc-bytestring-lexing")
- (version "0.5.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "bytestring-lexing/bytestring-lexing-"
- version ".tar.gz"))
- (sha256
- (base32
- "0wrzniawhgpphc6yx1v972gyqxdbv0pizaz9bafahrshyb9svy81"))))
- (build-system haskell-build-system)
- (home-page "http://code.haskell.org/~wren/")
- (synopsis "Parse and produce literals from strict or lazy bytestrings")
- (description
- "This package provides tools to parse and produce literals efficiently
-from strict or lazy bytestrings.")
- (license license:bsd-2)))
-
-(define-public ghc-configurator
- (package
- (name "ghc-configurator")
- (version "0.3.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "configurator/configurator-"
- version ".tar.gz"))
- (sha256
- (base32
- "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-hashable" ,ghc-hashable)
- ("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "http://github.com/bos/configurator")
- (synopsis "Configuration management")
- (description
- "This package provides a configuration management library for programs
-and daemons. The features include:
-
-@enumerate
-@item Automatic, dynamic reloading in response to modifications to
- configuration files.
-@item A simple, but flexible, configuration language, supporting several of
- the most commonly needed types of data, along with interpolation of strings
- from the configuration or the system environment (e.g. @code{$(HOME)}).
-@item Subscription-based notification of changes to configuration properties.
-@item An @code{import} directive allows the configuration of a complex
- application to be split across several smaller files, or common configuration
- data to be shared across several applications.
-@end enumerate\n")
- (license license:bsd-3)))
-
-(define-public ghc-file-embed
- (package
- (name "ghc-file-embed")
- (version "0.0.10.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/file-embed/"
- "file-embed-" version ".tar.gz"))
- (sha256
- (base32
- "0lj164cnzqyd487mli91nnr7137a4h4qsasfwsnsh77sx12fpk9k"))))
- (build-system haskell-build-system)
- (home-page "https://github.com/snoyberg/file-embed")
- (synopsis "Use Template Haskell to embed file contents directly")
- (description
- "This package allows you to use Template Haskell to read a file or all
-the files in a directory, and turn them into @code{(path, bytestring)} pairs
-embedded in your Haskell code.")
- (license license:bsd-3)))
-
-(define-public ghc-safeio
- (package
- (name "ghc-safeio")
- (version "0.0.5.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/safeio/"
- "safeio-" version ".tar.gz"))
- (sha256
- (base32
- "04g3070cbjdqj0h9l9ii6470xcbn40xfv4fr89a8yvnkdim9nyfm"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-conduit" ,ghc-conduit)
- ("ghc-conduit-combinators" ,ghc-conduit-combinators)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-resourcet" ,ghc-resourcet)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("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/safeio")
- (synopsis "Write output to disk atomically")
- (description
- "This package implements utilities to perform atomic output so as to
-avoid the problem of partial intermediate files.")
- (license license:expat)))
-
-(define-public ghc-tldr
- (package
- (name "ghc-tldr")
- (version "0.4.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/tldr/tldr-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0nc581y9jjzwd8l88g48c72mla7k6q1w102akl7gl5jsk9ljamd3"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-cmark" ,ghc-cmark)
- ("ghc-optparse-applicative" ,ghc-optparse-applicative)
- ("ghc-typed-process" ,ghc-typed-process)
- ("ghc-semigroups" ,ghc-semigroups)))
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-golden" ,ghc-tasty-golden)))
- (home-page "https://github.com/psibi/tldr-hs#readme")
- (synopsis "Haskell tldr client")
- (description "This package provides the @command{tldr} command and a
-Haskell client library allowing users to update and view @code{tldr} pages
-from a shell. The @code{tldr} pages are a community effort to simplify the
-man pages with practical examples.")
- (license license:bsd-3)))
-
-(define-public ghc-c2hs
- (package
- (name "ghc-c2hs")
- (version "0.28.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/c2hs/c2hs-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1nplgxfin139x12sb656f5870rpdclrhzi8mq8pry035qld15pci"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-language-c" ,ghc-language-c)
- ("ghc-dlist" ,ghc-dlist)))
- (native-inputs
- `(("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
- ("ghc-hunit" ,ghc-hunit)
- ("ghc-shelly" ,ghc-shelly)
- ("gcc" ,gcc)))
- (arguments
- `(;; XXX: Test failures are induced by a parse error in <bits/floatn.h>
- ;; of glibc 2.28.
- #:tests? #f
-
- #:phases
- (modify-phases %standard-phases
- (add-before 'check 'set-cc
- ;; add a cc executable in the path, needed for some tests to pass
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((gcc (assoc-ref inputs "gcc"))
- (tmpbin (tmpnam))
- (curpath (getenv "PATH")))
- (mkdir-p tmpbin)
- (symlink (which "gcc") (string-append tmpbin "/cc"))
- (setenv "PATH" (string-append tmpbin ":" curpath)))
- #t))
- (add-after 'check 'remove-cc
- ;; clean the tmp dir made in 'set-cc
- (lambda _
- (let* ((cc-path (which "cc"))
- (cc-dir (dirname cc-path)))
- (delete-file-recursively cc-dir)
- #t))))))
- (home-page "https://github.com/haskell/c2hs")
- (synopsis "Create Haskell bindings to C libraries")
- (description "C->Haskell assists in the development of Haskell bindings to
-C libraries. It extracts interface information from C header files and
-generates Haskell code with foreign imports and marshaling. Unlike writing
-foreign imports by hand (or using hsc2hs), this ensures that C functions are
-imported with the correct Haskell types.")
- (license license:gpl2)))
-
-(define-public ghc-libmpd
- (package
- (name "ghc-libmpd")
- (version "0.9.0.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/libmpd/libmpd-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1931m23iqb4wddpdidm4ph746zpaw41kkjzmb074j7yyfpk7x1jv"))))
- (build-system haskell-build-system)
- ;; Tests fail on i686.
- ;; See https://github.com/vimus/libmpd-haskell/issues/112
- (arguments `(#:tests? #f))
- (inputs
- `(("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-network" ,ghc-network)
- ("ghc-utf8-string" ,ghc-utf8-string)))
- (native-inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page "https://github.com/vimus/libmpd-haskell")
- (synopsis "Haskell client library for the Music Player Daemon")
- (description "This package provides a pure Haskell client library for the
-Music Player Daemon.")
- (license license:expat)))
-
-(define-public ghc-alsa-core
- (package
- (name "ghc-alsa-core")
- (version "0.5.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/alsa-core/alsa-core-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1avh4a419h9d2zsslg6j8hm87ppgsgqafz8ll037rk2yy1g4jl7b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
- ("alsa-lib" ,alsa-lib)))
- (native-inputs
- `(("pkg-config" ,pkg-config)))
- (home-page "http://www.haskell.org/haskellwiki/ALSA")
- (synopsis "Binding to the ALSA Library API (Exceptions)")
- (description "This package provides access to ALSA infrastructure, that is
-needed by both alsa-seq and alsa-pcm.")
- (license license:bsd-3)))
-
-(define-public ghc-base-unicode-symbols
- (package
- (name "ghc-base-unicode-symbols")
- (version "0.2.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/base-unicode-symbols/base-unicode-symbols-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1ia6li7qjg1zkak4gf6mnbshw45mq9bfjr0jch58ds0lscmvwyzf"))))
- (build-system haskell-build-system)
- (home-page "http://www.haskell.org/haskellwiki/Unicode-symbols")
- (synopsis "Unicode alternatives for common functions and operators")
- (description "This package defines new symbols for a number of functions,
-operators and types in the base package. All symbols are documented with
-their actual definition and information regarding their Unicode code point.
-They should be completely interchangeable with their definitions. For
-further Unicode goodness you can enable the @code{UnicodeSyntax}
-@url{https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exs.html#unicode-syntax,
-language extension}. This extension enables Unicode characters to be used to
-stand for certain ASCII character sequences, i.e. → instead of @code{->},
-∀ instead of @code{forall} and many others.")
- (license license:bsd-3)))
-
-(define-public ghc-genvalidity
- (package
- (name "ghc-genvalidity")
- (version "0.5.1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/genvalidity/genvalidity-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "17ykq38j9a2lzir6dqz5jgy6ndaafrpkhqhcg96c5ppg7wcxaaj0"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-validity" ,ghc-validity)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)
- ("ghc-hspec-core" ,ghc-hspec-core)))
- (home-page
- "https://github.com/NorfairKing/validity")
- (synopsis
- "Testing utilities for the @code{validity} library")
- (description
- "This package provides testing utilities that are useful in conjunction
-with the @code{Validity} typeclass.")
- (license license:expat)))
-
-(define-public ghc-genvalidity-property
- (package
- (name "ghc-genvalidity-property")
- (version "0.2.1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "genvalidity-property/genvalidity-property-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0cjw5i2pydidda9bnp6x37ylhxdk9g874x5sadr6sscg5kq85a1b"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-genvalidity" ,ghc-genvalidity)
- ("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)
- ("ghc-validity" ,ghc-validity)))
- (native-inputs `(("ghc-doctest" ,ghc-doctest)))
- (home-page
- "https://github.com/NorfairKing/validity")
- (synopsis
- "Standard properties for functions on @code{Validity} types")
- (description
- "This package supplements the @code{Validity} typeclass with standard
-properties for functions operating on them.")
- (license license:expat)))
-
-(define-public ghc-validity
- (package
- (name "ghc-validity")
- (version "0.7.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/validity/validity-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0xribw98amafihw87ddajk6vlirp7w9b26lrnjgq7jfm4710j95f"))))
- (build-system haskell-build-system)
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("hspec-discover" ,hspec-discover)))
- (home-page
- "https://github.com/NorfairKing/validity")
- (synopsis "Validity typeclass")
- (description
- "Values of custom types usually have invariants imposed upon them. This
-package provides the @code{Validity} type class, which makes these invariants
-explicit by providing a function to check whether the invariants hold.")
- (license license:expat)))
-
-(define-public ghc-path
- (package
- (name "ghc-path")
- (version "0.6.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/path/path-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0nayla4k1gb821k8y5b9miflv1bi8f0czf9rqr044nrr2dddi2sb"))))
- (build-system haskell-build-system)
- (arguments
- ;; TODO: There are some Windows-related tests and modules that need to be
- ;; danced around.
- `(#:tests? #f
- #:cabal-revision
- ("1" "05b1zwx2a893h4h5wvgpc5g5pyx71hfmx409rqisd8s1bq1hn463")))
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-hashable" ,ghc-hashable)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-genvalidity" ,ghc-genvalidity)
- ("ghc-genvalidity-property" ,ghc-genvalidity-property)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-validity" ,ghc-validity)))
- (home-page
- "http://hackage.haskell.org/package/path")
- (synopsis "Support for well-typed paths")
- (description "This package introduces a type for paths upholding useful
-invariants.")
- (license license:bsd-3)))
-
-(define-public ghc-path-io
- (package
- (name "ghc-path-io")
- (version "1.3.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/path-io/path-io-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1g9m3qliqjk1img894wsb89diym5zrq51qkkrwhz4sbm9a8hbv1a"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-dlist" ,ghc-dlist)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-path" ,ghc-path)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-temporary" ,ghc-temporary)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)))
- (arguments
- `(#:cabal-revision
- ("3" "1h9hsibbflkxpjl2fqamqiv3x3gasf51apnmklrs9l9x8r32hzcc")))
- (home-page
- "https://github.com/mrkkrp/path-io")
- (synopsis "Functions for manipulating well-typed paths")
- (description "This package provides an interface to the @code{directory}
-package for users of @code{path}. It also implements some missing stuff like
-recursive scanning and copying of directories, working with temporary
-files/directories, and more.")
- (license license:bsd-3)))
-
-(define-public ghc-hindent
- (package
- (name "ghc-hindent")
- (version "5.3.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hindent/hindent-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0wkfik7mvqskk23kyh7ybgnlh3j9j1ym7d3ncahsbli9w654b7xg"))))
- (build-system haskell-build-system)
- (arguments
- `(#:modules ((guix build haskell-build-system)
- (guix build utils)
- (guix build emacs-utils))
- #:imported-modules (,@%haskell-build-system-modules
- (guix build emacs-utils))
- #:phases
- (modify-phases %standard-phases
- (add-after 'install 'emacs-install
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (elisp-file "elisp/hindent.el")
- (dest (string-append out "/share/emacs/site-lisp"
- "/guix.d/hindent-" ,version))
- (emacs (string-append (assoc-ref inputs "emacs")
- "/bin/emacs")))
- (make-file-writable elisp-file)
- (emacs-substitute-variables elisp-file
- ("hindent-process-path"
- (string-append out "/bin/hindent")))
- (install-file elisp-file dest)
- (emacs-generate-autoloads "hindent" dest)))))))
- (inputs
- `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
- ("ghc-monad-loops" ,ghc-monad-loops)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-yaml" ,ghc-yaml)
- ("ghc-unix-compat" ,ghc-unix-compat)
- ("ghc-path" ,ghc-path)
- ("ghc-path-io" ,ghc-path-io)
- ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
- (native-inputs
- `(("ghc-hspec" ,ghc-hspec)
- ("ghc-diff" ,ghc-diff)
- ("emacs" ,emacs-minimal)))
- (home-page
- "https://github.com/commercialhaskell/hindent")
- (synopsis "Extensible Haskell pretty printer")
- (description
- "This package provides automatic formatting for Haskell files. Both a
-library and an executable.")
- (license license:bsd-3)))
-
-(define-public ghc-descriptive
- (package
- (name "ghc-descriptive")
- (version "0.9.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/descriptive/descriptive-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0y5693zm2kvqjilybbmrcv1g6n6x2p6zjgi0k0axjw1sdhh1g237"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-vector" ,ghc-vector)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-hspec" ,ghc-hspec)))
- (home-page
- "https://github.com/chrisdone/descriptive")
- (synopsis
- "Self-describing consumers/parsers: forms, cmd-line args, JSON, etc.")
- (description
- "This package provides datatypes and functions for creating consumers
-and parsers with useful semantics.")
- (license license:bsd-3)))
-
-(define-public ghc-exactprint
- (package
- (name "ghc-exactprint")
- (version "0.5.6.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "ghc-exactprint/ghc-exactprint-" version ".tar.gz"))
- (sha256
- (base32
- "141k6qiys0m0r4br7ikp4i546vs3xcil9cwglzcdfcbnb5nj1z87"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-paths" ,ghc-paths)
- ("ghc-syb" ,ghc-syb)
- ("ghc-free" ,ghc-free)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-diff" ,ghc-diff)
- ("ghc-silently" ,ghc-silently)
- ("ghc-filemanip" ,ghc-filemanip)))
- (home-page
- "http://hackage.haskell.org/package/ghc-exactprint")
- (synopsis "ExactPrint for GHC")
- (description
- "Using the API Annotations available from GHC 7.10.2, this library
-provides a means to round-trip any code that can be compiled by GHC, currently
-excluding @file{.lhs} files.")
- (license license:bsd-3)))
-
-(define-public ghc-microlens-mtl
- (package
- (name "ghc-microlens-mtl")
- (version "0.1.11.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/microlens-mtl/microlens-mtl-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0l6z1gkzwcpv89bxf5vgfrjb6gq2pj7sjjc53nvi5b9alx34zryk"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-microlens" ,ghc-microlens)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
- (home-page "https://github.com/monadfix/microlens")
- (synopsis
- "@code{microlens} support for Reader/Writer/State from mtl")
- (description
- "This package contains functions (like @code{view} or @code{+=}) which
-work on @code{MonadReader}, @code{MonadWriter}, and @code{MonadState} from the
-mtl package. This package is a part of the
-@uref{http://hackage.haskell.org/package/microlens, microlens} family; see the
-readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
- (license license:bsd-3)))
-
-(define-public ghc-microlens-ghc
- (package
- (name "ghc-microlens-ghc")
- (version "0.4.9.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/microlens-ghc/microlens-ghc-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "03iwgg8zww9irv59l70c8yy7vzxir1zf66y12210xk91k5hq6jrj"))))
- (build-system haskell-build-system)
- (inputs `(("ghc-microlens" ,ghc-microlens)))
- (home-page "https://github.com/monadfix/microlens")
- (synopsis "Use @code{microlens} with GHC libraries like @code{array}")
- (description "This library provides everything that @code{microlens}
-provides plus instances to make @code{each}, @code{at}, and @code{ix}
-usable with arrays, @code{ByteString}, and containers. This package is
-a part of the @uref{http://hackage.haskell.org/package/microlens,
-microlens} family; see the readme
-@uref{https://github.com/aelve/microlens#readme, on Github}.")
- (license license:bsd-3)))
-
-(define-public ghc-microlens-platform
- (package
- (name "ghc-microlens-platform")
- (version "0.3.10")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "microlens-platform/microlens-platform-" version ".tar.gz"))
- (sha256
- (base32
- "1d4nhmgf9jq0ixc7qhwm7aaw3xdr0nalw58d0ydsydgf02cyazwv"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-hashable" ,ghc-hashable)
- ("ghc-microlens" ,ghc-microlens)
- ("ghc-microlens-ghc" ,ghc-microlens-ghc)
- ("ghc-microlens-mtl" ,ghc-microlens-mtl)
- ("ghc-microlens-th" ,ghc-microlens-th)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)))
- (home-page "https://github.com/monadfix/microlens")
- (synopsis "Feature-complete microlens")
- (description
- "This package exports a module which is the recommended starting point
-for using @uref{http://hackage.haskell.org/package/microlens, microlens} if
-you aren't trying to keep your dependencies minimal. By importing
-@code{Lens.Micro.Platform} you get all functions and instances from
-@uref{http://hackage.haskell.org/package/microlens, microlens},
-@uref{http://hackage.haskell.org/package/microlens-th, microlens-th},
-@uref{http://hackage.haskell.org/package/microlens-mtl, microlens-mtl},
-@uref{http://hackage.haskell.org/package/microlens-ghc, microlens-ghc}, as
-well as instances for @code{Vector}, @code{Text}, and @code{HashMap}. The
-minor and major versions of @code{microlens-platform} are incremented whenever
-the minor and major versions of any other @code{microlens} package are
-incremented, so you can depend on the exact version of
-@code{microlens-platform} without specifying the version of @code{microlens}
-you need. This package is a part of the
-@uref{http://hackage.haskell.org/package/microlens, microlens} family; see the
-readme @uref{https://github.com/aelve/microlens#readme, on Github}.")
- (license license:bsd-3)))
-
-(define-public ghc-hasktags
- (package
- (name "ghc-hasktags")
- (version "0.71.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hasktags/hasktags-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1s2k9qrgy1jily96img2pmn7g35mwnnfiw6si3aw32jfhg5zsh1c"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-system-filepath" ,ghc-system-filepath)
- ("ghc-optparse-applicative" ,ghc-optparse-applicative)))
- (native-inputs
- `(("ghc-json" ,ghc-json)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-microlens-platform" ,ghc-microlens-platform)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "http://github.com/MarcWeber/hasktags")
- (synopsis "Make @code{Ctags} and @code{Etags} files for Haskell programs")
- (description
- "This package provides a means of generating tag files for Emacs and
-Vim.")
- (license license:bsd-3)))
-
-(define-public ghc-stylish-haskell
- (package
- (name "ghc-stylish-haskell")
- (version "0.9.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/stylish-haskell/stylish-haskell-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-file-embed" ,ghc-file-embed)
- ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-syb" ,ghc-syb)
- ("ghc-yaml" ,ghc-yaml)
- ("ghc-strict" ,ghc-strict)
- ("ghc-optparse-applicative"
- ,ghc-optparse-applicative)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://github.com/jaspervdj/stylish-haskell")
- (synopsis "Haskell code prettifier")
- (description "Stylish-haskell is a Haskell code prettifier. The goal is
-not to format all of the code in a file, to avoid \"getting in the way\".
-However, this tool can e.g. clean up import statements and help doing various
-tasks that get tedious very quickly. It can
-@itemize
-@item
-Align and sort @code{import} statements
-@item
-Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant
-pragmas
-@item
-Remove trailing whitespaces
-@item
-Align branches in @code{case} and fields in records
-@item
-Convert line endings (customisable)
-@item
-Replace tabs by four spaces (turned off by default)
-@item
-Replace some ASCII sequences by their Unicode equivalent (turned off by
-default)
-@end itemize")
- (license license:bsd-3)))
-
-(define-public ghc-validation
- (package
- (name "ghc-validation")
- (version "1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/validation/validation-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "08drmdvyzg2frbb26icy1mlz52xv0l6gi3v8gb7xp0vrcci5libh"))))
- (build-system haskell-build-system)
- (arguments
- `(#:cabal-revision
- ("1" "1x1g4nannz81j1h64l1m3ancc96zc57d1bjhj1wk7bwn1xxbi5h3")))
- (inputs
- `(("ghc-semigroups" ,ghc-semigroups)
- ("ghc-semigroupoids" ,ghc-semigroupoids)
- ("ghc-bifunctors" ,ghc-bifunctors)
- ("ghc-lens" ,ghc-lens)))
- (native-inputs
- `(("ghc-hedgehog" ,ghc-hedgehog)
- ("ghc-hunit" ,ghc-hunit)))
- (home-page "https://github.com/qfpl/validation")
- (synopsis
- "Data-type like Either but with an accumulating Applicative")
- (description
- "A data-type like Either but with differing properties and type-class
-instances.
-
-Library support is provided for this different representation, including
-@code{lens}-related functions for converting between each and abstracting over
-their similarities.
-
-The @code{Validation} data type is isomorphic to @code{Either}, but has an
-instance of @code{Applicative} that accumulates on the error side. That is to
-say, if two (or more) errors are encountered, they are appended using a
-@{Semigroup} operation.
-
-As a consequence of this @code{Applicative} instance, there is no
-corresponding @code{Bind} or @code{Monad} instance. @code{Validation} is an
-example of, \"An applicative functor that is not a monad.\"")
- (license license:bsd-3)))
-
-(define-public ghc-concurrent-output
- (package
- (name "ghc-concurrent-output")
- (version "1.10.9")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/concurrent-output/concurrent-output-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0mwf155w89nbbkjln7hhbn8k3f8p0ylcvgrg31cm7ijpx4499i4c"))))
- (build-system haskell-build-system)
- (inputs
- `(("ghc-async" ,ghc-async)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-terminal-size" ,ghc-terminal-size)))
- (home-page
- "https://hackage.haskell.org/package/concurrent-output")
- (synopsis
- "Ungarble output from several threads or commands")
- (description
- "Lets multiple threads and external processes concurrently output to the
-console, without it getting all garbled up.
-
-Built on top of that is a way of defining multiple output regions, which are
-automatically laid out on the screen and can be individually updated by
-concurrent threads. Can be used for progress displays etc.")
- (license license:bsd-2)))
-
-(define-public ghc-wl-pprint-annotated
- (package
- (name "ghc-wl-pprint-annotated")
- (version "0.1.0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/wl-pprint-annotated/wl-pprint-annotated-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1br7qyf27iza213inwhf9bm2k6in0zbmfw6w4clqlc9f9cj2nrkb"))))
- (build-system haskell-build-system)
- (native-inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page
- "https://github.com/minad/wl-pprint-annotated#readme")
- (synopsis
- "Wadler/Leijen pretty printer with annotation support")
- (description
- "Annotations are useful for coloring. This is a limited version of
-@code{wl-pprint-extras} without support for point effects and without the free
-monad. Like in @code{annotated-wl-pprint}, only annotations are supported.
-Compared to @code{annotated-wl-pprint} this library provides a slightly
-modernized interface.")
- (license license:bsd-3)))
;;; haskell.scm ends here
diff --git a/gnu/packages/idris.scm b/gnu/packages/idris.scm
index 4290d8c21f..894a19f0aa 100644
--- a/gnu/packages/idris.scm
+++ b/gnu/packages/idris.scm
@@ -21,9 +21,9 @@
(define-module (gnu packages idris)
#:use-module (gnu packages)
- #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-web)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages libffi)
#:use-module (gnu packages multiprecision)
#:use-module (gnu packages ncurses)
diff --git a/gnu/packages/statistics.scm b/gnu/packages/statistics.scm
index cdd0caec4a..4e2f6b7937 100644
--- a/gnu/packages/statistics.scm
+++ b/gnu/packages/statistics.scm
@@ -53,7 +53,7 @@
#:use-module (gnu packages gtk)
#:use-module (gnu packages gettext)
#:use-module (gnu packages glib)
- #:use-module (gnu packages haskell)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages icu4c)
#:use-module (gnu packages image)
#:use-module (gnu packages java)
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index a69c460e87..c7d633455e 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -48,9 +48,9 @@
#:use-module (guix build-system meson)
#:use-module (guix build-system perl)
#:use-module (guix build-system python)
- #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-web)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages autotools)
#:use-module (gnu packages bison)
#:use-module (gnu packages gawk)
generated by cgit v1.2.3 (git 2.25.4) at 2024-11-09 01:22:49 +0000