Mirror of GNU Guix
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.
 
 
 
 

10029 lines
368 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 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2016, 2018 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2016, 2017 Nils Gillmann <ng0@n0.is>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2015, 2016, 2017, 2018 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 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Tonton <tonton@riseup.net>
;;; Copyright © 2018 Timothy Sample <samplet@ngyro.com>
;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
;;;
;;; 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)
#:use-module (gnu packages)
#:use-module (gnu packages bootstrap)
#:use-module (gnu packages check)
#:use-module (gnu packages compression)
#:use-module (gnu packages elf)
#:use-module (gnu packages gcc)
#:use-module (gnu packages ghostscript)
#:use-module (gnu packages gl)
#:use-module (gnu packages graphviz)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
#:use-module (gnu packages haskell-web)
#:use-module (gnu packages libffi)
#:use-module (gnu packages linux)
#:use-module (gnu packages lisp)
#:use-module (gnu packages lua)
#:use-module (gnu packages maths)
#:use-module (gnu packages multiprecision)
#:use-module (gnu packages ncurses)
#:use-module (gnu packages pcre)
#:use-module (gnu packages perl)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages python)
#:use-module (gnu packages sdl)
#:use-module (gnu packages tls)
#:use-module (gnu packages xml)
#:use-module (gnu packages xorg)
#:use-module (guix build-system gnu)
#:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (guix utils)
#:use-module (ice-9 regex)
#:use-module ((srfi srfi-1) #:select (alist-delete)))
(define-public cl-yale-haskell
(let ((commit "85f94c72a16c5f70301dd8db04cde9de2d7dd270")
(revision "1"))
(package
(name "cl-yale-haskell")
(version (string-append "2.0.5-" revision "." (string-take commit 9)))
(source (origin
(method git-fetch)
(uri (git-reference
(url "https://git.elephly.net/software/yale-haskell.git")
(commit commit)))
(file-name (string-append "yale-haskell-" commit "-checkout"))
(sha256
(base32
"0bal3m6ryrjamz5p93bhs9rp5msk8k7lpcqr44wd7xs9b9k8w74g"))))
(build-system gnu-build-system)
(arguments
`(#:tests? #f ; no tests
;; Stripping binaries leads to a broken executable lisp system image.
#:strip-binaries? #f
#:make-flags
(list (string-append "PREFIX=" (assoc-ref %outputs "out")))
#:phases
(modify-phases %standard-phases
(replace 'configure
(lambda _
(setenv "PRELUDE" "./progs/prelude")
(setenv "HASKELL_LIBRARY" "./progs/lib")
(setenv "PRELUDEBIN" "./progs/prelude/clisp")
(setenv "HASKELLPROG" "./bin/clisp-haskell")
#t)))))
(inputs
`(("clisp" ,clisp)))
(home-page "https://git.elephly.net/software/yale-haskell.git")
(synopsis "Port of the Yale Haskell system to CLISP")
(description "This package provides the Yale Haskell system running on
top of CLISP.")
(license license:bsd-4))))
(define ghc-bootstrap-x86_64-7.8.4
(origin
(method url-fetch)
(uri
"https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-x86_64-unknown-linux-deb7.tar.xz")
(sha256
(base32
"13azsl53xgj20mi1hj9x0xb32vvcvs6cpmvwx6znxhas7blh0bpn"))))
(define ghc-bootstrap-i686-7.8.4
(origin
(method url-fetch)
(uri
"https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-i386-unknown-linux-deb7.tar.xz")
(sha256
(base32
"0wj5s435j0zgww70bj1d3f6wvnnpzlxwvwcyh2qv4qjq5z8j64kg"))))
;; 43 tests out of 3965 fail.
;;
;; Most of them do not appear to be serious:
;;
;; - some tests generate files referring to "/bin/sh" and "/bin/ls". I've not
;; figured out how these references are generated.
;;
;; - Some tests allocate more memory than expected (ca. 3% above upper limit)
;;
;; - Some tests try to load unavailable libriries: Control.Concurrent.STM,
;; Data.Vector, Control.Monad.State.
;;
;; - Test posix010 tries to check the existence of a user on the system:
;; getUserEntryForName: does not exist (no such user)
(define-public ghc-7
(package
(name "ghc")
(version "7.10.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://www.haskell.org/ghc/dist/"
version "/" name "-" version "-src.tar.xz"))
(sha256
(base32
"1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal"))))
(build-system gnu-build-system)
(supported-systems '("i686-linux" "x86_64-linux"))
(outputs '("out" "doc"))
(inputs
`(("gmp" ,gmp)
("ncurses" ,ncurses)
("libffi" ,libffi)
("ghc-testsuite"
,(origin
(method url-fetch)
(uri (string-append
"https://www.haskell.org/ghc/dist/"
version "/" name "-" version "-testsuite.tar.xz"))
(sha256
(base32
"0qp9da9ar87zbyn6wjgacd2ic1vgzbi3cklxnhsmjqyafv9qaj4b"))))))
(native-inputs
`(("perl" ,perl)
("python" ,python-2) ; for tests (fails with python-3)
("ghostscript" ,ghostscript) ; for tests
("patchelf" ,patchelf)
;; GHC is built with GHC. Therefore we need bootstrap binaries.
("ghc-binary"
,(if (string-match "x86_64" (or (%current-target-system) (%current-system)))
ghc-bootstrap-x86_64-7.8.4
ghc-bootstrap-i686-7.8.4))))
(arguments
`(#:test-target "test"
;; We get a smaller number of test failures by disabling parallel test
;; execution.
#:parallel-tests? #f
;; The DSOs use $ORIGIN to refer to each other, but (guix build
;; gremlin) doesn't support it yet, so skip this phase.
#:validate-runpath? #f
;; Don't pass --build=<triplet>, because the configure script
;; auto-detects slightly different triplets for --host and --target and
;; then complains that they don't match.
#:build #f
#:modules ((guix build gnu-build-system)
(guix build utils)
(guix build rpath)
(srfi srfi-26)
(srfi srfi-1))
#:imported-modules (,@%gnu-build-system-modules
(guix build rpath))
#:configure-flags
(list
(string-append "--with-gmp-libraries="
(assoc-ref %build-inputs "gmp") "/lib")
(string-append "--with-gmp-includes="
(assoc-ref %build-inputs "gmp") "/include")
"--with-system-libffi"
(string-append "--with-ffi-libraries="
(assoc-ref %build-inputs "libffi") "/lib")
(string-append "--with-ffi-includes="
(assoc-ref %build-inputs "libffi") "/include"))
;; FIXME: The user-guide needs dblatex, docbook-xsl and docbook-utils.
;; Currently we do not have the last one.
;; #:make-flags
;; (list "BUILD_DOCBOOK_HTML = YES")
#:phases
(let* ((ghc-bootstrap-path
(string-append (getcwd) "/" ,name "-" ,version "/ghc-bin"))
(ghc-bootstrap-prefix
(string-append ghc-bootstrap-path "/usr" )))
(alist-cons-after
'unpack-bin 'unpack-testsuite-and-fix-bins
(lambda* (#:key inputs outputs #:allow-other-keys)
(with-directory-excursion ".."
(copy-file (assoc-ref inputs "ghc-testsuite")
"ghc-testsuite.tar.xz")
(system* "tar" "xvf" "ghc-testsuite.tar.xz"))
(substitute*
(list "testsuite/timeout/Makefile"
"testsuite/timeout/timeout.py"
"testsuite/timeout/timeout.hs"
"testsuite/tests/rename/prog006/Setup.lhs"
"testsuite/tests/programs/life_space_leak/life.test"
"libraries/process/System/Process/Internals.hs"
"libraries/unix/cbits/execvpe.c")
(("/bin/sh") (which "sh"))
(("/bin/rm") "rm"))
#t)
(alist-cons-after
'unpack 'unpack-bin
(lambda* (#:key inputs outputs #:allow-other-keys)
(mkdir-p ghc-bootstrap-prefix)
(with-directory-excursion ghc-bootstrap-path
(copy-file (assoc-ref inputs "ghc-binary")
"ghc-bin.tar.xz")
(zero? (system* "tar" "xvf" "ghc-bin.tar.xz"))))
(alist-cons-before
'install-bin 'configure-bin
(lambda* (#:key inputs outputs #:allow-other-keys)
(let* ((binaries
(list
"./utils/ghc-pwd/dist-install/build/tmp/ghc-pwd"
"./utils/hpc/dist-install/build/tmp/hpc"
"./utils/haddock/dist/build/tmp/haddock"
"./utils/hsc2hs/dist-install/build/tmp/hsc2hs"
"./utils/runghc/dist-install/build/tmp/runghc"
"./utils/ghc-cabal/dist-install/build/tmp/ghc-cabal"
"./utils/hp2ps/dist/build/tmp/hp2ps"
"./utils/ghc-pkg/dist-install/build/tmp/ghc-pkg"
"./utils/unlit/dist/build/tmp/unlit"
"./ghc/stage2/build/tmp/ghc-stage2"))
(gmp (assoc-ref inputs "gmp"))
(gmp-lib (string-append gmp "/lib"))
(gmp-include (string-append gmp "/include"))
(ncurses-lib
(string-append (assoc-ref inputs "ncurses") "/lib"))
(ld-so (string-append (assoc-ref inputs "libc")
,(glibc-dynamic-linker)))
(libtinfo-dir
(string-append ghc-bootstrap-prefix
"/lib/ghc-7.8.4/terminfo-0.4.0.0")))
(with-directory-excursion
(string-append ghc-bootstrap-path "/ghc-7.8.4")
(setenv "CONFIG_SHELL" (which "bash"))
(setenv "LD_LIBRARY_PATH" gmp-lib)
;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded.
(for-each
(cut system* "patchelf" "--set-interpreter" ld-so <>)
binaries)
;; The binaries include a reference to libtinfo.so.5 which
;; is a subset of libncurses.so.5. We create a symlink in a
;; directory included in the bootstrap binaries rpath.
(mkdir-p libtinfo-dir)
(symlink
(string-append ncurses-lib "/libncursesw.so."
;; Extract "6.0" from "6.0-20170930" if a
;; dash-separated version tag exists.
,(let* ((v (package-version ncurses))
(d (or (string-index v #\-)
(string-length v))))
(version-major+minor (string-take v d))))
(string-append libtinfo-dir "/libtinfo.so.5"))
(setenv "PATH"
(string-append (getenv "PATH") ":"
ghc-bootstrap-prefix "/bin"))
(system*
(string-append (getcwd) "/configure")
(string-append "--prefix=" ghc-bootstrap-prefix)
(string-append "--with-gmp-libraries=" gmp-lib)
(string-append "--with-gmp-includes=" gmp-include)))))
(alist-cons-before
'configure 'install-bin
(lambda* (#:key inputs outputs #:allow-other-keys)
(with-directory-excursion
(string-append ghc-bootstrap-path "/ghc-7.8.4")
(zero? (system* "make" "install"))))
%standard-phases)))))))
(native-search-paths (list (search-path-specification
(variable "GHC_PACKAGE_PATH")
(files (list
(string-append "lib/ghc-" version)))
(file-pattern ".*\\.conf\\.d$")
(file-type 'directory))))
(home-page "https://www.haskell.org/ghc")
(synopsis "The Glasgow Haskell Compiler")
(description
"The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
interactive environment for the functional language Haskell.")
(license license:bsd-3)))
(define-public ghc-8
(package
(name "ghc")
(version "8.0.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://www.haskell.org/ghc/dist/"
version "/" name "-" version "-src.tar.xz"))
(sha256
(base32 "1c8qc4fhkycynk4g1f9hvk53dj6a1vvqi6bklqznns6hw59m8qhi"))
(patches
(search-patches
"ghc-dont-pass-linker-flags-via-response-files.patch"
"ghc-8.0-fall-back-to-madv_dontneed.patch"))))
(build-system gnu-build-system)
(supported-systems '("i686-linux" "x86_64-linux"))
(outputs '("out" "doc"))
(inputs
`(("gmp" ,gmp)
("ncurses" ,ncurses)
("libffi" ,libffi)
("ghc-testsuite"
,(origin
(method url-fetch)
(uri (string-append
"https://www.haskell.org/ghc/dist/"
version "/" name "-" version "-testsuite.tar.xz"))
(sha256
(base32 "1wjc3x68l305bl1h1ijd3yhqp2vqj83lkp3kqbr94qmmkqlms8sj"))))))
(native-inputs
`(("perl" ,perl)
("python" ,python-2) ; for tests
("ghostscript" ,ghostscript) ; for tests
;; GHC is built with GHC.
("ghc-bootstrap" ,ghc-7)))
(arguments
`(#:test-target "test"
;; We get a smaller number of test failures by disabling parallel test
;; execution.
#:parallel-tests? #f
;; The DSOs use $ORIGIN to refer to each other, but (guix build
;; gremlin) doesn't support it yet, so skip this phase.
#:validate-runpath? #f
;; Don't pass --build=<triplet>, because the configure script
;; auto-detects slightly different triplets for --host and --target and
;; then complains that they don't match.
#:build #f
#:configure-flags
(list
(string-append "--with-gmp-libraries="
(assoc-ref %build-inputs "gmp") "/lib")
(string-append "--with-gmp-includes="
(assoc-ref %build-inputs "gmp") "/include")
"--with-system-libffi"
(string-append "--with-ffi-libraries="
(assoc-ref %build-inputs "libffi") "/lib")
(string-append "--with-ffi-includes="
(assoc-ref %build-inputs "libffi") "/include")
(string-append "--with-curses-libraries="
(assoc-ref %build-inputs "ncurses") "/lib")
(string-append "--with-curses-includes="
(assoc-ref %build-inputs "ncurses") "/include"))
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'unpack-testsuite
(lambda* (#:key inputs #:allow-other-keys)
(with-directory-excursion ".."
(copy-file (assoc-ref inputs "ghc-testsuite")
"ghc-testsuite.tar.xz")
(zero? (system* "tar" "xvf" "ghc-testsuite.tar.xz")))))
(add-before 'build 'fix-lib-paths
(lambda _
(substitute*
(list "libraries/process/System/Process/Posix.hs"
"libraries/process/tests/process001.hs"
"libraries/process/tests/process002.hs"
"libraries/unix/cbits/execvpe.c")
(("/bin/sh") (which "sh"))
(("/bin/ls") (which "ls")))
#t))
(add-before 'build 'fix-environment
(lambda _
(unsetenv "GHC_PACKAGE_PATH")
(setenv "CONFIG_SHELL" (which "bash"))
#t))
(add-before 'check 'fix-testsuite
(lambda _
(substitute*
(list "testsuite/timeout/Makefile"
"testsuite/timeout/timeout.py"
"testsuite/timeout/timeout.hs"
"testsuite/tests/programs/life_space_leak/life.test")
(("/bin/sh") (which "sh"))
(("/bin/rm") "rm"))
#t)))))
(native-search-paths (list (search-path-specification
(variable "GHC_PACKAGE_PATH")
(files (list
(string-append "lib/ghc-" version)))
(file-pattern ".*\\.conf\\.d$")
(file-type 'directory))))
(home-page "https://www.haskell.org/ghc")
(synopsis "The Glasgow Haskell Compiler")
(description
"The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
interactive environment for the functional language Haskell.")
(license license:bsd-3)))
(define-public ghc ghc-8)
(define-public ghc-hostname
(package
(name "ghc-hostname")
(version "1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/hostname/"
"hostname-" version ".tar.gz"))
(sha256
(base32
"0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/hostname")
(synopsis "Hostname in Haskell")
(description "Network.HostName is a simple package providing a means to
determine the hostname.")
(license license:bsd-3)))
(define-public ghc-convertible
(package
(name "ghc-convertible")
(version "1.1.1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/convertible/"
"convertible-" version ".tar.gz"))
(sha256
(base32
"0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-time" ,ghc-old-time)
("ghc-old-locale" ,ghc-old-locale)
("ghc-mtl" ,ghc-mtl)
("ghc-text" ,ghc-text)))
(home-page "https://hackage.haskell.org/package/convertible")
(synopsis "Typeclasses and instances for converting between types")
(description
"This package provides a typeclass with a single function that is
designed to help convert between different types: numeric values, dates and
times, and the like. The conversions perform bounds checking and return a
pure @code{Either} value. This means that you need not remember which specific
function performs the conversion you desire.")
(license license:bsd-3)))
(define-public ghc-double-conversion
(package
(name "ghc-double-conversion")
(version "2.0.2.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"double-conversion/double-conversion-"
version ".tar.gz"))
(sha256
(base32
"0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
(build-system haskell-build-system)
(inputs `(("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(home-page "https://github.com/bos/double-conversion")
(synopsis "Fast conversion between double precision floating point and text")
(description
"This package provides a library that performs fast, accurate conversion
between double precision floating point and text.")
(license license:bsd-3)))
(define-public ghc-libxml
(package
(name "ghc-libxml")
(version "0.1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/libxml/"
"libxml-" version ".tar.gz"))
(sha256
(base32
"01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
(build-system haskell-build-system)
(inputs
`(("ghc-mtl" ,ghc-mtl)
("libxml2" ,libxml2)))
(arguments
`(#:configure-flags
`(,(string-append "--extra-include-dirs="
(assoc-ref %build-inputs "libxml2")
"/include/libxml2"))))
(home-page "https://hackage.haskell.org/package/libxml")
(synopsis "Haskell bindings to libxml2")
(description
"This library provides minimal Haskell binding to libxml2.")
(license license:bsd-3)))
(define-public ghc-prelude-extras
(package
(name "ghc-prelude-extras")
(version "0.4.0.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/prelude-extras/prelude-extras-"
version
".tar.gz"))
(sha256
(base32
"0xzqdf3nl2h0ra4gnslm1m1nsxlsgc0hh6ky3vn578vh11zhifq9"))))
(build-system haskell-build-system)
(home-page "https://github.com/ekmett/prelude-extras")
(synopsis "Higher order versions of Prelude classes")
(description "This library provides higher order versions of
@code{Prelude} classes to ease programming with polymorphic recursion and
reduce @code{UndecidableInstances}.")
(license license:bsd-3)))
(define-public ghc-data-default
(package
(name "ghc-data-default")
(version "0.7.1.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-default/data-default-"
version
".tar.gz"))
(sha256
(base32 "04d5n8ybmcxba9qb6h389w9zfq1lvj81b82jh6maqp6pkhkmvydh"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default-class"
,ghc-data-default-class)
("ghc-data-default-instances-base"
,ghc-data-default-instances-base)
("ghc-data-default-instances-containers"
,ghc-data-default-instances-containers)
("ghc-data-default-instances-dlist"
,ghc-data-default-instances-dlist)
("ghc-data-default-instances-old-locale"
,ghc-data-default-instances-old-locale)))
(home-page "https://hackage.haskell.org/package/data-default")
(synopsis "Types with default values")
(description
"This package defines a class for types with a default value, and
provides instances for types from the base, containers, dlist and old-locale
packages.")
(license license:bsd-3)))
(define-public ghc-data-default-class
(package
(name "ghc-data-default-class")
(version "0.1.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-default-class/"
"data-default-class-" version ".tar.gz"))
(sha256
(base32 "0miyjz8d4jyvqf2vp60lyfbnflx6cj2k8apmm9ly1hq0y0iv80ag"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/data-default-class")
(synopsis "Types with default values")
(description
"This package defines a class for types with default values.")
(license license:bsd-3)))
(define-public ghc-data-default-instances-base
(package
(name "ghc-data-default-instances-base")
(version "0.1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/"
"data-default-instances-base/"
"data-default-instances-base-" version ".tar.gz"))
(sha256
(base32 "0ym1sw3ssdzzifxxhh76qlv8kkmb2iclc158incv1dklyr9y8kw4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default-class" ,ghc-data-default-class)))
(home-page "https://hackage.haskell.org/package/data-default-instances-base")
(synopsis "Default instances for types in base")
(description
"This package provides default instances for types from the base
package.")
(license license:bsd-3)))
(define-public ghc-data-default-instances-containers
(package
(name "ghc-data-default-instances-containers")
(version "0.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/"
"data-default-instances-containers/"
"data-default-instances-containers-" version ".tar.gz"))
(sha256
(base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default-class" ,ghc-data-default-class)))
(home-page "https://hackage.haskell.org/package/data-default-instances-containers")
(synopsis "Default instances for types in containers")
(description "Provides default instances for types from the containers
package.")
(license license:bsd-3)))
(define-public ghc-data-default-instances-dlist
(package
(name "ghc-data-default-instances-dlist")
(version "0.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/"
"data-default-instances-dlist/"
"data-default-instances-dlist-" version ".tar.gz"))
(sha256
(base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default-class" ,ghc-data-default-class)
("ghc-dlist" ,ghc-dlist)))
(home-page "https://hackage.haskell.org/package/data-default-instances-dlist")
(synopsis "Default instances for types in dlist")
(description "Provides default instances for types from the dlist
package.")
(license license:bsd-3)))
(define-public ghc-code-page
(package
(name "ghc-code-page")
(version "0.1.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/code-page/code-page-"
version ".tar.gz"))
(sha256
(base32
"1491frk4jx6dlhifky9dvcxbsbcfssrz979a5hp5zn061rh8cp76"))))
(build-system haskell-build-system)
(home-page "https://github.com/RyanGlScott/code-page")
(synopsis "Windows code page library for Haskell")
(description "A cross-platform library with functions for adjusting
code pages on Windows. On all other operating systems, the library does
nothing.")
(license license:bsd-3)))
(define-public ghc-haddock-library
(package
(name "ghc-haddock-library")
(version "1.4.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/haddock-library/haddock-library-"
version
".tar.gz"))
(sha256
(base32
"0ns4bpf6whmcfl0cm2gx2c73if416x4q3ac4l4qm8w84h0zpcr7p"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-compat" ,ghc-base-compat)))
(native-inputs
`(("hspec-discover" ,hspec-discover)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://www.haskell.org/haddock/")
(synopsis "Library exposing some functionality of Haddock")
(description
"Haddock is a documentation-generation tool for Haskell libraries. These
modules expose some functionality of it without pulling in the GHC dependency.
Please note that the API is likely to change so specify upper bounds in your
project if you can't release often. For interacting with Haddock itself, see
the ‘haddock’ package.")
(license license:bsd-3)))
(define-public ghc-haddock-api
(package
(name "ghc-haddock-api")
;; This is the last version to be supported by Cabal < 2.0
(version "2.17.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/haddock-api/haddock-api-"
version
".tar.gz"))
(sha256
(base32
"00fn6pzgg8xjbaw12d76jdqh2dbc5xy7miyz0x6kidvvar7i35ss"))))
(build-system haskell-build-system)
(inputs
`(("ghc-paths" ,ghc-paths)
("ghc-haddock-library" ,ghc-haddock-library)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
(home-page "https://www.haskell.org/haddock/")
(synopsis "API for documentation-generation tool Haddock")
(description "This package provides an API to Haddock, the
documentation-generation tool for Haskell libraries.")
(license license:bsd-3)))
(define-public ghc-haddock-test
(package
(name "ghc-haddock-test")
(version "0.0.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"haddock-test/haddock-test-"
version ".tar.gz"))
(sha256
(base32
"1ax8fnfrwx66csj952f3virxzapipan9da7z5l1zc12nqkifbs7w"))))
(build-system haskell-build-system)
(inputs
`(("ghc-xml" ,ghc-xml)
("ghc-syb" ,ghc-syb)))
(home-page "http://www.haskell.org/haddock/")
(synopsis "Test utilities for Haddock")
(description "This package provides test utilities for Haddock.")
(license license:bsd-3)))
(define-public ghc-haddock
(package
(name "ghc-haddock")
(version "2.17.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/haddock/haddock-"
version
".tar.gz"))
(sha256
(base32
"1z3h3v7w84dzsm47iavdppc2w899mr4c1agq9fzghgz902i0a655"))))
(build-system haskell-build-system)
;; FIXME: Tests fail with this error:
;; driver-test/Main.hs:4:1: error:
;; Failed to load interface for ‘ResponseFileSpec’
(arguments `(#:tests? #f))
(inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-haddock-test" ,ghc-haddock-test)))
(home-page "https://www.haskell.org/haddock/")
(synopsis
"Documentation-generation tool for Haskell libraries")
(description
"Haddock is a documentation-generation tool for Haskell libraries.")
(license license:bsd-3)))
(define-public ghc-simple-reflect
(package
(name "ghc-simple-reflect")
(version "0.3.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/simple-reflect/simple-reflect-"
version
".tar.gz"))
(sha256
(base32
"1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq"))))
(build-system haskell-build-system)
(home-page
"https://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
(synopsis
"Simple reflection of expressions containing variables")
(description
"This package allows simple reflection of expressions containing
variables. Reflection here means that a Haskell expression is turned into a
string. The primary aim of this package is teaching and understanding; there
are no options for manipulating the reflected expressions beyond showing
them.")
(license license:bsd-3)))
(define-public ghc-haskell-src
(package
(name "ghc-haskell-src")
(version "1.0.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/haskell-src/haskell-src-"
version
".tar.gz"))
(sha256
(base32
"19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a"))))
(build-system haskell-build-system)
(inputs
`(("ghc-happy" ,ghc-happy)
("ghc-syb" ,ghc-syb)))
(home-page
"https://hackage.haskell.org/package/haskell-src")
(synopsis
"Support for manipulating Haskell source code")
(description
"The 'haskell-src' package provides support for manipulating Haskell
source code. The package provides a lexer, parser and pretty-printer, and a
definition of a Haskell abstract syntax tree (AST). Common uses of this
package are to parse or generate Haskell 98 code.")
(license license:bsd-3)))
(define-public ghc-alex
(package
(name "ghc-alex")
(version "3.2.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/alex/alex-"
version
".tar.gz"))
(sha256
(base32
"0bi1cs9b8ir33h1fl6x2xw4ymygapqbr713ridpf7rmk2wa7jqqs"))))
(build-system haskell-build-system)
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://www.haskell.org/alex/")
(synopsis
"Tool for generating lexical analysers in Haskell")
(description
"Alex is a tool for generating lexical analysers in Haskell. It takes a
description of tokens based on regular expressions and generates a Haskell
module containing code for scanning text efficiently. It is similar to the
tool lex or flex for C/C++.")
(license license:bsd-3)))
(define-public ghc-cgi
(package
(name "ghc-cgi")
(version "3001.3.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cgi/cgi-"
version
".tar.gz"))
(sha256
(base32
"1hbpplss1m4rdpm4ibip6fpimlhssqa14fl338kl2jbc463i64cj"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags (list "--allow-newer=QuickCheck")))
(inputs
`(("ghc-parsec" ,ghc-parsec)
("ghc-exceptions" ,ghc-exceptions)
("ghc-multipart" ,ghc-multipart)
("ghc-network-uri" ,ghc-network-uri)
("ghc-network" ,ghc-network)
("ghc-mtl" ,ghc-mtl)))
(native-inputs
`(("ghc-doctest" ,ghc-doctest)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/cheecheeo/haskell-cgi")
(synopsis "Library for writing CGI programs")
(description
"This is a Haskell library for writing CGI programs.")
(license license:bsd-3)))
(define-public ghc-cmdargs
(package
(name "ghc-cmdargs")
(version "0.10.18")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cmdargs/cmdargs-"
version ".tar.gz"))
(sha256
(base32
"1lnmcsf6p9yrwwz1zvrw5lbc32xpff7b70yz4ylawaflnlz6wrlh"))))
(build-system haskell-build-system)
(home-page
"http://community.haskell.org/~ndm/cmdargs/")
(synopsis "Command line argument processing")
(description
"This library provides an easy way to define command line parsers.")
(license license:bsd-3)))
(define-public ghc-concatenative
(package
(name "ghc-concatenative")
(version "1.0.1")
(source (origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/concatenative/concatenative-"
version ".tar.gz"))
(sha256
(base32
"05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd"))))
(build-system haskell-build-system)
(home-page
"https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty")
(synopsis "Library for postfix control flow")
(description
"Concatenative gives Haskell Factor-style combinators and arrows for
postfix notation. For more information on stack based languages, see
@uref{https://concatenative.org}.")
(license license:bsd-3)))
(define-public ghc-happy
(package
(name "ghc-happy")
(version "1.19.8")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/happy/happy-"
version
".tar.gz"))
(sha256
(base32
"186ky3bly0i3cc56qk3r7j7pxh2108aackq4n2lli7jmbnb3kxsd"))))
(build-system haskell-build-system)
(inputs
`(("ghc-mtl" ,ghc-mtl)))
(home-page "https://hackage.haskell.org/package/happy")
(synopsis "Parser generator for Haskell")
(description "Happy is a parser generator for Haskell. Given a grammar
specification in BNF, Happy generates Haskell code to parse the grammar.
Happy works in a similar way to the yacc tool for C.")
(license license:bsd-3)))
(define-public ghc-haskell-lexer
(package
(name "ghc-haskell-lexer")
(version "1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/haskell-lexer/haskell-lexer-"
version ".tar.gz"))
(sha256
(base32
"0rj3r1pk88hh3sk3mj61whp8czz5kpxhbc78xlr04bxwqjrjmm6p"))))
(build-system haskell-build-system)
(home-page "http://hackage.haskell.org/package/haskell-lexer")
(synopsis "Fully compliant Haskell 98 lexer")
(description
"This package provides a fully compliant Haskell 98 lexer.")
(license license:bsd-3)))
(define-public ghc-pretty-show
(package
(name "ghc-pretty-show")
(version "1.6.12")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/pretty-show/"
"pretty-show-" version ".tar.gz"))
(sha256
(base32
"1fblcxw4z4ry14brin1mvwccs6hqqlhi7xhwv1f23szjq25cjacn"))))
(build-system haskell-build-system)
(inputs
`(("ghc-haskell-lexer" ,ghc-haskell-lexer)
("ghc-happy" ,ghc-happy)))
(home-page "http://wiki.github.com/yav/pretty-show")
(synopsis "Tools for working with derived `Show` instances")
(description
"This package provides a library and an executable for working with
derived @code{Show} instances. By using the library, derived @code{Show}
instances can be parsed into a generic data structure. The @code{ppsh} tool
uses the library to produce human-readable versions of @code{Show} instances,
which can be quite handy for debugging Haskell programs. We can also render
complex generic values into an interactive Html page, for easier
examination.")
(license license:expat)))
(define-public ghc-pretty-show-for-haskell-src-exts
(package (inherit ghc-pretty-show)
(name "ghc-pretty-show")
(version "1.6.10")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/pretty-show/"
"pretty-show-" version ".tar.gz"))
(sha256
(base32
"133s4l1gk46saf6ycm785rswycy8g3j0qqrv93b5wp8cp50kd0ww"))))))
(define-public ghc-haskell-src-exts
(package
(name "ghc-haskell-src-exts")
(version "1.20.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
version
".tar.gz"))
(sha256
(base32
"1jsjl9hja2dpcfq4mzlfpwyr6axwnwgacfb7aa070kz4lbygzaa8"))))
(build-system haskell-build-system)
(inputs
`(("cpphs" ,cpphs)
("ghc-happy" ,ghc-happy)
("ghc-mtl" ,ghc-mtl)
("ghc-pretty-show" ,ghc-pretty-show-for-haskell-src-exts)))
(native-inputs
`(("ghc-smallcheck" ,ghc-smallcheck)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
("ghc-tasty-golden" ,ghc-tasty-golden)))
(home-page "https://github.com/haskell-suite/haskell-src-exts")
(synopsis "Library for manipulating Haskell source")
(description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
extension of the standard @code{haskell-src} package, and handles most
registered syntactic extensions to Haskell. All extensions implemented in GHC
are supported. Apart from these standard extensions, it also handles regular
patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
(license license:bsd-3)))
(define-public ghc-haskell-src-exts-util
(package
(name "ghc-haskell-src-exts-util")
(version "0.2.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"haskell-src-exts-util/haskell-src-exts-util-"
version ".tar.gz"))
(sha256
(base32
"14rhwcrdz3kfb69c64qn8kybl7wnpajrjlfz5p95ca4bva4mwclg"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default" ,ghc-data-default)
("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
("ghc-semigroups" ,ghc-semigroups)
("ghc-uniplate" ,ghc-uniplate)))
(home-page "https://github.com/pepeiborra/haskell-src-exts-util")
(synopsis "Helper functions for working with haskell-src-exts trees")
(description
"This package provides helper functions for working with
@code{haskell-src-exts} trees.")
(license license:bsd-3)))
(define-public ghc-refact
(package
(name "ghc-refact")
(version "0.3.0.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"refact/refact-"
version ".tar.gz"))
(sha256
(base32
"0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
(build-system haskell-build-system)
(home-page "http://hackage.haskell.org/package/refact")
(synopsis "Specify refactorings to perform with apply-refact")
(description
"This library provides a datatype which can be interpreted by
@code{apply-refact}. It exists as a separate library so that applications can
specify refactorings without depending on GHC.")
(license license:bsd-3)))
(define-public hlint
(package
(name "hlint")
(version "2.1.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/" name
"/" name "-" version ".tar.gz"))
(sha256
(base32
"0mmfavd158l5ig5wb1b1zbhbraj8hhqvbk4mg85n6c8ndpr4grd4"))))
(build-system haskell-build-system)
(inputs
`(("cpphs" ,cpphs)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-yaml" ,ghc-yaml)
("ghc-vector" ,ghc-vector)
("ghc-text" ,ghc-text)
("ghc-data-default" ,ghc-data-default)
("ghc-cmdargs" ,ghc-cmdargs)
("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
("ghc-haskell-src-exts-util" ,ghc-haskell-src-exts-util)
("ghc-uniplate" ,ghc-uniplate)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-extra" ,ghc-extra)
("ghc-refact" ,ghc-refact)
("ghc-aeson" ,ghc-aeson)
("hscolour" ,hscolour)))
(home-page "http://community.haskell.org/~ndm/hlint/")
(synopsis "Suggest improvements for Haskell source code")
(description "HLint reads Haskell programs and suggests changes that
hopefully make them easier to read. HLint also makes it easy to disable
unwanted suggestions, and to add your own custom suggestions.")
(license license:bsd-3)))
(define-public ghc-resourcet
(package
(name "ghc-resourcet")
(version "1.2.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/resourcet/"
"resourcet-" version ".tar.gz"))
(sha256
(base32
"0rzjzh34s36ssign7akqjnwnjxf11c3511wk7ky0xxy0dqmc2rg7"))))
(build-system haskell-build-system)
(inputs
`(("ghc-transformers-base" ,ghc-transformers-base)
("ghc-monad-control" ,ghc-monad-control)
("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-mtl" ,ghc-mtl)
("ghc-mmorph" ,ghc-mmorph)
("ghc-exceptions" ,ghc-exceptions)
("ghc-unliftio-core" ,ghc-unliftio-core)))
(native-inputs
`(("ghc-lifted-base" ,ghc-lifted-base)
("ghc-hspec" ,ghc-hspec)))
(home-page "https://github.com/snoyberg/conduit")
(synopsis "Deterministic allocation and freeing of scarce resources")
(description "ResourceT is a monad transformer which creates a region of
code where you can safely allocate resources.")
(license license:bsd-3)))
(define-public ghc-objectname
(package
(name "ghc-objectname")
(version "1.1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/ObjectName/ObjectName-"
version
".tar.gz"))
(sha256
(base32
"046jm94rmm46cicd31pl54vdvfjvhd9ffbfycy2lxzc0fliyznvj"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/ObjectName")
(synopsis "Helper library for Haskell OpenGL")
(description "This tiny package contains the class ObjectName, which
corresponds to the general notion of explicitly handled identifiers for API
objects, e.g. a texture object name in OpenGL or a buffer object name in
OpenAL.")
(license license:bsd-3)))
(define-public ghc-sdl
(package
(name "ghc-sdl")
(version "0.6.5.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/SDL/SDL-"
version
".tar.gz"))
(sha256
(base32
"1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46"))))
(build-system haskell-build-system)
(inputs
`(("sdl" ,sdl)))
(home-page "https://hackage.haskell.org/package/SDL")
(synopsis "LibSDL for Haskell")
(description "Simple DirectMedia Layer (libSDL) is a cross-platform
multimedia library designed to provide low level access to audio, keyboard,
mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
by MPEG playback software, emulators, and many popular games, including the
award winning Linux port of \"Civilization: Call To Power.\"")
(license license:bsd-3)))
(define-public ghc-sdl-mixer
(package
(name "ghc-sdl-mixer")
(version "0.6.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
version
".tar.gz"))
(sha256
(base32
"1fhray79d80dk2aj9mx3ks05mm48sd832g8zgxli226jx471fs8r"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags
(let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
(sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
(list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
(inputs
`(("ghc-sdl" ,ghc-sdl)
("sdl-mixer" ,sdl-mixer)))
(home-page "https://hackage.haskell.org/package/SDL-mixer")
(synopsis "Haskell bindings to libSDL_mixer")
(description "SDL_mixer is a sample multi-channel audio mixer library. It
supports any number of simultaneously playing channels of 16 bit stereo audio,
plus a single channel of music, mixed by the popular MikMod MOD, Timidity
MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
(license license:bsd-3)))
(define-public ghc-sdl-image
(package
(name "ghc-sdl-image")
(version "0.6.1.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/SDL-image/SDL-image-"
version
".tar.gz"))
(sha256
(base32
"1ybdwlqi5nqzpsbh2md5mxhwmjn910iqysf6nykwjxlmvhcjk281"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags
(let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
(sdl-image-include (string-append sdl-image "/include/SDL")))
(list (string-append "--extra-include-dirs=" sdl-image-include)))))
(inputs
`(("ghc-sdl" ,ghc-sdl)
("sdl-image" ,sdl-image)))
(home-page "https://hackage.haskell.org/package/SDL-image")
(synopsis "Haskell bindings to libSDL_image")
(description "SDL_image is an image file loading library. It loads images
as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
(license license:bsd-3)))
(define-public ghc-half
(package
(name "ghc-half")
(version "0.2.2.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/half/half-"
version ".tar.gz"))
(sha256
(base32
"0p4sb7vv9cljv48wlx65wgdnkryrk5d6yfh7g4yrm20w1p449hl5"))))
(build-system haskell-build-system)
(home-page "https://github.com/ekmett/half")
(synopsis "Half-precision floating-point computations")
(description "This library provides a half-precision floating-point
computation library for Haskell.")
(license license:bsd-3)))
(define-public ghc-fixed
(package
(name "ghc-fixed")
(version "0.2.1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/fixed/fixed-"
version ".tar.gz"))
(sha256
(base32
"1qhmwx8iqshns0crmr9d2f8hm65jxbcp3dvv0c39v34ra7if3a94"))))
(build-system haskell-build-system)
(home-page "https://github.com/ekmett/fixed")
(synopsis "Signed 15.16 precision fixed point arithmetic")
(description
"This package provides functions for signed 15.16 precision fixed point
arithmetic.")
(license license:bsd-3)))
(define-public ghc-openglraw
(package
(name "ghc-openglraw")
(version "3.2.7.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
version
".tar.gz"))
(sha256
(base32
"024aln102d1mmsdalq9jd5mmwjbnrb8gxcak73lybrc7q87kswk2"))))
(build-system haskell-build-system)
(inputs
`(("ghc-half" ,ghc-half)
("ghc-fixed" ,ghc-fixed)
("glu" ,glu)
("ghc-text" ,ghc-text)))
(home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Raw Haskell bindings for the OpenGL graphics system")
(description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
offers access to all necessary functions, tokens and types plus a general
facility for loading extension entries. The module hierarchy closely mirrors
the naming structure of the OpenGL extensions, making it easy to find the
right module to import. All API entries are loaded dynamically, so no special
C header files are needed for building this package. If an API entry is not
found at runtime, a userError is thrown.")
(license license:bsd-3)))
(define-public ghc-glut
(package
(name "ghc-glut")
(version "2.7.0.10")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/GLUT/GLUT-"
version
".tar.gz"))
(sha256
(base32
"0sbm943bg896nf3qjmlnsg3zzrr3pl330rzh9g0hwv47nzwwn4ab"))))
(build-system haskell-build-system)
(inputs
`(("ghc-statevar" ,ghc-statevar)
("ghc-opengl" ,ghc-opengl)
("ghc-openglraw" ,ghc-openglraw)
("freeglut" ,freeglut)))
(home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Haskell bindings for the OpenGL Utility Toolkit")
(description "This library provides Haskell bindings for the OpenGL
Utility Toolkit, a window system-independent toolkit for writing OpenGL
programs.")
(license license:bsd-3)))
(define-public ghc-gluraw
(package
(name "ghc-gluraw")
(version "2.0.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/GLURaw/GLURaw-"
version
".tar.gz"))
(sha256
(base32
"1phmvxr0kkxq89ykmr8rj77inj8dvcxd6h72z1ncdgdazfz3sjw8"))))
(build-system haskell-build-system)
(inputs
`(("ghc-openglraw" ,ghc-openglraw)))
(home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Raw Haskell bindings GLU")
(description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
basis for a nicer interface.")
(license license:bsd-3)))
(define-public ghc-opengl
(package
(name "ghc-opengl")
(version "3.0.1.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/OpenGL/OpenGL-"
version
".tar.gz"))
(sha256
(base32
"1nm2mzrn1h2nnfs9vl5p088hqpll7rdvcsyqsn8q641im9jhqp7l"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-objectname" ,ghc-objectname)
("ghc-gluraw" ,ghc-gluraw)
("ghc-statevar" ,ghc-statevar)
("ghc-openglraw" ,ghc-openglraw)))
(home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Haskell bindings for the OpenGL graphics system")
(description "This package provides Haskell bindings for the OpenGL
graphics system (GL, version 4.5) and its accompanying utility library (GLU,
version 1.3).")
(license license:bsd-3)))
(define-public ghc-streaming-commons
(package
(name "ghc-streaming-commons")
(version "0.2.1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"streaming-commons/streaming-commons-"
version ".tar.gz"))
(sha256
(base32
"13fn6qmpiggwpn8lczyydgp77cyzfypwds7wxskrwir4i5cgxlfq"))))
(build-system haskell-build-system)
(inputs
`(("ghc-async" ,ghc-async)
("ghc-blaze-builder" ,ghc-blaze-builder)
("ghc-network" ,ghc-network)
("ghc-random" ,ghc-random)
("ghc-stm" ,ghc-stm)
("ghc-text" ,ghc-text)
("ghc-zlib" ,ghc-zlib)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
(home-page "https://hackage.haskell.org/package/streaming-commons")
(synopsis "Conduit and pipes needed by some streaming data libraries")
(description "This package provides low-dependency functionality commonly
needed by various Haskell streaming data libraries, such as @code{conduit} and
@code{pipe}s.")
(license license:expat)))
(define-public cpphs
(package
(name "cpphs")
(version "1.20.8")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/" name "/"
name "-" version ".tar.gz"))
(sha256
(base32
"1bh524asqhk9v1s0wvipl0hgn7l63iy3js867yv0z3h5v2kn8vg5"))))
(build-system haskell-build-system)
(inputs
`(("ghc-polyparse" ,ghc-polyparse)
("ghc-old-locale" ,ghc-old-locale)
("ghc-old-time" ,ghc-old-time)))
(home-page "http://projects.haskell.org/cpphs/")
(synopsis "Liberalised re-implementation of cpp, the C pre-processor")
(description "Cpphs is a re-implementation of the C pre-processor that is
both more compatible with Haskell, and itself written in Haskell so that it
can be distributed with compilers. This version of the C pre-processor is
pretty-much feature-complete and compatible with traditional (K&R)
pre-processors. Additional features include: a plain-text mode; an option to
unlit literate code files; and an option to turn off macro-expansion.")
(license (list license:lgpl2.1+ license:gpl3+))))
(define-public ghc-reflection
(package
(name "ghc-reflection")
(version "2.1.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/reflection/reflection-"
version
".tar.gz"))
(sha256
(base32
"0f9w0akbm6p8h7kzgcd2f6nnpw1wy84pqn45vfz1ch5j0hn8h2d9"))))
(build-system haskell-build-system)
(inputs `(("ghc-tagged" ,ghc-tagged)))
(home-page "https://github.com/ekmett/reflection")
(synopsis "Reify arbitrary terms into types that can be reflected back
into terms")
(description "This package addresses the 'configuration problem' which is
propogating configurations that are available at run-time, allowing multiple
configurations to coexist without resorting to mutable global variables or
@code{System.IO.Unsafe.unsafePerformIO}.")
(license license:bsd-3)))
(define-public ghc-old-locale
(package
(name "ghc-old-locale")
(version "1.0.0.7")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/old-locale/old-locale-"
version
".tar.gz"))
(sha256
(base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags (list "--allow-newer=base")))
(home-page "https://hackage.haskell.org/package/old-locale")
(synopsis "Adapt to locale conventions")
(description
"This package provides the ability to adapt to locale conventions such as
date and time formats.")
(license license:bsd-3)))
(define-public ghc-old-time
(package
(name "ghc-old-time")
(version "1.1.0.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/old-time/old-time-"
version
".tar.gz"))
(sha256
(base32
"1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags (list "--allow-newer=base")))
(inputs
`(("ghc-old-locale" ,ghc-old-locale)))
(home-page "https://hackage.haskell.org/package/old-time")
(synopsis "Time compatibility library for Haskell")
(description "Old-time is a package for backwards compatibility with the
old @code{time} library. For new projects, the newer
@uref{https://hackage.haskell.org/package/time, time library} is recommended.")
(license license:bsd-3)))
(define-public ghc-data-default-instances-old-locale
(package
(name "ghc-data-default-instances-old-locale")
(version "0.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/"
"data-default-instances-old-locale/"
"data-default-instances-old-locale-" version ".tar.gz"))
(sha256
(base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default-class" ,ghc-data-default-class)
("ghc-old-locale" ,ghc-old-locale)))
(home-page
"https://hackage.haskell.org/package/data-default-instances-old-locale")
(synopsis "Default instances for types in old-locale")
(description "Provides Default instances for types from the old-locale
package.")
(license license:bsd-3)))
(define-public ghc-dlist
(package
(name "ghc-dlist")
(version "0.8.0.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/dlist/dlist-"
version
".tar.gz"))
(sha256
(base32 "0yirrh0s6acjy9hhvf5fqg2d6q5y6gm9xs04v6w1imndh1xqdwdc"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/spl/dlist")
(synopsis "Difference lists")
(description
"Difference lists are a list-like type supporting O(1) append. This is
particularly useful for efficient logging and pretty printing (e.g. with the
Writer monad), where list append quickly becomes too expensive.")
(license license:bsd-3)))
(define-public ghc-extensible-exceptions
(package
(name "ghc-extensible-exceptions")
(version "0.1.1.4")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"extensible-exceptions/extensible-exceptions-"
version ".tar.gz"))
(sha256
(base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/extensible-exceptions")
(synopsis "Extensible exceptions for Haskell")
(description
"This package provides extensible exceptions for both new and old
versions of GHC (i.e., < 6.10).")
(license license:bsd-3)))
(define-public cabal-install
(package
(name "cabal-install")
(version "1.22.6.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cabal-install/cabal-install-"
version
".tar.gz"))
(sha256
(base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx"))))
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
(build-system haskell-build-system)
(inputs
`(("ghc-http" ,ghc-http)
("ghc-mtl" ,ghc-mtl)
("ghc-network-uri" ,ghc-network-uri)
("ghc-network" ,ghc-network)
("ghc-random" ,ghc-random)
("ghc-stm" ,ghc-stm)
("ghc-zlib" ,ghc-zlib)))
(home-page "https://www.haskell.org/cabal/")
(synopsis "Command-line interface for Cabal and Hackage")
(description
"The cabal command-line program simplifies the process of managing
Haskell software by automating the fetching, configuration, compilation and
installation of Haskell libraries and programs.")
(license license:bsd-3)))
(define-public cabal-doctest
(package
(name "cabal-doctest")
(version "1.0.6")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"cabal-doctest/cabal-doctest-"
version ".tar.gz"))
(sha256
(base32
"0bgd4jdmzxq5y465r4sf4jv2ix73yvblnr4c9wyazazafddamjny"))))
(build-system haskell-build-system)
(home-page "https://github.com/phadej/cabal-doctest")
(synopsis "Setup.hs helper for running doctests")
(description
"To properly work, the @code{doctest} package needs plenty of
configuration. This library provides the common bits for writing custom
@file{Setup.hs} files.")
(license license:bsd-3)))
(define-public ghc-mtl
(package
(name "ghc-mtl")
(version "2.2.1")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/mtl/mtl-"
version
".tar.gz"))
(sha256
(base32
"1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
(build-system haskell-build-system)
;; This is an official revision, relaxing the requirement transformers ==
;; 0.4 to transformers >= 0.4 && < 0.6; see
;; https://hackage.haskell.org/package/mtl-2.2.1/revision/1.cabal
(arguments
`(#:configure-flags (list "--allow-newer=transformers")))
(home-page "https://github.com/ekmett/mtl")
(synopsis
"Monad classes, using functional dependencies")
(description "Monad classes using functional dependencies, with instances
for various monad transformers, inspired by the paper 'Functional Programming
with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced
School of Functional Programming', 1995. See
@uref{https://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
(license license:bsd-3)))
(define-public ghc-parsec-numbers
(package
(name "ghc-parsec-numbers")
(version "0.1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"parsec-numbers/parsec-numbers-" version ".tar.gz"))
(sha256
(base32 "1gzy4v3r02kvdxvgg1nj83mmb6aph2v4ilf9c7y6nbvi2x49l0bp"))))
(build-system haskell-build-system)
(inputs
`(("ghc-parsec" ,ghc-parsec)))
(home-page "https://hackage.haskell.org/package/parsec-numbers")
(synopsis "Utilities for parsing numbers from strings")
(description
"This package provides the number parsers without the need to use a large
(and unportable) token parser.")
(license license:bsd-3)))
(define-public ghc-paths
(package
(name "ghc-paths")
(version "0.1.0.9")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/ghc-paths/ghc-paths-"
version
".tar.gz"))
(sha256
(base32
"0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
(build-system haskell-build-system)
(home-page "https://github.com/simonmar/ghc-paths")
(synopsis
"Knowledge of GHC's installation directories")
(description
"Knowledge of GHC's installation directories.")
(license license:bsd-3)))
(define-public ghc-utf8-string
(package
(name "ghc-utf8-string")
(version "1.0.1.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/utf8-string/utf8-string-"
version
".tar.gz"))
(sha256
(base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags (list "--allow-newer=base")))
(home-page "https://github.com/glguy/utf8-string/")
(synopsis "Support for reading and writing UTF8 Strings")
(description
"A UTF8 layer for Strings. The utf8-string package provides operations
for encoding UTF8 strings to Word8 lists and back, and for reading and writing
UTF8 without truncation.")
(license license:bsd-3)))
(define-public ghc-setenv
(package
(name "ghc-setenv")
(version "0.1.1.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/setenv/setenv-"
version
".tar.gz"))
(sha256
(base32
"0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/setenv")
(synopsis "Library for setting environment variables")
(description "This package provides a Haskell library for setting
environment variables.")
(license license:expat)))
(define-public ghc-setlocale
(package
(name "ghc-setlocale")
(version "1.0.0.6")
(source (origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/setlocale-"
version "/setlocale-" version ".tar.gz"))
(sha256
(base32
"1rl8qb8vzv8fdbczy2dxwgn4cb68lfrjdxf2w8nn9wy1acqzcyjq"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/setlocale")
(synopsis "Haskell bindings to setlocale")
(description "This package provides Haskell bindings to the
@code{setlocale} C function.")
(license license:bsd-3)))
(define-public ghc-x11
(package
(name "ghc-x11")
(version "1.8")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/X11/"
"X11-" version ".tar.gz"))
(sha256
(base32 "13lxq36856fzp61y4api78vssykyh8fm2aplr0nsj18ymdm1c6sl"))))
(build-system haskell-build-system)
(inputs
`(("libx11" ,libx11)
("libxrandr" ,libxrandr)
("libxinerama" ,libxinerama)
("libxscrnsaver" ,libxscrnsaver)
("ghc-data-default" ,ghc-data-default)))
(home-page "https://github.com/haskell-pkg-janitors/X11")
(synopsis "Bindings to the X11 graphics library")
(description
"This package provides Haskell bindings to the X11 graphics library. The
bindings are a direct translation of the C bindings.")
(license license:bsd-3)))
(define-public ghc-x11-xft
(package
(name "ghc-x11-xft")
(version "0.3.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/X11-xft/"
"X11-xft-" version ".tar.gz"))
(sha256
(base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
(inputs
`(("ghc-x11" ,ghc-x11)
("ghc-utf8-string" ,ghc-utf8-string)
("libx11" ,libx11)
("libxft" ,libxft)
("xorgproto" ,xorgproto)))
(native-inputs
`(("pkg-config" ,pkg-config)))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/X11-xft")
(synopsis "Bindings to Xft")
(description
"Bindings to the Xft, X Free Type interface library, and some Xrender
parts.")
(license license:lgpl2.1)))
(define-public ghc-stringbuilder
(package
(name "ghc-stringbuilder")
(version "0.5.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/stringbuilder/stringbuilder-"
version
".tar.gz"))
(sha256
(base32
"1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
; enabled
(home-page "https://hackage.haskell.org/package/stringbuilder")
(synopsis "Writer monad for multi-line string literals")
(description "This package provides a writer monad for multi-line string
literals.")
(license license:expat)))
(define-public ghc-zlib
(package
(name "ghc-zlib")
(version "0.6.2")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/zlib/zlib-"
version
".tar.gz"))
(sha256
(base32
"1vbzf0awb6zb456xf48za1kl22018646cfzq4frvxgb9ay97vk0d"))))
(build-system haskell-build-system)
;; Tests require older versions of testy.
(arguments `(#:tests? #f))
(inputs `(("zlib" ,zlib)))
(home-page "https://hackage.haskell.org/package/zlib")
(synopsis
"Compression and decompression in the gzip and zlib formats")
(description
"This package provides a pure interface for compressing and decompressing
streams of data represented as lazy 'ByteString's. It uses the zlib C library
so it has high performance. It supports the 'zlib', 'gzip' and 'raw'
compression formats. It provides a convenient high level API suitable for
most tasks and for the few cases where more control is needed it provides
access to the full zlib feature set.")
(license license:bsd-3)))
(define-public ghc-stm
(package
(name "ghc-stm")
(version "2.4.5.0")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/stm/stm-"
version
".tar.gz"))
(sha256
(base32
"19sr11a0hqikhvf561b38phz6k3zg9s157a0f5ffvghk7wcdpmri"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/stm")
(synopsis "Software Transactional Memory")
(description
"Software Transactional Memory, or STM, is an abstraction for concurrent
communication. The main benefits of STM are composability and modularity.
That is, using STM you can write concurrent abstractions that can be easily
composed with any other abstraction built using STM, without exposing the
details of how your abstraction ensures safety. This is typically not the
case with other forms of concurrent communication, such as locks or
@code{MVar}s.")
(license license:bsd-3)))
(define-public ghc-parallel
(package
(name "ghc-parallel")
(version "3.2.1.0")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/parallel/parallel-"
version
".tar.gz"))
(sha256
(base32
"09l52k1gsn667lmv0pp052cbwkzkbhfivp51f2xkrlfzf6xwvqsd"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/parallel")
(synopsis "Parallel programming library")
(description
"This package provides a library for parallel programming.")
(license license:bsd-3)))
(define-public ghc-safesemaphore
(package
(name "ghc-safesemaphore")
(version "0.10.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"SafeSemaphore/SafeSemaphore-" version ".tar.gz"))
(sha256
(base32
"0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stm" ,ghc-stm)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
(home-page "https://github.com/ChrisKuklewicz/SafeSemaphore")
(synopsis "Exception safe semaphores")
(description "This library provides exception safe semaphores that can be
used in place of @code{QSem}, @code{QSemN}, and @code{SampleVar}, all of which
are not exception safe and can be broken by @code{killThread}.")
(license license:bsd-3)))
(define-public ghc-text
(package
(name "ghc-text")
(version "1.2.2.2")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/text/text-"
version
".tar.gz"))
(sha256
(base32
"1y9d0zjs2ls0c574mr5xw7y3y49s62sd3wcn9lhpwz8a6q352iii"))))
(build-system haskell-build-system)
;; The test dependencies depend on ghc-text: ghc-test-framework -> ghc-xml -> ghc-text
(arguments `(#:tests? #f))
(inputs
`(("ghc-random" ,ghc-random)))
(home-page "https://github.com/bos/text")
(synopsis "Efficient packed Unicode text type library")
(description
"An efficient packed, immutable Unicode text type (both strict and
lazy), with a powerful loop fusion optimization framework.
The 'Text' type represents Unicode character strings, in a time and
space-efficient manner. This package provides text processing
capabilities that are optimized for performance critical use, both
in terms of large data quantities and high speed.")
(license license:bsd-3)))
(define-public ghc-text-binary
(package
(name "ghc-text-binary")
(version "0.2.1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"text-binary/text-binary-"
version ".tar.gz"))
(sha256
(base32
"18gl10pwg3qwsk0za3c70j4n6a9129wwf1b7d3a461h816yv55xn"))))
(build-system haskell-build-system)
(inputs `(("ghc-text" ,ghc-text)))
(home-page "https://github.com/kawu/text-binary")
(synopsis "Binary instances for text types")
(description
"This package provides a compatibility layer providing @code{Binary}
instances for strict and lazy text types for versions older than 1.2.1 of the
text package.")
(license license:bsd-2)))
(define-public ghc-strict
(package
(name "ghc-strict")
(version "0.3.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/strict/strict-"
version ".tar.gz"))
(sha256
(base32 "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/strict")
(synopsis "Strict data types and String IO")
(description
"This package provides strict versions of some standard Haskell data
types, such as pairs, @code{Maybe} and @code{Either}. It also contains strict
IO operations.")
(license license:bsd-3)))
(define-public ghc-hashable
(package
(name "ghc-hashable")
(version "1.2.6.1")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hashable/hashable-"
version
".tar.gz"))
(sha256
(base32
"0ymv2mcrrgbdc2w39rib171fwnhg7fgp0sy4h8amrh1vw64qgjll"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-random" ,ghc-random)))
(native-inputs
`(("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/tibbe/hashable")
(synopsis "Class for types that can be converted to a hash value")
(description
"This package defines a class, @code{Hashable}, for types that can be
converted to a hash value. This class exists for the benefit of hashing-based
data structures. The package provides instances for basic types and a way to
combine hash values.")
(license license:bsd-3)))
(define-public ghc-hashable-time
(package
(name "ghc-hashable-time")
(version "0.2.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hashable-time/hashable-time-"
version
".tar.gz"))
(sha256
(base32
"0k932nyd08l3xxbh2g3n76py2f4kd9yw4s5a065vjz0xp6wjnxdm"))))
(build-system haskell-build-system)
(inputs `(("ghc-hashable" ,ghc-hashable)))
(home-page "http://hackage.haskell.org/package/hashable-time")
(synopsis "Hashable instances for Data.Time")
(description
"This package provides @code{Hashable} instances for types in
@code{Data.Time}.")
(license license:bsd-3)))
(define-public ghc-data-hash
(package
(name "ghc-data-hash")
(version "0.2.0.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/data-hash"
"/data-hash-" version ".tar.gz"))
(sha256
(base32 "1ghbqvc48gf9p8wiy71hdpaj7by3b9cw6wgwi3qqz8iw054xs5wi"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(home-page "https://hackage.haskell.org/package/data-hash")
(synopsis "Combinators for building fast hashing functions")
(description
"This package provides combinators for building fast hashing functions.
It includes hashing functions for all basic Haskell98 types.")
(license license:bsd-3)))
(define-public ghc-murmur-hash
(package
(name "ghc-murmur-hash")
(version "0.1.0.9")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/murmur-hash"
"/murmur-hash-" version ".tar.gz"))
(sha256
(base32 "1bb58kfnzvx3mpc0rc0dhqc1fk36nm8prd6gvf20gk6lxaadpfc9"))))
(build-system haskell-build-system)
(home-page "https://github.com/nominolo/murmur-hash")
(synopsis "MurmurHash2 implementation for Haskell")
(description
"This package provides an implementation of MurmurHash2, a good, fast,
general-purpose, non-cryptographic hashing function. See
@url{https://sites.google.com/site/murmurhash/} for details. This
implementation is pure Haskell, so it might be a bit slower than a C FFI
binding.")
(license license:bsd-3)))
(define-public ghc-random
(package
(name "ghc-random")
(version "1.1")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/random/random-"
version
".tar.gz"))
(sha256
(base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
(build-system haskell-build-system)
(home-page "https://hackage.haskell.org/package/random")
(synopsis "Random number library")
(description "This package provides a basic random number generation
library, including the ability to split random number generators.")
(license license:bsd-3)))
(define-public ghc-primitive
(package
(name "ghc-primitive")
(version "0.6.3.0")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/primitive/primitive-"
version
".tar.gz"))
(sha256
(base32
"0mcmbnj08wd6zfwn7xk6zf5hy5zwbla5v78pw0dpymqg9s0gzpnd"))))
(build-system haskell-build-system)
(home-page
"https://github.com/haskell/primitive")
(synopsis "Primitive memory-related operations")
(description
"This package provides various primitive memory-related operations.")
(license license:bsd-3)))
(define-public ghc-tf-random
(package
(name "ghc-tf-random")
(version "0.5")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/tf-random/tf-random-"
version
".tar.gz"))
(sha256
(base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
(build-system haskell-build-system)
(inputs
`(("ghc-primitive" ,ghc-primitive)
("ghc-random" ,ghc-random)))
(home-page "https://hackage.haskell.org/package/tf-random")
(synopsis "High-quality splittable pseudorandom number generator")
(description "This package contains an implementation of a high-quality
splittable pseudorandom number generator. The generator is based on a
cryptographic hash function built on top of the ThreeFish block cipher. See
the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
Hashing\" by Claessen, Pałka for details and the rationale of the design.")
(license license:bsd-3)))
(define-public ghc-transformers-base
(package
(name "ghc-transformers-base")
(version "0.4.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/transformers-base/transformers-base-"
version
".tar.gz"))
(sha256
(base32
"11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stm" ,ghc-stm)
("ghc-transformers-compat" ,ghc-transformers-compat)))
(home-page
"https://hackage.haskell.org/package/transformers-compat")
(synopsis
"Backported transformer library")
(description
"Backported versions of types that were added to transformers in
transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
compatibility to run on old versions of the platform.")
(license license:bsd-3)))
(define-public ghc-transformers-compat
(package
(name "ghc-transformers-compat")
(version "0.5.1.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/transformers-compat"
"/transformers-compat-" version ".tar.gz"))
(sha256
(base32
"17yam0199fh9ndsn9n69jx9nvbsmymzzwbi23dck3dk4q57fz0fq"))))
(build-system haskell-build-system)
(home-page "https://github.com/ekmett/transformers-compat/")
(synopsis "Small compatibility shim between transformers 0.3 and 0.4")
(description "This package includes backported versions of types that were
added to transformers in transformers 0.3 and 0.4 for users who need strict
transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
but also need those types.")
(license license:bsd-3)))
(define-public ghc-unix-time
(package
(name "ghc-unix-time")
(version "0.3.7")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/unix-time/unix-time-"
version
".tar.gz"))
(sha256
(base32
"1qdlc9raih8s0m3x8x3n7q3ngh4faw2alv9l78sp6gnx648k0c8i"))))
(build-system haskell-build-system)
(arguments
`(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
; is weird, that should be provided by GHC 7.10.2.
(inputs
`(("ghc-old-time" ,ghc-old-time)
("ghc-old-locale" ,ghc-old-locale)))
(home-page "https://hackage.haskell.org/package/unix-time")
(synopsis "Unix time parser/formatter and utilities")
(description "This library provides fast parsing and formatting utilities
for Unix time in Haskell.")
(license license:bsd-3)))
(define-public ghc-unix-compat
(package
(name "ghc-unix-compat")
(version "0.4.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/unix-compat/unix-compat-"
version
".tar.gz"))
(sha256
(base32
"036nv05w0yjxc3rfpar60ddjrlzc40mdgr5k6ihvwlvqfmq1gw9m"))))
(build-system haskell-build-system)
(home-page
"https://github.com/jystic/unix-compat")
(synopsis "Portable POSIX-compatibility layer")
(description
"This package provides portable implementations of parts of the unix
package. This package re-exports the unix package when available. When it
isn't available, portable implementations are used.")
(license license:bsd-3)))
(define-public ghc-indents
(package
(name "ghc-indents")
(version "0.3.3")
(source (origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/indents/indents-"
version ".tar.gz"))
(sha256
(base32
"16lz21bp9j14xilnq8yym22p3saxvc9fsgfcf5awn2a6i6n527xn"))))
(build-system haskell-build-system)
(inputs
`(("ghc-parsec" ,ghc-parsec)
("ghc-concatenative" ,ghc-concatenative)
("ghc-mtl" ,ghc-mtl)))
(home-page "http://patch-tag.com/r/salazar/indents")
(synopsis "Indentation sensitive parser-combinators for parsec")
(description
"This library provides functions for use in parsing indentation sensitive
contexts. It parses blocks of lines all indented to the same level as well as
lines continued at an indented level below.")
(license license:bsd-3)))
(define-public ghc-iproute
(package
(name "ghc-iproute")
(version "1.7.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/iproute/iproute-"
version
".tar.gz"))
(sha256
(base32
"1viyxq3m1aifl05w0hxwrhhhcfpmvwz4ymil2gngi4nfm0yd1f2p"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
; exported by ghc-byteorder. Doctest issue.
(inputs
`(("ghc-appar" ,ghc-appar)
("ghc-byteorder" ,ghc-byteorder)
("ghc-network" ,ghc-network)
("ghc-safe" ,ghc-safe)))
(home-page "https://www.mew.org/~kazu/proj/iproute/")
(synopsis "IP routing table")
(description "IP Routing Table is a tree of IP ranges to search one of
them on the longest match base. It is a kind of TRIE with one way branching
removed. Both IPv4 and IPv6 are supported.")
(license license:bsd-3)))
(define-public ghc-iwlib
(package
(name "ghc-iwlib")
(version "0.1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/iwlib/iwlib-"
version ".tar.gz"))
(sha256
(base32 "0khmfwql4vwj55idsxmhjhrbqzfir3g9wm5lmpvnf77mm95cfpdz"))))
(build-system haskell-build-system)
(inputs
`(("wireless-tools" ,wireless-tools)))
(home-page "https://github.com/jaor/iwlib")
(synopsis "Haskell binding to the iw wireless networking library")
(description
"IWlib is a thin Haskell binding to the iw C library. It provides
information about the current wireless network connections, and adapters on
supported systems.")
(license license:bsd-3)))
(define-public ghc-regex-base
(package
(name "ghc-regex-base")
(version "0.93.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/regex-base/regex-base-"
version
".tar.gz"))
(sha256
(base32
"0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
(build-system haskell-build-system)
(inputs
`(("ghc-mtl" ,ghc-mtl)))
(home-page
"https://sourceforge.net/projects/lazy-regex")
(synopsis "Replaces/Enhances Text.Regex")
(description "@code{Text.Regex.Base} provides the interface API for
regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
(license license:bsd-3)))
(define-public ghc-regex-posix
(package
(name "ghc-regex-posix")
(version "0.95.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/regex-posix/regex-posix-"
version
".tar.gz"))
(sha256
(base32
"0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)))
(home-page "https://sourceforge.net/projects/lazy-regex")
(synopsis "POSIX regular expressions for Haskell")
(description "This library provides the POSIX regex backend used by the
Haskell library @code{regex-base}.")
(license license:bsd-3)))
(define-public ghc-regex-compat
(package
(name "ghc-regex-compat")
(version "0.95.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/regex-compat/regex-compat-"
version
".tar.gz"))
(sha256
(base32
"0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)
("ghc-regex-posix" ,ghc-regex-posix)))
(home-page "https://sourceforge.net/projects/lazy-regex")
(synopsis "Replaces/Enhances Text.Regex")
(description "This library provides one module layer over
@code{regex-posix} to replace @code{Text.Regex}.")
(license license:bsd-3)))
(define-public ghc-regex-tdfa-rc
(package
(name "ghc-regex-tdfa-rc")
(version "1.1.8.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-"
version
".tar.gz"))
(sha256
(base32
"1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3"))))
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)
("ghc-parsec" ,ghc-parsec)
("ghc-mtl" ,ghc-mtl)))
(home-page
"https://hackage.haskell.org/package/regex-tdfa")
(synopsis "Tagged DFA regex engine for Haskell")
(description "A new all-Haskell \"tagged\" DFA regex engine, inspired by
@code{libtre} (fork by Roman Cheplyaka).")
(license license:bsd-3)))
(define-public ghc-regex-tdfa-text
(package
(name "ghc-regex-tdfa-text")
(version "1.0.0.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/regex-tdfa-text/"
"regex-tdfa-text-" version ".tar.gz"))
(sha256
(base32
"0090g6lgbdm9lywpqm2d3724nnnh24nx3vnlqr96qc2w486pmmrq"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-regex-base" ,ghc-regex-base)
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
(home-page
"http://hackage.haskell.org/package/regex-tdfa-text")
(synopsis "Text interface for regex-tdfa")
(description
"This provides an extra text interface for regex-tdfa.")
(license license:bsd-3)))
(define-public ghc-regex
(package
(name "ghc-regex")
(version "1.0.1.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/regex/"
"regex-" version ".tar.gz"))
(sha256
(base32
"1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-hashable" ,ghc-hashable)
("ghc-regex-base" ,ghc-regex-base)
("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
("ghc-regex-tdfa" ,ghc-regex-tdfa)
("ghc-regex-tdfa-text" ,ghc-regex-tdfa-text)
("ghc-text" ,ghc-text)
("ghc-time-locale-compat" ,ghc-time-locale-compat)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-utf8-string" ,ghc-utf8-string)))
(home-page "http://regex.uk")
(synopsis "Toolkit for regex-base")
(description
"This package provides a regular expression toolkit for @code{regex-base}
with compile-time checking of regular expression syntax, data types for
matches and captures, a text replacement toolkit, portable options, high-level
AWK-like tools for building text processing apps, regular expression macros
with parsers and test bench, comprehensive documentation, tutorials and
copious examples.")
(license license:bsd-3)))
(define-public ghc-parsers
(package
(name "ghc-parsers")
(version "0.12.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/parsers/parsers-"
version
".tar.gz"))
(sha256
(base32
"07najh7f9y3ahh42z96sw4hnd0kc4x3wm0xlf739y0gh81ys5097"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
; -package attoparsec-0.13.0.1"
(inputs
`(("ghc-base-orphans" ,ghc-base-orphans)
("ghc-attoparsec" ,ghc-attoparsec)
("ghc-parsec" ,ghc-parsec)
("ghc-scientific" ,ghc-scientific)
("ghc-charset" ,ghc-charset)
("ghc-text" ,ghc-text)
("ghc-unordered-containers" ,ghc-unordered-containers)))
(home-page "https://github.com/ekmett/parsers/")
(synopsis "Parsing combinators")
(description "This library provides convenient combinators for working
with and building parsing combinator libraries. Given a few simple instances,
you get access to a large number of canned definitions. Instances exist for
the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
@code{Text.Read}.")
(license license:bsd-3)))
(define-public ghc-trifecta
(package
(name "ghc-trifecta")
(version "1.7.1.1")
(source (origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/trifecta/"
"trifecta-" version ".tar.gz"))
(sha256
(base32
"13n6a3fdxngnzsjnhfrzigv1c2g0xm6lqkjcnirpc37sd0rpby31"))))
(build-system haskell-build-system)
(inputs
`(("ghc-doctest" ,ghc-doctest-0.13)
("ghc-reducers" ,ghc-reducers)
("ghc-semigroups" ,ghc-semigroups)
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-blaze-builder" ,ghc-blaze-builder)
("ghc-blaze-html" ,ghc-blaze-html)
("ghc-blaze-markup" ,ghc-blaze-markup)
("ghc-charset" ,ghc-charset)
("ghc-comonad" ,ghc-comonad)
("ghc-doctest" ,ghc-doctest)
("ghc-fingertree" ,ghc-fingertree)
("ghc-hashable" ,ghc-hashable)
("ghc-lens" ,ghc-lens)
("ghc-mtl" ,ghc-mtl)
("ghc-parsers" ,ghc-parsers)
("ghc-profunctors" ,ghc-profunctors)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-utf8-string" ,ghc-utf8-string)))
(native-inputs
`(("cabal-doctest" ,cabal-doctest)))
(home-page "https://github.com/ekmett/trifecta/")
(synopsis "Parser combinator library with convenient diagnostics")
(description "Trifecta is a modern parser combinator library for Haskell,
with slicing and Clang-style colored diagnostics.")
(license license:bsd-3)))
(define-public ghc-time-locale-compat
(package
(name "ghc-time-locale-compat")
(version "0.1.1.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"time-locale-compat/time-locale-compat-"
version ".tar.gz"))
(sha256
(base32
"1vdcfr2hp9qh3ag90x6ikbdf42wiqpdylnplffna54bpnilbyi4i"))))
(build-system haskell-build-system)
(inputs `(("ghc-old-locale" ,ghc-old-locale)))
(home-page "https://github.com/khibino/haskell-time-locale-compat")
(synopsis "Compatibility of TimeLocale between old-locale and time-1.5")
(description "This package contains a wrapped name module for
@code{TimeLocale}.")
(license license:bsd-3)))
(define-public ghc-attoparsec
(package
(name "ghc-attoparsec")
(version "0.13.2.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/attoparsec/attoparsec-"
version
".tar.gz"))
(sha256
(base32
"0j6qcwd146yzlkc9mcvzvnixsyl65n2a68l28322q5v9p4g4g4yx"))))
(build-system haskell-build-system)
;; FIXME: at least on test fails with QuickCheck > 2.9.2. Once upstream
;; has updated the tests to work with a later version of QuickCheck we can
;; re-enable them.
(arguments `(#:tests? #f))
(inputs
`(("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)))
(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-zip-archive
(package
(name "ghc-zip-archive")
(version "0.3.0.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/zip-archive/zip-archive-"
version
".tar.gz"))
(sha256
(base32
"1iwpzjck4jg9bz1yqky051i2wljsqc14q5zbi10dydfp8ip3d0yw"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-time" ,ghc-old-time)
("ghc-digest" ,ghc-digest)
("zip" ,zip)
("ghc-mtl" ,ghc-mtl)
("ghc-temporary" ,ghc-temporary)
("ghc-text" ,ghc-text)
("ghc-zlib" ,ghc-zlib)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
(home-page "https://hackage.haskell.org/package/zip-archive")
(synopsis "Zip archive library for Haskell")
(description "The zip-archive library provides functions for creating,
modifying, and extracting files from zip archives in Haskell.")