You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

14601 lines
531 KiB

;;; 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 Nikita <nikita@n0.is>
;;; Copyright © 2016, 2019 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>
;;; Copyright © 2019,2020 John Soo <jsoo1@asu.edu>
;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com>
;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
;;; Copyright © 2020 JoJo <jo@jo.zone>
;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr>
;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (gnu packages haskell-xyz)
#:use-module (gnu packages)
#: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 llvm)
#:use-module (gnu packages lua)
#:use-module (gnu packages maths)
#:use-module (gnu packages ncurses)
#:use-module (gnu packages pcre)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages sdl)
#:use-module (gnu packages web)
#:use-module (gnu packages xml)
#:use-module (gnu packages xorg)
#:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix utils)
#: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-active
(package
(name "ghc-active")
(version "0.2.0.14")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"active/active-" version ".tar.gz"))
(sha256
(base32
"0x3b4ln6csa554qls28wbxvclkbdz3yi60i1m0q5ing0cs16fifz"))))
(build-system haskell-build-system)
(inputs
`(("ghc-vector" ,ghc-vector)
("ghc-semigroups" ,ghc-semigroups)
("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-lens" ,ghc-lens)
("ghc-linear" ,ghc-linear)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://hackage.haskell.org/package/active")
(synopsis "Abstractions for animation")
(description "This package defines an @code{Active} abstraction for
time-varying values with finite start and end times. It is used for
describing animations within the
@url{https://archives.haskell.org/projects.haskell.org/diagrams/,
diagrams framework}.")
(license license:bsd-3)))
(define-public ghc-adjunctions
(package
(name "ghc-adjunctions")
(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)
(arguments
`(#:cabal-revision
("2" "1yfsjx7dqikg3hvld7i91xfsg5lawmr5980lvfd794sybmgxsf17")))
(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.9")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"aeson-compat-" version "/"
"aeson-compat-" version ".tar.gz"))
(sha256
(base32
"1j13gykv4ryvmr14w5blz0nnpdb4p0hpa27wahw3mhb1lwdr8hz0"))))
(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-aeson-diff
(package
(name "ghc-aeson-diff")
(version "1.1.0.7")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"aeson-diff/aeson-diff-" version ".tar.gz"))
(sha256
(base32
"01d48pd7d1mb9cd5yxfajln8rmjdjq8ch91s0lav4qw1azv6vp2r"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-edit-distance-vector" ,ghc-edit-distance-vector)
("ghc-hashable" ,ghc-hashable)
("ghc-scientific" ,ghc-scientific)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
("ghc-semigroups" ,ghc-semigroups)
("ghc-optparse-applicative" ,ghc-optparse-applicative)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
("ghc-glob" ,ghc-glob)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-doctest" ,ghc-doctest)
("hlint" ,hlint)))
(home-page "https://github.com/thsutton/aeson-diff")
(synopsis "Extract and apply patches to JSON documents")
(description "This is a small library for working with changes to JSON
documents. It includes a library and two command-line executables in the
style of the @command{diff} and @command{patch} commands available on many
systems.")
(license license:bsd-3)))
(define-public ghc-alex
(package
(name "ghc-alex")
(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 "https://wiki.haskell.org/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-alsa-mixer
(package
(name "ghc-alsa-mixer")
(version "0.3.0")
(source
(origin
(method url-fetch)
(uri
(string-append
"mirror://hackage/package/alsa-mixer/alsa-mixer-"
version ".tar.gz"))
(sha256
(base32
"00ny2p3276jilidjs44npc8zmbhynz3f2lpmlwwl6swwx5yijsnb"))))
(build-system haskell-build-system)
(inputs `(("ghc-alsa-core" ,ghc-alsa-core)))
(native-inputs `(("ghc-c2hs" ,ghc-c2hs)))
(home-page "https://github.com/ttuegel/alsa-mixer")
(synopsis "Bindings to the ALSA simple mixer API")
(description
"This package provides bindings to the ALSA simple mixer API.")
(license license:bsd-3)))
(define-public ghc-annotated-wl-pprint
(package
(name "ghc-annotated-wl-pprint")
(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.9.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
version
".tar.gz"))
(sha256
(base32
"1yr0ld0kqns3w3j9gl62bdwshvyazidx4dv1qkvq19ivnf08w23l"))))
(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.9")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"ansi-wl-pprint/ansi-wl-pprint-"
version ".tar.gz"))
(sha256
(base32
"1b2fg8px98dzbaqyns10kvs8kn6cl1hdq5wb9saz40izrpkyicm7"))))
(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.8")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/appar/appar-"
version
".tar.gz"))
(sha256
(base32
"07v3h766q9mnhphsm53718h1lds147ix7dj15kc5hnsj4vffvkn4"))))
(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-assoc
(package
(name "ghc-assoc")
(version "1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/assoc/assoc-"
version
".tar.gz"))
(sha256
(base32
"1m9n4vp190bvn2wcrd4ggfwa9pi93jp0zgx02mdgywn2zfidw020"))))
(build-system haskell-build-system)
(inputs
`(("ghc-bifunctors" ,ghc-bifunctors)
("ghc-tagged" ,ghc-tagged)))
(home-page
"http://hackage.haskell.org/package/assoc")
(synopsis
"Swap and assoc: Symmetric and Semigroupy Bifunctors")
(description
"Provides generalisations of @code{swap :: (a,b) -> (b,a)} and
@code{assoc :: ((a,b),c) -> (a,(b,c))} to @code{Bifunctor}s supporting
similar operations (e.g. @code{Either}, @code{These}).")
(license license:bsd-3)))
(define-public ghc-async
(package
(name "ghc-async")
(version "2.2.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/async/async-"
version
".tar.gz"))
(sha256
(base32
"1zxvfcyy4sg8lmzphi5dgnavksj5pav6rbvd5kc48lf4hanb2jjb"))))
(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-primops
(package
(name "ghc-atomic-primops")
(version "0.8.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/atomic-primops"
"/atomic-primops-" version ".tar.gz"))
(sha256
(base32
"03n5dmyplrqgbyf8dr91izkxci7gkl3i3fnp82i5ld869zrgjfh0"))))
(build-system haskell-build-system)
(inputs `(("ghc-primitive" ,ghc-primitive)))
(home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
(synopsis "Safe approach to CAS and other atomic ops")
(description
"GHC 7.4 introduced a new @code{casMutVar} PrimOp which is difficult to
use safely, because pointer equality is a highly unstable property in Haskell.
This library provides a safer method based on the concept of @code{Ticket}s.")
(license license:bsd-3)))
(define-public ghc-atomic-write
(package
(name "ghc-atomic-write")
(version "0.2.0.6")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/atomic-write/atomic-write-"
version
".tar.gz"))
(sha256
(base32
"1xs3shwnlj8hmnm3q6jc8nv78z0481i5n4hrqqdmbpx8grvlnqyl"))))
(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-atomic-write-0.2.0.7
(package
(inherit ghc-atomic-write)
(version "0.2.0.7")
(source
(origin
(inherit (package-source ghc-atomic-write))
(uri (string-append
"https://hackage.haskell.org/package/atomic-write/atomic-write-"
version
".tar.gz"))
(sha256
(base32
"03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm"))))))
(define-public ghc-attoparsec
(package
(name "ghc-attoparsec")
(version "0.13.2.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/attoparsec/attoparsec-"
version
".tar.gz"))
(sha256
(base32
"1ngjn9h5n0vyki0m2jir4mg85875ysswy9hznpmj1r856mqwc6ix"))))
(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.1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"attoparsec-iso8601-" version "/"
"attoparsec-iso8601-" version ".tar.gz"))
(sha256
(base32
"0hj10w15qp2z5bz2v4xahhmbgzclpyfi5l2sv97wqycysg9gp7s9"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
("1" "1rjhscmczgs1bwyqx7lvkm8py3ylxjd2797mrzgnq60fvm292750")))
(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.6")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/auto-update/auto-update-"
version
".tar.gz"))
(sha256
(base32
"1i36xc2i34aync8271x3pv515l3zb53i518dybn8ghqkhzf27q7l"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-hunit" ,ghc-hunit)
("ghc-retry" ,ghc-retry)
("hspec-discover" ,hspec-discover)))
(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.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/base-compat/base-compat-"
version
".tar.gz"))
(sha256
(base32
"0hgvlqcr852hfp52jp99snhbj550mvxxpi8qn15d8ml9aqhyl2lr"))))
(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-base-compat-batteries
(package
(name "ghc-base-compat-batteries")
(version "0.10.5")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"base-compat-batteries/base-compat-batteries-"
version ".tar.gz"))
(sha256
(base32
"1vkhc639vqiv5p39jn1v312z32i7yk5q2lf0ap4jxl1v8p8wyp8p"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-compat" ,ghc-base-compat)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)
("hspec-discover" ,hspec-discover)))
(arguments
`(#:cabal-revision
("1" "15sn2qc8k0hxbb2nai341kkrci98hlhzcj2ci087m0zxcg5jcdbp")))
(home-page "https://hackage.haskell.org/package/base-compat-batteries")
(synopsis "base-compat with extra batteries")
(description "This library provides functions available in later
versions of @code{base} to a wider range of compilers, without requiring
you to use CPP pragmas in your code. This package provides the same API
as the @code{base-compat} library, but depends on compatibility
packages (such as @code{semigroups}) to offer a wider support window
than @code{base-compat}, which has no dependencies.")
(license license:expat)))
(define-public ghc-basement
(package
(name "ghc-basement")
(version "0.0.11")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"basement/basement-" version ".tar.gz"))
(sha256
(base32
"0srlws74yiraqaapgcjd9p5d1fwb3zr9swcz74jpjm55fls2nn37"))))
(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.8.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/base-orphans/base-orphans-"
version
".tar.gz"))
(sha256
(base32
"1nwr9av27i9p72k0sn96mw3ywdczw65dy5gd5wxpabhhxlxdcas4"))))
(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 "https://wiki.haskell.org/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-basic-prelude
(package
(name "ghc-basic-prelude")
(version "0.7.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/basic-prelude/"
"basic-prelude-" version ".tar.gz"))
(sha256
(base32
"0yckmnvm6i4vw0mykj4fzl4ldsf67v8d2h0vp1bakyj84n4myx8h"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hashable" ,ghc-hashable)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)))
(home-page "https://github.com/snoyberg/basic-prelude#readme")
(synopsis "Enhanced core prelude; a common foundation for alternate preludes")
(description
"The premise of basic-prelude is that there are a lot of very commonly
desired features missing from the standard Prelude, such as commonly used
operators (<$> and >=>, for instance) and imports for common datatypes
(e.g., ByteString and Vector). At the same time, there are lots of other
components which are more debatable, such as providing polymorphic versions
of common functions.
So basic-prelude is intended to give a common foundation for a number of
alternate preludes. The package provides two modules: CorePrelude provides
the common ground for other preludes to build on top of, while BasicPrelude
exports CorePrelude together with commonly used list functions to provide a
drop-in replacement for the standard Prelude.
Users wishing to have an improved Prelude can use BasicPrelude. Developers
wishing to create a new prelude should use CorePrelude.")
(license license:expat)))
(define-public ghc-bifunctors
(package
(name "ghc-bifunctors")
(version "5.5.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bifunctors/bifunctors-"
version
".tar.gz"))
(sha256
(base32
"0rn47q8dzv0g1fyams99p4py6q0asxdc50q9k0nj497brk738xcb"))))
(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-bitarray
(package
(name "ghc-bitarray")
(version "0.0.1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"bitarray/bitarray-" version ".tar.gz"))
(sha256
(base32
"00nqd62cbh42qqqvcl6iv1i9kbv0f0mkiygv4j70wfh5cl86yzxj"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
("1" "10fk92v9afjqk43zi621jxl0n8kci0xjj32lz3vqa9xbh67zjz45")))
(home-page "https://hackage.haskell.org/package/bitarray")
(synopsis "Mutable and immutable bit arrays")
(description "The package provides mutable and immutable bit arrays.")
(license license:bsd-3)))
(define-public ghc-blaze-builder
(package
(name "ghc-blaze-builder")
(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.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"blaze-markup/blaze-markup-"
version ".tar.gz"))
(sha256
(base32
"1g9m7ansj7fdyzhz1wqkbzn5amjm50vjgjdwkbjc5qqhagnv1y3j"))))
(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.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bytestring-builder"
"/bytestring-builder-" version ".tar.gz"))
(sha256
(base32
"0grcrgwwwcvwrs9az7l4d3kf0lsqfa9qpmjzf6iyanvwn9nyzyi7"))))
(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
`(#:cabal-revision
("1" "0x11aj6w1lijh84jcdq1qgyvdnc7i9ivbyq4wf9rxicg57viisz9")
#: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.14")))))))
(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.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/bzlib-conduit/"
"bzlib-conduit-" version ".tar.gz"))
(sha256
(base32
"0a21zin5plsl37hkxh2jv8cxwyjrbs2fy7n5cyrzgdaa7lmp6b7b"))))
(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-cborg
(package
(name "ghc-cborg")
(version "0.2.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://hackage/package/cborg/cborg-"
version
".tar.gz"))
(sha256
(base32
"1rdnvy0w17s70ikmbyrnwax5rvqh19l95sh8i7ipgxi23z1r0bp1"))))
(build-system haskell-build-system)
(inputs
`(("ghc-half" ,ghc-half)
("ghc-primitive" ,ghc-primitive)))
(native-inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-base64-bytestring" ,ghc-base64-bytestring)
("ghc-base16-bytestring" ,ghc-base16-bytestring)
("ghc-fail" ,ghc-fail)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-scientific" ,ghc-scientific)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-vector" ,ghc-vector)))
(home-page "http://hackage.haskell.org/package/cborg")
(synopsis "Concise Binary Object Representation")
(description
"This package (formerly binary-serialise-cbor) provides an
efficient implementation of the Concise Binary Object
Representation (CBOR), as specified by RFC 7049 at
https://tools.ietf.org/html/rfc7049.
If you are looking for a library for serialisation of Haskell values, have a
look at the @url{https://hackage.haskell.org/package/serialise} package, which
is built upon this library.
An implementation of the standard bijection between CBOR and JSON is provided
by the @url{https://hackage.haskell.org/package/cborg-json} package.
Also see @code{https://hackage.haskell.org/package/cbor-tool} for a convenient
command-line utility for working with CBOR data.")
(license license:bsd-3)))
(define-public ghc-cborg-json
(package
(name "ghc-cborg-json")
(version "0.2.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://hackage/package/cborg-json/cborg-json-"
version
".tar.gz"))
(sha256
(base32 "0ysilz7rrjk94sqr3a61s98hr9qfi1xg13bskmlpc6mpgi2s4s5b"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-aeson-pretty" ,ghc-aeson-pretty)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-scientific" ,ghc-scientific)
("ghc-vector" ,ghc-vector)
("ghc-cborg" ,ghc-cborg)))
(home-page "https://github.com/well-typed/cborg")
(synopsis "A library for encoding JSON as CBOR")
(description
"This package implements the bijection between JSON and CBOR
defined in the CBOR specification, RFC 7049.")
(license license:bsd-3)))
(define-public ghc-cereal
(package
(name "ghc-cereal")
(version "0.5.8.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cereal/cereal-"
version
".tar.gz"))
(sha256
(base32
"1mqvd1iwzr50az4y24332x3g3wsrzw8j1iwph02vr7jbjfn8i7id"))))
(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.4.0.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cgi/cgi-"
version
".tar.gz"))
(sha256
(base32
"1d0nh5ymkqskkp4yn0gfz4mff8i0cxyw1wws8xxp6k1mg1ywa25k"))))
(build-system haskell-build-system)
(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)
(arguments
`(#:cabal-revision
("1" "1z6nxw2g9vgsjq0g159sk8mwj68lwzxzi5iv5ynha0h85jcqxszy")))
(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.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/Chart/"
"Chart-" version ".tar.gz"))
(sha256
(base32
"1pn735k9ifxlb9mdh8xy7wi22cxni8xyr28n8zx9w0j6vprcg89l"))))
(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.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/Chart-cairo/"
"Chart-cairo-" version ".tar.gz"))
(sha256
(base32
"0hknj4rsjf2m8p5pyq5zff8ai7v80yvmxb5c6n0bkgxs4317nbl9"))))
(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.7")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/ChasingBottoms/"
"ChasingBottoms-" version ".tar.gz"))
(sha256
(base32
"0ziiqfsvv1ypdra6kd0bhbsl852i0wqn43jkfii38yl879cdacan"))))
(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.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cheapskate/cheapskate-"
version
".tar.gz"))
(sha256
(base32
"0qnyd8bni2rby6b02ff4bvfdhm1hwc8vzpmnms84jgrlg1lly3fm"))))
(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.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/chell/chell-"
version ".tar.gz"))
(sha256
(base32
"1i845isfbk0yq852am9bqmxfpfkpnlha8nfidffsv4gw2p8gg6fg"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
("1" "1q93wrw03ix4cmnkz3lzkixcvvizw6i2ia2zifdfak1dvxnblxk0")))
(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.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/chell-quickcheck/"
"chell-quickcheck-" version ".tar.gz"))
(sha256
(base32
"0n8c57n88r2bx0bh8nabsz07m42rh23ahs3hgyzf8gr76l08zq03"))))
(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\\.13")
"QuickCheck >= 2.3 && < 2.14")))))))
(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.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/chell-quickcheck/"
"chell-quickcheck-" version ".tar.gz"))
(sha256
(base32
"0n8c57n88r2bx0bh8nabsz07m42rh23ahs3hgyzf8gr76l08zq03"))))
(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\\.13")
"QuickCheck >= 2.3 && < 2.14")))))))
(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.8")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/"
"clock/"
"clock-" version ".tar.gz"))
(sha256
(base32 "0539w9bjw6xbfv9v6aq9hijszxqdnqhilwpbwpql1400ji95r8q8"))))
(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.6")
(source (origin
(method url-fetch)
;; XXX As of version 0.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
"1p41z6z8dqxk62287lvhhg4ayy9laai9ljh4azsnzb029v6mbv0d"))))
(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.2.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"cmark-gfm/cmark-gfm-"
version ".tar.gz"))
(sha256
(base32
"03xflrkyw84qv3yjly5iks9311bqv5cmrmsylr763v4ph0fn7rjq"))))
(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.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/code-page/code-page-"
version ".tar.gz"))
(sha256
(base32
"0i0qbrbhvrwkbikqb7hh7yxaipaavwzvyrw211d0vkz99f62mqxz"))))
(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.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/colour/colour-"
version ".tar.gz"))
(sha256
(base32
"1rq4l46jx4lpdppy71wf7m1n7pw2jwy788rm35ycwzb1g4clg39v"))))
(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://wiki.haskell.org/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.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/comonad/comonad-"
version
".tar.gz"))
(sha256
(base32
"1l7snp2mszgnjgd0nc9kzfyd13vla0rlazqi03rwx2akcxk14n3c"))))
(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")
(version "0.7.0.12")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"concurrent-extra/concurrent-extra-"
version ".tar.gz"))
(sha256
(base32
"1y8xk460fvnw0idzdiylmm874sjny4q9jxb1js9fjz8lw2wns3h4"))))
(build-system haskell-build-system)
(arguments
;; XXX: The ReadWriteLock 'stressTest' fails.
`(#:tests? #f))
(inputs
`(("ghc-unbounded-delays" ,ghc-unbounded-delays)))
(native-inputs
`(("ghc-async" ,ghc-async)
("ghc-hunit" ,ghc-hunit)
("ghc-random" ,ghc-random)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
(home-page "https://github.com/basvandijk/concurrent-extra")
(synopsis "Extra concurrency primitives")
(description "This Haskell library offers (among other things) the
following selection of synchronisation primitives:
@itemize
@item @code{Broadcast}: Wake multiple threads by broadcasting a value.
@item @code{Event}: Wake multiple threads by signalling an event.
@item @code{Lock}: Enforce exclusive access to a resource. Also known
as a binary semaphore or mutex. The package additionally provides an
alternative that works in the STM monad.
@item @code{RLock}: A lock which can be acquired multiple times by the
same thread. Also known as a reentrant mutex.
@item @code{ReadWriteLock}: Multiple-reader, single-writer locks. Used
to protect shared resources which may be concurrently read, but only
sequentially written.
@item @code{ReadWriteVar}: Concurrent read, sequential write variables.
@end itemize
Please consult the API documentation of the individual modules for more
detailed information.
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.11")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://hackage/package/concurrent-output/concurrent-output-"
version
".tar.gz"))
(sha256
(base32
"1d1aaqg5814k59b0iws3fh06p3g2siaj922gkhs75qgncj0my2p3"))))
(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.1.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"conduit/conduit-" version ".tar.gz"))
(sha256
(base32
"18izjgff4pmrknc8py06yvg3g6x27nx0rzmlwjxcflwm5v4szpw4"))))
(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.11.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"conduit-algorithms/conduit-algorithms-"
version ".tar.gz"))
(sha256
(base32
"0c1jwz30kkvimx7lb61782yk0kyfamrf5bqc3g1h7g51lk8bbv9i"))))
(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-conduit-zstd" ,ghc-conduit-zstd)
("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.4")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"conduit-extra/conduit-extra-"
version ".tar.gz"))
(sha256
(base32
"1d853d39vj5pb8yxfcsnjwdzqzkm34ixzbnba8bslpihb7182wxi"))))
(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-conduit-zstd
(package
(name "ghc-conduit-zstd")
(version "0.0.1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"conduit-zstd/conduit-zstd-" version ".tar.gz"))
(sha256
(base32
"04h7w2903hgw4gjcx2pg29yinnmfapawvc19hd3r57rr12fzb0c6"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-zstd" ,ghc-zstd)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-conduit-combinators" ,ghc-conduit-combinators)
("ghc-conduit-extra" ,ghc-conduit-extra)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-th" ,ghc-test-framework-th)))
(home-page "https://github.com/luispedro/conduit-zstd#readme")
(synopsis "Conduit-based ZStd Compression")
(description "Zstandard compression packaged as a conduit. This is
a very thin wrapper around the
@url{https://github.com/facebookexperimental/hs-zstd/, official hs-zstd
interface}.")
(license license:expat)))
(define-public ghc-configurator
(package
(name "ghc-configurator")
(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 "https://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.3.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"connection/connection-"
version ".tar.gz"))
(sha256
(base32
"1nbmafhlg0wy4aa3p7amjddbamdz6avzrxn4py3lvhrjqn4raxax"))))
(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.5.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/contravariant/contravariant-"
version
".tar.gz"))
(sha256
(base32
"0366gl62wwwdbl9i6kqy60asf60876k55v91la6bmhnwwcj2q9n4"))))
(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)
(arguments
`(#:cabal-revision
("1" "1h2955ahga6i4fn7k8v66l03v77p6fhsac6ck8gpabkc08ij60wp")))
(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.8")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://hackage/package/data-accessor/data-accessor-"
version ".tar.gz"))
(sha256
(base32 "1fq4gygxbz0bd0mzgvc1sl3m4gjnsv8nbgpnmdpa29zj5lb9agxc"))))
(build-system haskell-build-system)
(home-page "https://wiki.haskell.org/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://wiki.haskell.org/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-fix
(package
(name "ghc-data-fix")
(version "0.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://hackage/package/data-fix/"
"data-fix-" version ".tar.gz"))
(sha256
(base32 "14hk6hq5hdb3l5bhmzhw086jpzlvp9qbw9dzw30wlz5jbh2ihmvy"))))
(build-system haskell-build-system)
(home-page "https://github.com/spell-music/data-fix")
(synopsis "Fixpoint data types")
(description
"Fixpoint types and recursion schemes. If you define your AST as
fixpoint type, you get fold and unfold operations for free.
Thanks for contribution to: Matej Kollar, Herbert Valerio Riedel")
(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-dbus
(package
(name "ghc-dbus")
(version "1.2.7")
(source
(origin
(method url-fetch)
(uri
(string-append
"mirror://hackage/package/dbus/dbus-"
version ".tar.gz"))
(sha256
(base32
"0ypkjlw9fn65g7p28kb3p82glk7qs7p7vyffccw7qxa3z57s12w5"))))
(build-system haskell-build-system)
(inputs
`(("ghc-cereal" ,ghc-cereal)
("ghc-conduit" ,ghc-conduit)
("ghc-exceptions" ,ghc-exceptions)
("ghc-lens" ,ghc-lens)
("ghc-network" ,ghc-network)
("ghc-random" ,ghc-random)
("ghc-split" ,ghc-split)
("ghc-th-lift" ,ghc-th-lift)
("ghc-vector" ,ghc-vector)
("ghc-xml-conduit" ,ghc-xml-conduit)
("ghc-xml-types" ,ghc-xml-types)))
(native-inputs
`(("ghc-extra" ,ghc-extra)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-resourcet" ,ghc-resourcet)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
;; FIXME - Some tests try to talk to network.
(arguments `(#:tests? #f))
(home-page "https://github.com/rblaze/haskell-dbus")
(synopsis "Client library for the D-Bus IPC system")
(description
"D-Bus is a simple, message-based protocol for inter-process
communication, which allows applications to interact with other parts
of the machine and the user's session using remote procedure
calls. D-Bus is a essential part of the modern Linux desktop, where
it replaces earlier protocols such as CORBA and DCOP. This library
is an implementation of the D-Bus protocol in Haskell. It can be used
to add D-Bus support to Haskell applications, without the awkward
interfaces common to foreign bindings.")
(license license:asl2.0)))
(define-public ghc-deepseq-generics
(package
(name "ghc-deepseq-generics")
(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
("4" "0928s2qnbqsjzrm94x88rvmvbigfmhcyp4m73gw6asinp2qg1kii")))
(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-dense-linear-algebra
(package
(name "ghc-dense-linear-algebra")
(version "0.1.0.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"dense-linear-algebra/dense-linear-algebra-"
version ".tar.gz"))
(sha256