7406 lines
263 KiB
Scheme
7406 lines
263 KiB
Scheme
;;; GNU Guix --- Functional package management for GNU
|
||
;;; Copyright © 2015 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 Ludovic Courtès <ludo@gnu.org>
|
||
;;; Copyright © 2016 ng0 <ng0@we.make.ritual.n0.is>
|
||
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
|
||
;;; Copyright © 2015, 2016 Ricardo Wurmus <rekado@elephly.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 (ice-9 regex)
|
||
#:use-module ((guix licenses) #:prefix license:)
|
||
#:use-module (guix packages)
|
||
#:use-module (guix download)
|
||
#:use-module (guix utils)
|
||
#:use-module (guix build-system gnu)
|
||
#:use-module (guix build-system haskell)
|
||
#:use-module (gnu packages pkg-config)
|
||
#:use-module (gnu packages perl)
|
||
#:use-module (gnu packages compression)
|
||
#:use-module (gnu packages elf)
|
||
#:use-module (gnu packages gl)
|
||
#:use-module (gnu packages sdl)
|
||
#:use-module (gnu packages bootstrap)
|
||
#:use-module (gnu packages zip)
|
||
#:use-module (gnu packages gcc)
|
||
#:use-module (gnu packages ghostscript)
|
||
#:use-module (gnu packages libffi)
|
||
#:use-module (gnu packages libedit)
|
||
#:use-module (gnu packages lua)
|
||
#:use-module (gnu packages multiprecision)
|
||
#:use-module (gnu packages ncurses)
|
||
#:use-module (gnu packages python)
|
||
#:use-module (gnu packages pcre)
|
||
#:use-module (gnu packages xml)
|
||
#:use-module (gnu packages xorg))
|
||
|
||
(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
|
||
(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)
|
||
("libedit" ,libedit)
|
||
("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."
|
||
,(version-major+minor
|
||
(package-version ncurses)))
|
||
(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-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-libxml
|
||
(package
|
||
(name "ghc-libxml")
|
||
(version "0.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "http://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 "http://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.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/prelude-extras/prelude-extras-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1q7mj9hysy747vimnlyrwsk1wb2axymxixa76fwcbcnmz3fi4llp"))))
|
||
(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.5.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/data-default/data-default-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32 "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c"))))
|
||
(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.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/data-default-class/"
|
||
"data-default-class-" version ".tar.gz"))
|
||
(sha256
|
||
(base32 "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d"))))
|
||
(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.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 "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb"))))
|
||
(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-haddock-library
|
||
(package
|
||
(name "ghc-haddock-library")
|
||
(version "1.2.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/haddock-library/haddock-library-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-base-compat" ,ghc-base-compat)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(native-inputs
|
||
`(("hspec-discover" ,hspec-discover)))
|
||
(home-page "http://www.haskell.org/haddock/")
|
||
(synopsis
|
||
"Library exposing some functionality of Haddock")
|
||
(description
|
||
"Haddock is a documentation-generation tool for Haskell libraries. These
|
||
modules expose some functionality of it without pulling in the GHC dependency.
|
||
Please note that the API is likely to change so specify upper bounds in your
|
||
project if you can't release often. For interacting with Haddock itself, see
|
||
the ‘haddock’ package.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-haddock-api
|
||
(package
|
||
(name "ghc-haddock-api")
|
||
(version "2.16.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/haddock-api/haddock-api-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-paths" ,ghc-paths)
|
||
("ghc-haddock-library" ,ghc-haddock-library)))
|
||
(home-page "http://www.haskell.org/haddock/")
|
||
(synopsis "API for documentation-generation tool Haddock")
|
||
(description "This package provides an API to Haddock, the
|
||
documentation-generation tool for Haskell libraries.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-haddock
|
||
(package
|
||
(name "ghc-haddock")
|
||
(version "2.16.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/haddock/haddock-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed
|
||
; upstream. See
|
||
; <https://github.com/haskell/haddock/issues/427>
|
||
(inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
|
||
(home-page "http://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
|
||
"http://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-multipart
|
||
(package
|
||
(name "ghc-multipart")
|
||
(version "0.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/multipart/multipart-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-parsec" ,ghc-parsec)))
|
||
(home-page
|
||
"http://www.github.com/silkapp/multipart")
|
||
(synopsis
|
||
"HTTP multipart library")
|
||
(description
|
||
"HTTP multipart split out of the cgi package, for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-html
|
||
(package
|
||
(name "ghc-html")
|
||
(version "1.0.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/html/html-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"https://hackage.haskell.org/package/html")
|
||
(synopsis "HTML combinator library")
|
||
(description
|
||
"This package contains a combinator library for constructing HTML
|
||
documents.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-xhtml
|
||
(package
|
||
(name "ghc-xhtml")
|
||
(version "3000.2.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/xhtml/xhtml-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/haskell/xhtml")
|
||
(synopsis "XHTML combinator library")
|
||
(description
|
||
"This package provides combinators for producing XHTML 1.0, including the
|
||
Strict, Transitional and Frameset variants.")
|
||
(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.1.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/alex/alex-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10. Fixed
|
||
; upstream, see
|
||
; <https://github.com/simonmar/alex/issues/62>
|
||
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "http://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.2.2.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/cgi/cgi-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-parsec" ,ghc-parsec)
|
||
("ghc-old-locale" ,ghc-old-locale)
|
||
("ghc-old-time" ,ghc-old-time)
|
||
("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-multipart" ,ghc-multipart)
|
||
("ghc-network-uri" ,ghc-network-uri)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(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.13")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/cmdargs/cmdargs-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6"))))
|
||
(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{http://concatenative.org}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-happy
|
||
(package
|
||
(name "ghc-happy")
|
||
(version "1.19.5")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/happy/happy-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ;; cannot satisfy -package mtl. Possible Cabal
|
||
;; issue.
|
||
(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-src-exts
|
||
(package
|
||
(name "ghc-haskell-src-exts")
|
||
(version "1.16.0.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
|
||
"1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("cpphs" ,cpphs)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-happy" ,ghc-happy)
|
||
("ghc-syb" ,ghc-syb)))
|
||
(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 hlint
|
||
(package
|
||
(name "hlint")
|
||
(version "1.9.21")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/" name
|
||
"/" name "-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("cpphs" ,cpphs)
|
||
("ghc-cmdargs" ,ghc-cmdargs)
|
||
("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
|
||
("ghc-uniplate" ,ghc-uniplate)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-extra" ,ghc-extra)
|
||
("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.1.6")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/resourcet/resourcet-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y"))))
|
||
(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)))
|
||
(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-xss-sanitize
|
||
(package
|
||
(name "ghc-xss-sanitize")
|
||
(version "0.3.5.6")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-tagsoup" ,ghc-tagsoup)
|
||
("ghc-utf8-string" ,ghc-utf8-string)
|
||
("ghc-css-text" ,ghc-css-text)
|
||
("ghc-network-uri" ,ghc-network-uri)))
|
||
(native-inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("ghc-attoparsec" ,ghc-attoparsec)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-hunit" ,ghc-hunit)))
|
||
(home-page "https://github.com/yesodweb/haskell-xss-sanitize")
|
||
(synopsis "Sanitize untrusted HTML to prevent XSS attacks")
|
||
(description "This library provides @code{sanitizeXSS}. Run untrusted
|
||
HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
|
||
attacks.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-objectname
|
||
(package
|
||
(name "ghc-objectname")
|
||
(version "1.1.0.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/ObjectName/ObjectName-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg"))))
|
||
(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.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z"))))
|
||
(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.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/SDL-image/SDL-image-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq"))))
|
||
(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.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/half/half-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1"))))
|
||
(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-openglraw
|
||
(package
|
||
(name "ghc-openglraw")
|
||
(version "2.5.1.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-half" ,ghc-half)
|
||
("glu" ,glu)
|
||
("ghc-text" ,ghc-text)))
|
||
(home-page "http://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.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/GLUT/GLUT-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-statevar" ,ghc-statevar)
|
||
("ghc-opengl" ,ghc-opengl)
|
||
("ghc-openglraw" ,ghc-openglraw)
|
||
("freeglut" ,freeglut)))
|
||
(home-page "http://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 "1.5.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/GLURaw/GLURaw-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-openglraw" ,ghc-openglraw)))
|
||
(home-page "http://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 "2.12.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/OpenGL/OpenGL-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b"))))
|
||
(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 "http://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.1.14.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/streaming-commons/streaming-commons-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-directory" ,ghc-directory)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-stm" ,ghc-stm)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-transformers" ,ghc-transformers)
|
||
("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 "Provides low-dependency functionality commonly needed by
|
||
various Haskell streaming data libraries, such as @code{conduit} and
|
||
@code{pipe}s.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public cpphs
|
||
(package
|
||
(name "cpphs")
|
||
(version "1.19.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/" name "/"
|
||
name "-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
|
||
(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")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/reflection/reflection-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
|
||
(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)
|
||
(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)
|
||
(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.7.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/dlist/dlist-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32 "10rp96rryij7d8gz5kv8ygc6chm1624ck5mbnqs2a3fkdzqj2b9k"))))
|
||
(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 "http://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 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)
|
||
(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{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
|
||
(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)
|
||
(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-x11
|
||
(package
|
||
(name "ghc-x11")
|
||
(version "1.6.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/X11/"
|
||
"X11-" version ".tar.gz"))
|
||
(sha256
|
||
(base32 "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj"))))
|
||
(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)
|
||
("xproto" ,xproto)))
|
||
(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.5.4.2")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/zlib/zlib-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
|
||
(build-system haskell-build-system)
|
||
(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.4")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/stm/stm-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/stm")
|
||
(synopsis "Software Transactional Memory")
|
||
(description
|
||
"A modular composable concurrency abstraction.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-parallel
|
||
(package
|
||
(name "ghc-parallel")
|
||
(version "3.2.0.6")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/parallel/parallel-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
|
||
(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-text
|
||
(package
|
||
(name "ghc-text")
|
||
(version "1.2.1.3")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/text/text-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(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-hashable
|
||
(package
|
||
(name "ghc-hashable")
|
||
(version "1.2.3.3")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hashable/hashable-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)))
|
||
(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, '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-hunit
|
||
(package
|
||
(name "ghc-hunit")
|
||
(version "1.2.5.2")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/HUnit/HUnit-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://hunit.sourceforge.net/")
|
||
(synopsis "Unit testing framework for Haskell")
|
||
(description
|
||
"HUnit is a unit testing framework for Haskell, inspired by the
|
||
JUnit tool for Java.")
|
||
(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.1.0")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/primitive/primitive-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1j1q7l21rdm8kfs93vibr3xwkkhqis181w2k6klfhx5g5skiywwk"))))
|
||
(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-test-framework
|
||
(package
|
||
(name "ghc-test-framework")
|
||
(version "0.8.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/test-framework/"
|
||
"test-framework-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(inputs
|
||
`(("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
|
||
("ghc-hostname" ,ghc-hostname)
|
||
("ghc-old-locale" ,ghc-old-locale)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-regex-posix" ,ghc-regex-posix)
|
||
("ghc-xml" ,ghc-xml)
|
||
("ghc-libxml" ,ghc-libxml)))
|
||
(home-page "https://batterseapower.github.io/test-framework/")
|
||
(synopsis "Framework for running and organising tests")
|
||
(description
|
||
"This package allows tests such as QuickCheck properties and HUnit test
|
||
cases to be assembled into test groups, run in parallel (but reported in
|
||
deterministic order, to aid diff interpretation) and filtered and controlled
|
||
by command line options. All of this comes with colored test output, progress
|
||
reporting and test statistics output.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-test-framework-hunit
|
||
(package
|
||
(name "ghc-test-framework-hunit")
|
||
(version "0.3.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"test-framework-hunit/test-framework-hunit-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-test-framework" ,ghc-test-framework)))
|
||
(home-page "https://batterseapower.github.io/test-framework/")
|
||
(synopsis "HUnit support for test-framework")
|
||
(description
|
||
"This package provides HUnit support for the test-framework package.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-test-framework-quickcheck2
|
||
(package
|
||
(name "ghc-test-framework-quickcheck2")
|
||
(version "0.3.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"test-framework-quickcheck2/"
|
||
"test-framework-quickcheck2-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
|
||
(modules '((guix build utils)))
|
||
(snippet
|
||
;; The Hackage page and the cabal file linked there for this package
|
||
;; both list 2.9 as the upper version limit, but the source tarball
|
||
;; specifies 2.8. Assume the Hackage page is correct.
|
||
'(substitute* "test-framework-quickcheck2.cabal"
|
||
(("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-test-framework" ,ghc-test-framework)))
|
||
(home-page "https://batterseapower.github.io/test-framework/")
|
||
(synopsis "QuickCheck2 support for test-framework")
|
||
(description
|
||
"This packages provides QuickCheck2 support for the test-framework
|
||
package.")
|
||
(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.4.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/transformers-compat"
|
||
"/transformers-compat-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym"))))
|
||
(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.6")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/unix-time/unix-time-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax"))))
|
||
(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.1.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/unix-compat/unix-compat-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps"))))
|
||
(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-http-types
|
||
(package
|
||
(name "ghc-http-types")
|
||
(version "0.9")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/http-types/http-types-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Tests cannot find
|
||
; Blaze.Bytestring.Builder, which should be
|
||
; provided by ghc-blaze-builder.
|
||
(inputs
|
||
`(("ghc-case-insensitive" ,ghc-case-insensitive)
|
||
("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-text" ,ghc-text)))
|
||
(home-page "https://github.com/aristidb/http-types")
|
||
(synopsis "Generic HTTP types for Haskell")
|
||
(description "This package provides generic HTTP types for Haskell (for
|
||
both client and server code).")
|
||
(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.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/iproute/iproute-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1ply0i110c2sppjbfyysgw48jfjnsbam5zwil8xws0hp20rh1pb5"))))
|
||
(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 "http://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-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
|
||
"http://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 "http://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 "http://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-parsers
|
||
(package
|
||
(name "ghc-parsers")
|
||
(version "0.12.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/parsers/parsers-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"18wzmp8y3py4qa8hdsxqm0jfzmwy744dw7xa48r5s8ynhpimi462"))))
|
||
(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.5.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/trifecta/trifecta-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0fjhnsbafl3yw34pyhcsvrqy6a2mnhyqys6gna3rrlygs8ck7hpb"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
|
||
; -package ansi-terminal-0.6.2.3"
|
||
(inputs
|
||
`(("ghc-charset" ,ghc-charset)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-lens" ,ghc-lens)
|
||
("ghc-profunctors" ,ghc-profunctors)
|
||
("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-fingertree" ,ghc-fingertree)
|
||
("ghc-hashable" ,ghc-hashable)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-parsers" ,ghc-parsers)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-utf8-string" ,ghc-utf8-string)))
|
||
(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-attoparsec
|
||
(package
|
||
(name "ghc-attoparsec")
|
||
(version "0.13.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/attoparsec/attoparsec-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-scientific" ,ghc-scientific)
|
||
("ghc-text" ,ghc-text)))
|
||
(native-inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
|
||
("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
|
||
("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-css-text
|
||
(package
|
||
(name "ghc-css-text")
|
||
(version "0.1.2.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/css-text/css-text-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("ghc-attoparsec" ,ghc-attoparsec)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "http://www.yesodweb.com/")
|
||
(synopsis "CSS parser and renderer")
|
||
(description "This package provides a CSS parser and renderer for
|
||
Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-zip-archive
|
||
(package
|
||
(name "ghc-zip-archive")
|
||
(version "0.2.3.7")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/zip-archive/zip-archive-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-old-time" ,ghc-old-time)
|
||
("ghc-digest" ,ghc-digest)
|
||
("zip" ,zip)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("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.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-distributive
|
||
(package
|
||
(name "ghc-distributive")
|
||
(version "0.4.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/distributive/distributive-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: fails with "cannot satisfy -package
|
||
; tagged-0.8.1". Suspected Cabal issue.
|
||
(inputs
|
||
`(("ghc-tagged" ,ghc-tagged)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)))
|
||
(home-page "https://github.com/ekmett/distributive/")
|
||
(synopsis "Distributive functors for Haskell")
|
||
(description "This package provides distributive functors for Haskell.
|
||
Dual to @code{Traversable}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-cereal
|
||
(package
|
||
(name "ghc-cereal")
|
||
(version "0.4.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/cereal/cereal-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/cereal")
|
||
(synopsis "Binary serialization library")
|
||
(description "This package provides a binary serialization library,
|
||
similar to @code{binary}, that introduces an @code{isolate} primitive for
|
||
parser isolation, and labeled blocks for better error messages.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-comonad
|
||
(package
|
||
(name "ghc-comonad")
|
||
(version "4.2.7.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/comonad/comonad-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
|
||
; -package contravariant-1.3.3"
|
||
(inputs
|
||
`(("ghc-distributive" ,ghc-distributive)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)
|
||
("ghc-contravariant" ,ghc-contravariant)
|
||
("ghc-semigroups" ,ghc-semigroups)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-contravariant" ,ghc-contravariant)))
|
||
(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 hscolour
|
||
(package
|
||
(name "hscolour")
|
||
(version "1.23")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hscolour/hscolour-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/hscolour")
|
||
(synopsis "Script to colourise Haskell code")
|
||
(description "HSColour is a small Haskell script to colourise Haskell
|
||
code. It currently has six output formats: ANSI terminal codes (optionally
|
||
XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01
|
||
with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX,
|
||
and mIRC chat codes.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-polyparse
|
||
(package
|
||
(name "ghc-polyparse")
|
||
(version "1.11")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/polyparse/polyparse-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)))
|
||
(home-page
|
||
"http://code.haskell.org/~malcolm/polyparse/")
|
||
(synopsis
|
||
"Alternative parser combinator libraries")
|
||
(description
|
||
"This package provides a variety of alternative parser combinator
|
||
libraries, including the original HuttonMeijer set. The Poly sets have
|
||
features like good error reporting, arbitrary token type, running state, lazy
|
||
parsing, and so on. Finally, Text.Parse is a proposed replacement for the
|
||
standard Read class, for better deserialisation of Haskell values from
|
||
Strings.")
|
||
(license license:lgpl2.1)))
|
||
|
||
(define-public ghc-extra
|
||
(package
|
||
(name "ghc-extra")
|
||
(version "1.4.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/extra/extra-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1h9hxkrqrqscx420yz1lmivbrhi6jc3a5ap61vkxd2mhdgark9hf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/ndmitchell/extra")
|
||
(synopsis "Extra Haskell functions")
|
||
(description "This library provides extra functions for the standard
|
||
Haskell libraries. Most functions are simple additions, filling out missing
|
||
functionality. A few functions are available in later versions of GHC, but
|
||
this package makes them available back to GHC 7.2.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-profunctors
|
||
(package
|
||
(name "ghc-profunctors")
|
||
(version "5.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/profunctors/profunctors-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-distributive" ,ghc-distributive)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-tagged" ,ghc-tagged)))
|
||
(home-page "https://github.com/ekmett/profunctors/")
|
||
(synopsis "Profunctors for Haskell")
|
||
(description "This library provides profunctors for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-reducers
|
||
(package
|
||
(name "ghc-reducers")
|
||
(version "3.12.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/reducers/reducers-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0pkddg0s3cn759miq0nfrq7lnp3imk5sx784ihsilsbjh9kvffz4"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-fingertree" ,ghc-fingertree)
|
||
("ghc-hashable" ,ghc-hashable)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-semigroupoids" ,ghc-semigroupoids)
|
||
("ghc-semigroups" ,ghc-semigroups)))
|
||
(home-page "https://github.com/ekmett/reducers/")
|
||
(synopsis "Semigroups, specialized containers and a general map/reduce framework")
|
||
(description "This library provides various semigroups, specialized
|
||
containers and a general map/reduce framework for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-appar
|
||
(package
|
||
(name "ghc-appar")
|
||
(version "0.1.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/appar/appar-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"https://hackage.haskell.org/package/appar")
|
||
(synopsis "Simple applicative parser")
|
||
(description "This package provides a simple applicative parser in Parsec
|
||
style.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-safe
|
||
(package
|
||
(name "ghc-safe")
|
||
(version "0.3.9")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/safe/safe-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/ndmitchell/safe#readme")
|
||
(synopsis "Library of safe (exception free) functions")
|
||
(description "This library provides wrappers around @code{Prelude} and
|
||
@code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
|
||
exceptions.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-generic-deriving
|
||
(package
|
||
(name "ghc-generic-deriving")
|
||
(version "1.8.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/generic-deriving/generic-deriving-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/generic-deriving")
|
||
(synopsis "Generalise the deriving mechanism to arbitrary classes")
|
||
(description "This package provides functionality for generalising the
|
||
deriving mechanism in Haskell to arbitrary classes.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-pcre-light
|
||
(package
|
||
(name "ghc-pcre-light")
|
||
(version "0.4.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/pcre-light/pcre-light-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("pcre" ,pcre)))
|
||
(home-page "https://github.com/Daniel-Diaz/pcre-light")
|
||
(synopsis "Haskell library for Perl 5 compatible regular expressions")
|
||
(description "This package provides a small, efficient, and portable regex
|
||
library for Perl 5 compatible regular expressions. The PCRE library is a set
|
||
of functions that implement regular expression pattern matching using the same
|
||
syntax and semantics as Perl 5.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-logict
|
||
(package
|
||
(name "ghc-logict")
|
||
(version "0.6.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/logict/logict-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-mtl" ,ghc-mtl)))
|
||
(home-page "http://code.haskell.org/~dolio/")
|
||
(synopsis "Backtracking logic-programming monad")
|
||
(description "This library provides a continuation-based, backtracking,
|
||
logic programming monad. An adaptation of the two-continuation implementation
|
||
found in the paper \"Backtracking, Interleaving, and Terminating Monad
|
||
Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
|
||
online}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-xml
|
||
(package
|
||
(name "ghc-xml")
|
||
(version "1.3.14")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/xml/xml-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)))
|
||
(home-page "http://code.galois.com")
|
||
(synopsis "Simple XML library for Haskell")
|
||
(description "This package provides a simple XML library for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-exceptions
|
||
(package
|
||
(name "ghc-exceptions")
|
||
(version "0.8.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/exceptions/exceptions-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Missing test-framework package.
|
||
(inputs
|
||
`(("ghc-stm" ,ghc-stm)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)))
|
||
(home-page "https://github.com/ekmett/exceptions/")
|
||
(synopsis "Extensible optionally-pure exceptions")
|
||
(description "This library provides extensible optionally-pure exceptions
|
||
for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-temporary
|
||
(package
|
||
(name "ghc-temporary")
|
||
(version "1.2.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/temporary/temporary-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-exceptions" ,ghc-exceptions)))
|
||
(home-page "http://www.github.com/batterseapower/temporary")
|
||
(synopsis "Temporary file and directory support")
|
||
(description "The functions for creating temporary files and directories
|
||
in the Haskelll base library are quite limited. This library just repackages
|
||
the Cabal implementations of its own temporary file and folder functions so
|
||
that you can use them without linking against Cabal or depending on it being
|
||
installed.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-temporary-rc
|
||
(package
|
||
(name "ghc-temporary-rc")
|
||
(version "1.2.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/temporary-rc/temporary-rc-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-exceptions" ,ghc-exceptions)))
|
||
(home-page
|
||
"http://www.github.com/feuerbach/temporary")
|
||
(synopsis
|
||
"Portable temporary file and directory support")
|
||
(description
|
||
"The functions for creating temporary files and directories in the base
|
||
library are quite limited. The unixutils package contains some good ones, but
|
||
they aren't portable to Windows. This library just repackages the Cabal
|
||
implementations of its own temporary file and folder functions so that you can
|
||
use them without linking against Cabal or depending on it being installed.
|
||
This is a better maintained fork of the \"temporary\" package.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-smallcheck
|
||
(package
|
||
(name "ghc-smallcheck")
|
||
(version "1.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/smallcheck/smallcheck-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-logict" ,ghc-logict)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(home-page
|
||
"https://github.com/feuerbach/smallcheck")
|
||
(synopsis "Property-based testing library")
|
||
(description "SmallCheck is a testing library that allows to verify
|
||
properties for all test cases up to some depth. The test cases are generated
|
||
automatically by SmallCheck.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tasty-ant-xml
|
||
(package
|
||
(name "ghc-tasty-ant-xml")
|
||
(version "1.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-generic-deriving" ,ghc-generic-deriving)
|
||
("ghc-xml" ,ghc-xml)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-stm" ,ghc-stm)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-tasty" ,ghc-tasty)))
|
||
(home-page
|
||
"https://github.com/ocharles/tasty-ant-xml")
|
||
(synopsis
|
||
"Render tasty output to XML for Jenkins")
|
||
(description
|
||
"A tasty ingredient to output test results in XML, using the Ant
|
||
schema. This XML can be consumed by the Jenkins continuous integration
|
||
framework.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tasty-smallcheck
|
||
(package
|
||
(name "ghc-tasty-smallcheck")
|
||
(version "0.8.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-smallcheck" ,ghc-smallcheck)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-tagged" ,ghc-tagged)))
|
||
(home-page "http://documentup.com/feuerbach/tasty")
|
||
(synopsis "SmallCheck support for the Tasty test framework")
|
||
(description "This package provides SmallCheck support for the Tasty
|
||
Haskell test framework.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-silently
|
||
(package
|
||
(name "ghc-silently")
|
||
(version "1.2.5")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/silently/silently-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ;; circular dependency with nanospec
|
||
;; (inputs
|
||
;; `(("ghc-temporary" ,ghc-temporary)))
|
||
(home-page "https://github.com/hspec/silently")
|
||
(synopsis "Prevent writing to stdout")
|
||
(description "This package provides functions to prevent or capture
|
||
writing to stdout and other handles.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-quickcheck-instances
|
||
(package
|
||
(name "ghc-quickcheck-instances")
|
||
(version "0.3.11")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/"
|
||
"quickcheck-instances/quickcheck-instances-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-old-time" ,ghc-old-time)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-hashable" ,ghc-hashable)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-text" ,ghc-text)))
|
||
(home-page
|
||
"https://github.com/aslatter/qc-instances")
|
||
(synopsis "Common quickcheck instances")
|
||
(description "This package provides QuickCheck instances for types
|
||
provided by the Haskell Platform.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-quickcheck-unicode
|
||
(package
|
||
(name "ghc-quickcheck-unicode")
|
||
(version "1.0.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page
|
||
"https://github.com/bos/quickcheck-unicode")
|
||
(synopsis "Generator functions Unicode-related tests")
|
||
(description "This package provides generator and shrink functions for
|
||
testing Unicode-related software.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-quickcheck-io
|
||
(package
|
||
(name "ghc-quickcheck-io")
|
||
(version "0.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hunit" ,ghc-hunit)))
|
||
(home-page
|
||
"https://github.com/hspec/quickcheck-io#readme")
|
||
(synopsis "Use HUnit assertions as QuickCheck properties")
|
||
(description "This package provides an orphan instance that allows you to
|
||
use HUnit assertions as QuickCheck properties.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-quickcheck
|
||
(package
|
||
(name "ghc-quickcheck")
|
||
(version "2.8.1")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0fvnfl30fxmj5q920l13641ar896d53z0z6z66m7c1366lvalwvh"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f ; FIXME: currently missing libraries used for tests.
|
||
#:configure-flags '("-f base4")))
|
||
(inputs
|
||
`(("ghc-tf-random" ,ghc-tf-random)))
|
||
(home-page
|
||
"https://github.com/nick8325/quickcheck")
|
||
(synopsis
|
||
"Automatic testing of Haskell programs")
|
||
(description
|
||
"QuickCheck is a library for random testing of program properties.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-case-insensitive
|
||
(package
|
||
(name "ghc-case-insensitive")
|
||
(version "1.2.0.4")
|
||
(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
|
||
"07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hunit" ,ghc-hunit)))
|
||
;; these inputs are necessary to use this library
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("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 'Data.CaseInsensitive' provides the 'CI' type constructor
|
||
which can be parameterised by a string-like type like: 'String', 'ByteString',
|
||
'Text', etc.. Comparisons of values of the resulting type will be insensitive
|
||
to cases.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-syb
|
||
(package
|
||
(name "ghc-syb")
|
||
(version "0.6")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/syb/syb-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hunit" ,ghc-hunit)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(home-page
|
||
"http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
|
||
(synopsis "Scrap Your Boilerplate")
|
||
(description "This package contains the generics system described in the
|
||
/Scrap Your Boilerplate/ papers (see
|
||
@uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It
|
||
defines the 'Data' class of types permitting folding and unfolding of
|
||
constructor applications, instances of this class for primitive types, and a
|
||
variety of traversals.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-fgl
|
||
(package
|
||
(name "ghc-fgl")
|
||
(version "5.5.3.0")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/fgl/fgl-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0fbyb6jxy9whgrv6dgnkzz70cmy98arx3q2gnkhgl4a3d7idh36p"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
|
||
(synopsis
|
||
"Martin Erwig's Functional Graph Library")
|
||
(description "The functional graph library, FGL, is a collection of type
|
||
and function definitions to address graph problems. The basis of the library
|
||
is an inductive definition of graphs in the style of algebraic data types that
|
||
encourages inductive, recursive definitions of graph algorithms.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-chasingbottoms
|
||
(package
|
||
(name "ghc-chasingbottoms")
|
||
(version "1.3.0.13")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/ChasingBottoms/"
|
||
"ChasingBottoms-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1fb86jd6cdz4rx3fj3r9n8d60kx824ywwy7dw4qnrdran46ja3pl"))
|
||
(modules '((guix build utils)))
|
||
(snippet
|
||
;; The Hackage page and the cabal file linked there for this package
|
||
;; both list 0.7 as the upper version limit, but the source tarball
|
||
;; specifies 0.6. Assume the Hackage page is correct.
|
||
'(substitute* "ChasingBottoms.cabal"
|
||
(("syb >= 0.1.0.2 && < 0.6") "syb >= 0.1.0.2 && < 0.7")))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-syb" ,ghc-syb)))
|
||
(home-page "https://hackage.haskell.org/package/ChasingBottoms")
|
||
(synopsis "Testing of partial and infinite values in Haskell")
|
||
(description
|
||
;; FIXME: There should be a @comma{} in the uref text, but it is not
|
||
;; rendered properly.
|
||
"This is a library for testing code involving bottoms or infinite values.
|
||
For the underlying theory and a larger example involving use of QuickCheck,
|
||
see the article
|
||
@uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
|
||
\"Chasing Bottoms A Case Study in Program Verification in the Presence of
|
||
Partial and Infinite Values\"}.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-unordered-containers
|
||
(package
|
||
(name "ghc-unordered-containers")
|
||
(version "0.2.5.1")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/unordered-containers"
|
||
"/unordered-containers-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-chasingbottoms" ,ghc-chasingbottoms)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
|
||
("ghc-hashable" ,ghc-hashable)))
|
||
(home-page
|
||
"https://github.com/tibbe/unordered-containers")
|
||
(synopsis
|
||
"Efficient hashing-based container types")
|
||
(description
|
||
"Efficient hashing-based container types. The containers have been
|
||
optimized for performance critical use, both in terms of large data quantities
|
||
and high speed.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-uniplate
|
||
(package
|
||
(name "ghc-uniplate")
|
||
(version "1.6.12")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/uniplate/uniplate-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-syb" ,ghc-syb)
|
||
("ghc-hashable" ,ghc-hashable)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)))
|
||
(home-page "http://community.haskell.org/~ndm/uniplate/")
|
||
(synopsis "Simple, concise and fast generic operations")
|
||
(description "Uniplate is a library for writing simple and concise generic
|
||
operations. Uniplate has similar goals to the original Scrap Your Boilerplate
|
||
work, but is substantially simpler and faster.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-base64-bytestring
|
||
(package
|
||
(name "ghc-base64-bytestring")
|
||
(version "1.0.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
|
||
(home-page "https://github.com/bos/base64-bytestring")
|
||
(synopsis "Base64 encoding and decoding for ByteStrings")
|
||
(description "This library provides fast base64 encoding and decoding for
|
||
Haskell @code{ByteString}s.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-annotated-wl-pprint
|
||
(package
|
||
(name "ghc-annotated-wl-pprint")
|
||
(version "0.7.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/annotated-wl-pprint"
|
||
"/annotated-wl-pprint-" version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"https://github.com/david-christiansen/annotated-wl-pprint")
|
||
(synopsis
|
||
"The Wadler/Leijen Pretty Printer, with annotation support")
|
||
(description "This is a modified version of wl-pprint, which was based on
|
||
Wadler's paper \"A Prettier Printer\". This version allows the library user
|
||
to annotate the text with semantic information, which can later be rendered in
|
||
a variety of ways.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-wl-pprint
|
||
(package
|
||
(name "ghc-wl-pprint")
|
||
(version "1.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/wl-pprint/wl-pprint-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"166zvk4zwn2zaa9kx66m1av38m34qp6h4i65bri2sfnxgvx0700r"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/wl-pprint")
|
||
(synopsis "Wadler/Leijen pretty printer")
|
||
(description
|
||
"This is a pretty printing library based on Wadler's paper @i{A Prettier
|
||
Printer}. This version allows the library user to declare overlapping
|
||
instances of the @code{Pretty} class.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-ansi-wl-pprint
|
||
(package
|
||
(name "ghc-ansi-wl-pprint")
|
||
(version "0.6.7.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/ansi-wl-pprint/ansi-wl-pprint-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"025pyphsjf0dnbrmj5nscbi6gzyigwgp3ifxb3psn7kji6mfr29p"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
|
||
(home-page "https://github.com/ekmett/ansi-wl-pprint")
|
||
(synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
|
||
(description "This is a pretty printing library based on Wadler's paper
|
||
\"A Prettier Printer\". It has been enhanced with support for ANSI terminal
|
||
colored output using the ansi-terminal package.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-split
|
||
(package
|
||
(name "ghc-split")
|
||
(version "0.2.2")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/split/split-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))
|
||
(modules '((guix build utils)))
|
||
(snippet
|
||
;; The Cabal file on Hackage is updated, but the tar.gz does not
|
||
;; include it. See
|
||
;; <https://hackage.haskell.org/package/split-0.2.2/revisions/>.
|
||
'(substitute* "split.cabal"
|
||
(("base <4.8") "base <4.9")))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://hackage.haskell.org/package/split")
|
||
(synopsis "Combinator library for splitting lists")
|
||
(description "This package provides a collection of Haskell functions for
|
||
splitting lists into parts, akin to the @code{split} function found in several
|
||
mainstream languages.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-parsec
|
||
(package
|
||
(name "ghc-parsec")
|
||
(version "3.1.9")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/parsec/parsec-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-hunit" ,ghc-hunit)))
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(home-page
|
||
"https://github.com/aslatter/parsec")
|
||
(synopsis "Monadic parser combinators")
|
||
(description "Parsec is a parser library. It is simple, safe, well
|
||
documented, has extensive libraries, good error messages, and is fast. It is
|
||
defined as a monad transformer that can be stacked on arbitrary monads, and it
|
||
is also parametric in the input stream type.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-vector
|
||
(package
|
||
(name "ghc-vector")
|
||
(version "0.11.0.0")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/vector/vector-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-primitive" ,ghc-primitive)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(home-page "https://github.com/haskell/vector")
|
||
(synopsis "Efficient Arrays")
|
||
(description "This library provides an efficient implementation of
|
||
Int-indexed arrays (both mutable and immutable), with a powerful loop
|
||
optimisation framework.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-vector-binary-instances
|
||
(package
|
||
(name "ghc-vector-binary-instances")
|
||
(version "0.2.1.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/"
|
||
"vector-binary-instances/vector-binary-instances-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-cereal" ,ghc-cereal)
|
||
("ghc-vector" ,ghc-vector)))
|
||
(home-page "https://github.com/bos/vector-binary-instances")
|
||
(synopsis "Instances of Data.Binary and Data.Serialize for vector")
|
||
(description "This library provides instances of @code{Binary} for the
|
||
types defined in the @code{vector} package, making it easy to serialize
|
||
vectors to and from disk. We use the generic interface to vectors, so all
|
||
vector types are supported. Specific instances are provided for unboxed,
|
||
boxed and storable vectors.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-network
|
||
(package
|
||
(name "ghc-network")
|
||
(version "2.6.2.1")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/network/network-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hunit" ,ghc-hunit)))
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(home-page "https://github.com/haskell/network")
|
||
(synopsis "Low-level networking interface")
|
||
(description
|
||
"This package provides a low-level networking interface.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-network-uri
|
||
(package
|
||
(name "ghc-network-uri")
|
||
(version "2.6.0.3")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/network-uri/network-uri-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(native-inputs
|
||
`(("ghc-hunit" ,ghc-hunit)))
|
||
(inputs
|
||
`(("ghc-parsec" ,ghc-parsec)
|
||
("ghc-network" ,ghc-network)))
|
||
(home-page
|
||
"https://github.com/haskell/network-uri")
|
||
(synopsis "Library for URI manipulation")
|
||
(description "This package provides an URI manipulation interface. In
|
||
'network-2.6' the 'Network.URI' module was split off from the 'network'
|
||
package into this package.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-ansi-terminal
|
||
(package
|
||
(name "ghc-ansi-terminal")
|
||
(version "0.6.2.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d"))))
|
||
(build-system haskell-build-system)
|
||
(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-http
|
||
(package
|
||
(name "ghc-http")
|
||
(version "4000.2.20")
|
||
(outputs '("out" "doc"))
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/HTTP/HTTP-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-hunit" ,ghc-hunit)))
|
||
(inputs
|
||
`(("ghc-old-time" ,ghc-old-time)
|
||
("ghc-parsec" ,ghc-parsec)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-network-uri" ,ghc-network-uri)))
|
||
(arguments
|
||
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
|
||
(home-page "https://github.com/haskell/HTTP")
|
||
(synopsis "Library for client-side HTTP")
|
||
(description
|
||
"The HTTP package supports client-side web programming in Haskell. It
|
||
lets you set up HTTP connections, transmitting requests and processing the
|
||
responses coming back.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-hspec
|
||
(package
|
||
(name "ghc-hspec")
|
||
(version "2.2.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hspec/hspec-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hspec-core" ,ghc-hspec-core)
|
||
("hspec-discover" ,hspec-discover)
|
||
("ghc-hspec-expectations" ,ghc-hspec-expectations)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-stringbuilder" ,ghc-stringbuilder)
|
||
("ghc-hspec-meta" ,ghc-hspec-meta)))
|
||
(home-page "http://hspec.github.io/")
|
||
(synopsis "Testing Framework for Haskell")
|
||
(description "This library provides the Hspec testing framework for
|
||
Haskell, inspired by the Ruby library RSpec.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-hspec-contrib
|
||
(package
|
||
(name "ghc-hspec-contrib")
|
||
(version "0.3.0")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"hspec-contrib/hspec-contrib-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hspec-core" ,ghc-hspec-core)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(native-inputs
|
||
`(("hspec-discover" ,hspec-discover)))
|
||
(home-page "http://hspec.github.io/")
|
||
(synopsis "Contributed functionality for Hspec")
|
||
(description
|
||
"This package provides contributed Hspec extensions.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-hspec-expectations
|
||
(package
|
||
(name "ghc-hspec-expectations")
|
||
(version "0.7.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-hunit" ,ghc-hunit)))
|
||
(home-page "https://github.com/sol/hspec-expectations")
|
||
(synopsis "Catchy combinators for HUnit")
|
||
(description "This library provides catchy combinators for HUnit, see
|
||
@uref{https://github.com/sol/hspec-expectations#readme, the README}.")
|
||
(license license:expat)))
|
||
|
||
(define-public hspec-discover
|
||
(package
|
||
(name "hspec-discover")
|
||
(version "2.2.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hspec-discover/hspec-discover-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
|
||
; documentation files.
|
||
(inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
|
||
(home-page "http://hspec.github.io/")
|
||
(synopsis "Automatically discover and run Hspec tests")
|
||
(description "hspec-discover is a tool which automatically discovers and
|
||
runs Hspec tests.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-hspec-core
|
||
(package
|
||
(name "ghc-hspec-core")
|
||
(version "2.2.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hspec-core/hspec-core-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
|
||
(inputs
|
||
`(("ghc-setenv" ,ghc-setenv)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-quickcheck-io" ,ghc-quickcheck-io)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hspec-expectations" ,ghc-hspec-expectations)
|
||
("ghc-silently" ,ghc-silently)))
|
||
(home-page "http://hspec.github.io/")
|
||
(synopsis "Testing framework for Haskell")
|
||
(description "This library exposes internal types and functions that can
|
||
be used to extend Hspec's functionality.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-hspec-meta
|
||
(package
|
||
(name "ghc-hspec-meta")
|
||
(version "2.2.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/hspec-meta/hspec-meta-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-hspec-expectations" ,ghc-hspec-expectations)
|
||
("ghc-setenv" ,ghc-setenv)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-quickcheck-io" ,ghc-quickcheck-io)))
|
||
(home-page "http://hspec.github.io/")
|
||
(synopsis "Version of Hspec to test Hspec itself")
|
||
(description "This library provides a stable version of Hspec which is
|
||
used to test the in-development version of Hspec.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-vault
|
||
(package
|
||
(name "ghc-vault")
|
||
(version "0.3.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/vault/vault-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-hashable" ,ghc-hashable)))
|
||
(home-page
|
||
"https://github.com/HeinrichApfelmus/vault")
|
||
(synopsis "Persistent store for arbitrary values")
|
||
(description "This package provides vaults for Haskell. A vault is a
|
||
persistent store for values of arbitrary types. It's like having first-class
|
||
access to the storage space behind @code{IORefs}. The data structure is
|
||
analogous to a bank vault, where you can access different bank boxes with
|
||
different keys; hence the name. Also provided is a @code{locker} type,
|
||
representing a store for a single element.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-mmorph
|
||
(package
|
||
(name "ghc-mmorph")
|
||
(version "1.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/mmorph/mmorph-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"https://hackage.haskell.org/package/mmorph")
|
||
(synopsis "Monad morphisms")
|
||
(description
|
||
"This library provides monad morphism utilities, most commonly used for
|
||
manipulating monad transformer stacks.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-monad-control
|
||
(package
|
||
(name "ghc-monad-control")
|
||
(version "1.0.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/monad-control"
|
||
"/monad-control-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-stm" ,ghc-stm)
|
||
("ghc-transformers-base" ,ghc-transformers-base)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)))
|
||
(home-page "https://github.com/basvandijk/monad-control")
|
||
(synopsis "Monad transformers to lift control operations like exception
|
||
catching")
|
||
(description "This package defines the type class @code{MonadBaseControl},
|
||
a subset of @code{MonadBase} into which generic control operations such as
|
||
@code{catch} can be lifted from @code{IO} or any other base monad.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-byteorder
|
||
(package
|
||
(name "ghc-byteorder")
|
||
(version "1.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/byteorder/byteorder-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"http://community.haskell.org/~aslatter/code/byteorder")
|
||
(synopsis
|
||
"Exposes the native endianness of the system")
|
||
(description
|
||
"This package is for working with the native byte-ordering of the
|
||
system.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-base-compat
|
||
(package
|
||
(name "ghc-base-compat")
|
||
(version "0.8.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/base-compat/base-compat-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("hspec-discover" ,hspec-discover)))
|
||
(home-page "https://hackage.haskell.org/package/base-compat")
|
||
(synopsis "Haskell compiler compatibility library")
|
||
(description "This library provides functions available in later versions
|
||
of base to a wider range of compilers, without requiring the use of CPP
|
||
pragmas in your code.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-blaze-builder
|
||
(package
|
||
(name "ghc-blaze-builder")
|
||
(version "0.4.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/blaze-builder/blaze-builder-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Missing test libraries.
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("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.7.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/blaze-markup/blaze-markup-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"080vlhd8dwjxrma4bb524lh8gxs5lm3xh122icy6lnnyipla0s9y"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
|
||
(inputs
|
||
`(("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-text" ,ghc-text)))
|
||
(home-page "http://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-blaze-html
|
||
(package
|
||
(name "ghc-blaze-html")
|
||
(version "0.8.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/blaze-html/blaze-html-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
|
||
(inputs
|
||
`(("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-blaze-markup" ,ghc-blaze-markup)))
|
||
(home-page "http://jaspervdj.be/blaze")
|
||
(synopsis "Fast HTML combinator library")
|
||
(description "This library provides HTML combinators for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-easy-file
|
||
(package
|
||
(name "ghc-easy-file")
|
||
(version "0.2.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/easy-file/easy-file-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"https://github.com/kazu-yamamoto/easy-file")
|
||
(synopsis "File handling library for Haskell")
|
||
(description "This library provides file handling utilities for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-async
|
||
(package
|
||
(name "ghc-async")
|
||
(version "2.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/async/async-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-stm" ,ghc-stm)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
|
||
(home-page "https://github.com/simonmar/async")
|
||
(synopsis "Library to run IO operations asynchronously")
|
||
(description "Async provides a library to run IO operations
|
||
asynchronously, and wait for their results. It is a higher-level interface
|
||
over threads in Haskell, in which @code{Async a} is a concurrent thread that
|
||
will eventually deliver a value of type @code{a}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-fingertree
|
||
(package
|
||
(name "ghc-fingertree")
|
||
(version "0.1.1.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/fingertree/fingertree-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
|
||
(home-page "https://hackage.haskell.org/package/fingertree")
|
||
(synopsis "Generic finger-tree structure")
|
||
(description "This library provides finger trees, a general sequence
|
||
representation with arbitrary annotations, for use as a base for
|
||
implementations of various collection types. It includes examples, as
|
||
described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
|
||
simple general-purpose data structure\".")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-optparse-applicative
|
||
(package
|
||
(name "ghc-optparse-applicative")
|
||
(version "0.11.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/optparse-applicative"
|
||
"/optparse-applicative-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-transformers-compat" ,ghc-transformers-compat)
|
||
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
|
||
(home-page "https://github.com/pcapriotti/optparse-applicative")
|
||
(synopsis "Utilities and combinators for parsing command line options")
|
||
(description "This package provides utilities and combinators for parsing
|
||
command line options in Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-base-orphans
|
||
(package
|
||
(name "ghc-base-orphans")
|
||
(version "0.4.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/base-orphans/base-orphans-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("hspec-discover" ,hspec-discover)))
|
||
(home-page "https://hackage.haskell.org/package/base-orphans")
|
||
(synopsis "Orphan instances for backwards compatibility")
|
||
(description "This package defines orphan instances that mimic instances
|
||
available in later versions of base to a wider (older) range of compilers.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-auto-update
|
||
(package
|
||
(name "ghc-auto-update")
|
||
(version "0.1.2.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/auto-update/auto-update-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/yesodweb/wai")
|
||
(synopsis "Efficiently run periodic, on-demand actions")
|
||
(description "This library provides mechanisms to efficiently run
|
||
periodic, on-demand actions in Haskell.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-tagged
|
||
(package
|
||
(name "ghc-tagged")
|
||
(version "0.8.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tagged/tagged-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/tagged")
|
||
(synopsis "Haskell phantom types to avoid passing dummy arguments")
|
||
(description "This library provides phantom types for Haskell 98, to avoid
|
||
having to unsafely pass dummy arguments.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-unbounded-delays
|
||
(package
|
||
(name "ghc-unbounded-delays")
|
||
(version "0.1.0.9")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/basvandijk/unbounded-delays")
|
||
(synopsis "Unbounded thread delays and timeouts")
|
||
(description "The @code{threadDelay} and @code{timeout} functions from the
|
||
Haskell base library use the bounded @code{Int} type for specifying the delay
|
||
or timeout period. This package provides alternative functions which use the
|
||
unbounded @code{Integer} type.")
|
||
(license license:bsd-3)))
|
||
|
||
;; This package builds `clock` without tests, since the tests rely on tasty
|
||
;; and tasty-quickcheck, which in turn require clock to build. When tasty and
|
||
;; tasty-quickcheck are added, we will add ghc-clock with tests enabled.
|
||
(define ghc-clock-bootstrap
|
||
(package
|
||
(name "ghc-clock-bootstrap")
|
||
(version "0.5.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/"
|
||
"clock/"
|
||
"clock-" version ".tar.gz"))
|
||
(sha256
|
||
(base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
|
||
;; tasty-quickcheck, which need clock to build.
|
||
(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)))
|
||
|
||
(define-public ghc-clock
|
||
(package
|
||
(name "ghc-clock")
|
||
(version "0.5.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/"
|
||
"clock/"
|
||
"clock-" version ".tar.gz"))
|
||
(sha256
|
||
(base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
|
||
(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)))
|
||
|
||
(define-public ghc-charset
|
||
(package
|
||
(name "ghc-charset")
|
||
(version "0.3.7.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/charset/charset-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-semigroups" ,ghc-semigroups)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)))
|
||
(home-page "https://github.com/ekmett/charset")
|
||
(synopsis "Fast unicode character sets for Haskell")
|
||
(description "This package provides fast unicode character sets for
|
||
Haskell, based on complemented PATRICIA tries.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-bytestring-builder
|
||
(package
|
||
(name "ghc-bytestring-builder")
|
||
(version "0.10.6.0.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/bytestring-builder"
|
||
"/bytestring-builder-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:haddock? #f)) ; Package contains no documentation.
|
||
(home-page "https://hackage.haskell.org/package/bytestring-builder")
|
||
(synopsis "The new bytestring builder, packaged outside of GHC")
|
||
(description "This package provides the bytestring builder that is
|
||
debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
|
||
Compatibility package for older packages.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-nats
|
||
(package
|
||
(name "ghc-nats")
|
||
(version "1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/nats/nats-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:haddock? #f))
|
||
(inputs
|
||
`(("ghc-hashable" ,ghc-hashable)))
|
||
(home-page "https://hackage.haskell.org/package/nats")
|
||
(synopsis "Natural numbers")
|
||
(description "This library provides the natural numbers for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-void
|
||
(package
|
||
(name "ghc-void")
|
||
(version "0.7.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/void/void-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-semigroups" ,ghc-semigroups)
|
||
("ghc-hashable" ,ghc-hashable)))
|
||
(home-page "https://github.com/ekmett/void")
|
||
(synopsis
|
||
"Logically uninhabited data type")
|
||
(description
|
||
"A Haskell 98 logically uninhabited data type, used to indicate that a
|
||
given term should not exist.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-kan-extensions
|
||
(package
|
||
(name "ghc-kan-extensions")
|
||
(version "4.2.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/kan-extensions/kan-extensions-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0iywbadpy8s3isfzlx9dlz3apaywhqq4gdbxkwygksq8pzdhwkrk"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-adjunctions" ,ghc-adjunctions)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-contravariant" ,ghc-contravariant)
|
||
("ghc-distributive" ,ghc-distributive)
|
||
("ghc-free" ,ghc-free)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-semigroupoids" ,ghc-semigroupoids)
|
||
("ghc-tagged" ,ghc-tagged)))
|
||
(home-page "https://github.com/ekmett/kan-extensions/")
|
||
(synopsis "Kan extensions library")
|
||
(description "This library provides Kan extensions, Kan lifts, various
|
||
forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-statevar
|
||
(package
|
||
(name "ghc-statevar")
|
||
(version "1.1.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/StateVar/StateVar-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-stm" ,ghc-stm)))
|
||
(home-page "https://hackage.haskell.org/package/StateVar")
|
||
(synopsis "State variables for Haskell")
|
||
(description "This package provides state variables, which are references
|
||
in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-lens
|
||
(package
|
||
(name "ghc-lens")
|
||
(version "4.13")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/lens/lens-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0g4g0xksrb2m8wgsmraaq8qnk1sssb42kr65fc7clgyid6zyfmim"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
|
||
(inputs
|
||
`(("ghc-base-orphans" ,ghc-base-orphans)
|
||
("ghc-bifunctors" ,ghc-bifunctors)
|
||
("ghc-distributive" ,ghc-distributive)
|
||
("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-free" ,ghc-free)
|
||
("ghc-kan-extensions" ,ghc-kan-extensions)
|
||
("ghc-parallel" ,ghc-parallel)
|
||
("ghc-reflection" ,ghc-reflection)
|
||
("ghc-semigroupoids" ,ghc-semigroupoids)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-contravariant" ,ghc-contravariant)
|
||
("ghc-hashable" ,ghc-hashable)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-profunctors" ,ghc-profunctors)
|
||
("ghc-semigroups" ,ghc-semigroups)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-void" ,ghc-void)
|
||
("ghc-generic-deriving" ,ghc-generic-deriving)
|
||
("ghc-nats" ,ghc-nats)
|
||
("ghc-simple-reflect" ,ghc-simple-reflect)
|
||
("hlint" ,hlint)))
|
||
(home-page "https://github.com/ekmett/lens/")
|
||
(synopsis "Lenses, Folds and Traversals")
|
||
(description "This library provides @code{Control.Lens}. The combinators
|
||
in @code{Control.Lens} provide a highly generic toolbox for composing families
|
||
of getters, folds, isomorphisms, traversals, setters and lenses and their
|
||
indexed variants.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tagsoup
|
||
(package
|
||
(name "ghc-tagsoup")
|
||
(version "0.14")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tagsoup/tagsoup-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"07pax7i0bl79dmqqz58zy09yrgpnyyr2ya0z183hv96kp65jv0lh"))))
|
||
(build-system haskell-build-system)
|
||
(inputs `(("ghc-text" ,ghc-text)))
|
||
(home-page
|
||
"http://community.haskell.org/~ndm/tagsoup/")
|
||
(synopsis
|
||
"Parsing and extracting information from (possibly malformed) HTML/XML
|
||
documents")
|
||
(description
|
||
"TagSoup is a library for parsing HTML/XML. It supports the HTML 5
|
||
specification, and can be used to parse either well-formed XML, or
|
||
unstructured and malformed HTML from the web. The library also provides
|
||
useful functions to extract information from an HTML document, making it ideal
|
||
for screen-scraping.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-digest
|
||
(package
|
||
(name "ghc-digest")
|
||
(version "0.0.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/digest/digest-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("zlib" ,zlib)))
|
||
(home-page
|
||
"https://hackage.haskell.org/package/digest")
|
||
(synopsis
|
||
"Various cryptographic hashes for bytestrings")
|
||
(description
|
||
"This package provides efficient cryptographic hash implementations for
|
||
strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they
|
||
are implemented as FFI bindings to efficient code from zlib.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-cheapskate
|
||
(package
|
||
(name "ghc-cheapskate")
|
||
(version "0.1.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/cheapskate/cheapskate-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-xss-sanitize" ,ghc-xss-sanitize)
|
||
("ghc-data-default" ,ghc-data-default)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-blaze-html" ,ghc-blaze-html)
|
||
("ghc-syb" ,ghc-syb)
|
||
("ghc-uniplate" ,ghc-uniplate)
|
||
("ghc-aeson" ,ghc-aeson)
|
||
("ghc-wai-extra" ,ghc-wai-extra)
|
||
("ghc-wai" ,ghc-wai)
|
||
("ghc-http-types" ,ghc-http-types)))
|
||
(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 XSS
|
||
attacks.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-bifunctors
|
||
(package
|
||
(name "ghc-bifunctors")
|
||
(version "5")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/bifunctors/bifunctors-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-tagged" ,ghc-tagged)
|
||
("ghc-semigroups" ,ghc-semigroups)))
|
||
(home-page "https://github.com/ekmett/bifunctors/")
|
||
(synopsis "Bifunctors for Haskell")
|
||
(description "This package provides bifunctors for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-semigroupoids
|
||
(package
|
||
(name "ghc-semigroupoids")
|
||
(version "5.0.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/semigroupoids/semigroupoids-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1jf7jnfhdvl6p18wdr21yi2fim1xb8alcn6szhrdswj0dkilgq6d"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
|
||
(inputs
|
||
`(("ghc-base-orphans" ,ghc-base-orphans)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)
|
||
("ghc-bifunctors" ,ghc-bifunctors)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-contravariant" ,ghc-contravariant)
|
||
("ghc-distributive" ,ghc-distributive)
|
||
("ghc-semigroups" ,ghc-semigroups)
|
||
("ghc-tagged" ,ghc-tagged)))
|
||
(home-page "https://github.com/ekmett/semigroupoids")
|
||
(synopsis "Semigroupoids operations for Haskell")
|
||
(description "This library provides a wide array of (semi)groupoids and
|
||
operations for working with them. A @code{Semigroupoid} is a @code{Category}
|
||
without the requirement of identity arrows for every object in the category.
|
||
A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
|
||
Finally, to work with these weaker structures it is beneficial to have
|
||
containers that can provide stronger guarantees about their contents, so
|
||
versions of @code{Traversable} and @code{Foldable} that can be folded with
|
||
just a @code{Semigroup} are added.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-contravariant
|
||
(package
|
||
(name "ghc-contravariant")
|
||
(version "1.3.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/contravariant/contravariant-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"184hcmhsznqrkmqlc1kza9pb5p591anva574ry8wrh81vqmhwfb5"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-void" ,ghc-void)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)
|
||
("ghc-statevar" ,ghc-statevar)
|
||
("ghc-semigroups" ,ghc-semigroups)))
|
||
(home-page
|
||
"https://github.com/ekmett/contravariant/")
|
||
(synopsis "Contravariant functors")
|
||
(description "Contravariant functors for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-semigroups
|
||
(package
|
||
(name "ghc-semigroups")
|
||
(version "0.17.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/semigroups/semigroups-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0gvpfi7s6ys4qha3y9a1zl1a15gf9cgg33wjb94ghg82ivcxnc3r"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-nats" ,ghc-nats)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-hashable" ,ghc-hashable)))
|
||
(home-page "https://github.com/ekmett/semigroups/")
|
||
(synopsis "Semigroup operations for Haskell")
|
||
(description "This package provides semigroups for Haskell. In
|
||
mathematics, a semigroup is an algebraic structure consisting of a set
|
||
together with an associative binary operation. A semigroup generalizes a
|
||
monoid in that there might not exist an identity element. It
|
||
also (originally) generalized a group (a monoid with all inverses) to a type
|
||
where every element did not have to have an inverse, thus the name
|
||
semigroup.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-free
|
||
(package
|
||
(name "ghc-free")
|
||
(version "4.12.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/free/free-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-prelude-extras" ,ghc-prelude-extras)
|
||
("ghc-profunctors" ,ghc-profunctors)
|
||
("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-bifunctors" ,ghc-bifunctors)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-distributive" ,ghc-distributive)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-semigroupoids" ,ghc-semigroupoids)
|
||
("ghc-semigroups" ,ghc-semigroups)))
|
||
(home-page "https://github.com/ekmett/free/")
|
||
(synopsis "Unrestricted monads for Haskell")
|
||
(description "This library provides free monads, which are useful for many
|
||
tree-like structures and domain specific languages. If @code{f} is a
|
||
@code{Functor} then the free @code{Monad} on @code{f} is the type of trees
|
||
whose nodes are labeled with the constructors of @code{f}. The word \"free\"
|
||
is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
|
||
f} makes no constraining assumptions beyond those given by @code{f} and the
|
||
definition of @code{Monad}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-adjunctions
|
||
(package
|
||
(name "ghc-adjunctions")
|
||
(version "4.2.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/adjunctions/adjunctions-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"00p030iypjzjib8pxz1x6mxfi59wvyrwjj11zv9bh766dgkdbwjq"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-profunctors" ,ghc-profunctors)
|
||
("ghc-comonad" ,ghc-comonad)
|
||
("ghc-contravariant" ,ghc-contravariant)
|
||
("ghc-distributive" ,ghc-distributive)
|
||
("ghc-free" ,ghc-free)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-semigroupoids" ,ghc-semigroupoids)
|
||
("ghc-semigroups" ,ghc-semigroups)
|
||
("ghc-void" ,ghc-void)))
|
||
(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-fast-logger
|
||
(package
|
||
(name "ghc-fast-logger")
|
||
(version "2.4.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/fast-logger/fast-logger-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0kjk1861qcls8m8y7i55msfpprws5wk6c5mxzi35g2qbl2sih4p5"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-bytestring-builder" ,ghc-bytestring-builder)
|
||
("ghc-auto-update" ,ghc-auto-update)
|
||
("ghc-text" ,ghc-text)))
|
||
(native-inputs
|
||
`(("hspec-discover" ,hspec-discover)
|
||
("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "https://hackage.haskell.org/package/fast-logger")
|
||
(synopsis "Fast logging system")
|
||
(description "This library provides a fast logging system for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-doctest
|
||
(package
|
||
(name "ghc-doctest")
|
||
(version "0.10.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/doctest/doctest-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: missing test framework
|
||
(inputs
|
||
`(("ghc-syb" ,ghc-syb)
|
||
("ghc-paths" ,ghc-paths)
|
||
("ghc-base-compat" ,ghc-base-compat)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-stringbuilder" ,ghc-stringbuilder)
|
||
("ghc-silently" ,ghc-silently)
|
||
("ghc-setenv" ,ghc-setenv)))
|
||
(home-page
|
||
"https://github.com/sol/doctest#readme")
|
||
(synopsis "Test interactive Haskell examples")
|
||
(description "The doctest program checks examples in source code comments.
|
||
It is modeled after doctest for Python, see
|
||
@uref{http://docs.python.org/library/doctest.html, the Doctest website}.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-lifted-base
|
||
(package
|
||
(name "ghc-lifted-base")
|
||
(version "0.2.3.6")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/lifted-base/lifted-base-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
|
||
(inputs
|
||
`(("ghc-transformers-base" ,ghc-transformers-base)
|
||
("ghc-monad-control" ,ghc-monad-control)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)
|
||
("ghc-hunit" ,ghc-hunit)))
|
||
(home-page "https://github.com/basvandijk/lifted-base")
|
||
(synopsis "Lifted IO operations from the base library")
|
||
(description "Lifted-base exports IO operations from the @code{base}
|
||
library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
|
||
Note that not all modules from @code{base} are converted yet. The package
|
||
includes a copy of the @code{monad-peel} test suite written by Anders
|
||
Kaseorg.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-word8
|
||
(package
|
||
(name "ghc-word8")
|
||
(version "0.1.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/word8/word8-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("hspec-discover" ,hspec-discover)))
|
||
(home-page "https://hackage.haskell.org/package/word8")
|
||
(synopsis "Word8 library for Haskell")
|
||
(description "Word8 library to be used with @code{Data.ByteString}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-stringsearch
|
||
(package
|
||
(name "ghc-stringsearch")
|
||
(version "0.3.6.6")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/stringsearch/stringsearch-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://bitbucket.org/dafis/stringsearch")
|
||
(synopsis "Fast searching, splitting and replacing of ByteStrings")
|
||
(description "This package provides several functions to quickly search
|
||
for substrings in strict or lazy @code{ByteStrings}. It also provides
|
||
functions for breaking or splitting on substrings and replacing all
|
||
occurrences of a substring (the first in case of overlaps) with another.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tasty-quickcheck
|
||
(package
|
||
(name "ghc-tasty-quickcheck")
|
||
(version "0.8.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty-quickcheck/"
|
||
"tasty-quickcheck-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-pcre-light" ,ghc-pcre-light)))
|
||
(home-page "http://documentup.com/feuerbach/tasty")
|
||
(synopsis "QuickCheck support for the Tasty test framework")
|
||
(description "This package provides QuickCheck support for the Tasty
|
||
Haskell test framework.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-tasty-golden
|
||
(package
|
||
(name "ghc-tasty-golden")
|
||
(version "2.3.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-temporary" ,ghc-temporary)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-optparse-applicative" ,ghc-optparse-applicative)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-temporary-rc" ,ghc-temporary-rc)))
|
||
(home-page
|
||
"https://github.com/feuerbach/tasty-golden")
|
||
(synopsis "Golden tests support for tasty")
|
||
(description
|
||
"This package provides support for 'golden testing'. A golden test is an
|
||
IO action that writes its result to a file. To pass the test, this output
|
||
file should be identical to the corresponding 'golden' file, which contains
|
||
the correct result for the test.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-tasty
|
||
(package
|
||
(name "ghc-tasty")
|
||
(version "0.11.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty/tasty-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-stm" ,ghc-stm)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-tagged" ,ghc-tagged)
|
||
("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
|
||
("ghc-optparse-applicative" ,ghc-optparse-applicative)
|
||
("ghc-unbounded-delays" ,ghc-unbounded-delays)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
|
||
(home-page "http://documentup.com/feuerbach/tasty")
|
||
(synopsis "Modern and extensible testing framework")
|
||
(description "Tasty is a modern testing framework for Haskell. It lets
|
||
you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
|
||
and any other types of tests into a single test suite.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-tasty-hunit
|
||
(package
|
||
(name "ghc-tasty-hunit")
|
||
(version "0.9.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-tasty" ,ghc-tasty)))
|
||
(home-page "http://documentup.com/feuerbach/tasty")
|
||
(synopsis "HUnit support for the Tasty test framework")
|
||
(description "This package provides HUnit support for the Tasty Haskell
|
||
test framework.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-cookie
|
||
(package
|
||
(name "ghc-cookie")
|
||
(version "0.4.1.6")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/cookie/cookie-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-old-locale" ,ghc-old-locale)
|
||
("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-data-default-class" ,ghc-data-default-class)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
|
||
(home-page "https://github.com/snoyberg/cookie")
|
||
(synopsis "HTTP cookie parsing and rendering")
|
||
(description "HTTP cookie parsing and rendering library for Haskell.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-scientific
|
||
(package
|
||
(name "ghc-scientific")
|
||
(version "0.3.4.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/scientific/scientific-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0mimdkva0cgzaychr6whv9if29z0r5wwhkss9bmd4rz8kq1kgngn"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hashable" ,ghc-hashable)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-smallcheck" ,ghc-smallcheck)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/basvandijk/scientific")
|
||
(synopsis "Numbers represented using scientific notation")
|
||
(description "This package provides @code{Data.Scientific}, which provides
|
||
the number type @code{Scientific}. Scientific numbers are arbitrary precision
|
||
and space efficient. They are represented using
|
||
@uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific
|
||
notation}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-aeson
|
||
(package
|
||
(name "ghc-aeson")
|
||
(version "0.10.0.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/aeson/aeson-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
|
||
(inputs
|
||
`(("ghc-attoparsec" ,ghc-attoparsec)
|
||
("ghc-dlist" ,ghc-dlist)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-scientific" ,ghc-scientific)
|
||
("ghc-syb" ,ghc-syb)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-hashable" ,ghc-hashable)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/bos/aeson")
|
||
(synopsis "Fast JSON parsing and encoding")
|
||
(description "This package provides a JSON parsing and encoding library
|
||
for Haskell, optimized for ease of use and high performance. (A note on
|
||
naming: in Greek mythology, Aeson was the father of Jason.)")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-aeson-pretty
|
||
(package
|
||
(name "ghc-aeson-pretty")
|
||
(version "0.7.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-aeson" ,ghc-aeson)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-unordered-containers"
|
||
,ghc-unordered-containers)
|
||
("ghc-attoparsec" ,ghc-attoparsec)
|
||
("ghc-cmdargs" ,ghc-cmdargs)))
|
||
(home-page "https://github.com/informatikr/aeson-pretty")
|
||
(synopsis "JSON pretty-printing library and command-line tool")
|
||
(description
|
||
"This package provides a JSON pretty-printing library compatible with aeson
|
||
as well as a command-line tool to improve readabilty of streams of JSON data.
|
||
The library provides the function @code{encodePretty}. It is a drop-in
|
||
replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
|
||
human readers. The command-line tool reads JSON from stdin and writes
|
||
prettified JSON to stdout. It also offers a complementary \"compact\"-mode,
|
||
essentially the opposite of pretty-printing.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-wai
|
||
(package
|
||
(name "ghc-wai")
|
||
(version "3.0.4.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/wai/wai-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1551n0g0n22vml33v0jz5xgjcy6j79algvsdqg11a1z5ljjrjlqf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-bytestring-builder" ,ghc-bytestring-builder)
|
||
("ghc-unix-compat" ,ghc-unix-compat)
|
||
("ghc-vault" ,ghc-vault)
|
||
("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-http-types" ,ghc-http-types)))
|
||
(native-inputs
|
||
`(("hspec-discover" ,hspec-discover)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "https://hackage.haskell.org/package/wai")
|
||
(synopsis "Web application interface for Haskell")
|
||
(description "This package provides a Web Application Interface (WAI)
|
||
library for the Haskell language. It defines a common protocol for
|
||
communication between web applications and web servers.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-wai-logger
|
||
(package
|
||
(name "ghc-wai-logger")
|
||
(version "2.2.4.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/wai-logger/wai-logger-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
|
||
(build-system haskell-build-system)
|
||
(arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
|
||
; by propagated-inputs.
|
||
(inputs
|
||
`(("ghc-auto-update" ,ghc-auto-update)
|
||
("ghc-byteorder" ,ghc-byteorder)
|
||
("ghc-easy-file" ,ghc-easy-file)
|
||
("ghc-unix-time" ,ghc-unix-time)
|
||
("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-case-insensitive" ,ghc-case-insensitive)
|
||
("ghc-fast-logger" ,ghc-fast-logger)
|
||
("ghc-http-types" ,ghc-http-types)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-wai" ,ghc-wai)))
|
||
(home-page "https://hackage.haskell.org/package/wai-logger")
|
||
(synopsis "Logging system for WAI")
|
||
(description "This package provides the logging system for WAI.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-wai-extra
|
||
(package
|
||
(name "ghc-wai-extra")
|
||
(version "3.0.11.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/wai-extra/wai-extra-"
|
||
version
|
||
".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1kr2s5qyx1dvnwr372h7pca4sgxjv0pdx96xkgsfi180h3mb0vq8"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-base64-bytestring" ,ghc-base64-bytestring)
|
||
("ghc-cookie" ,ghc-cookie)
|
||
("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-lifted-base" ,ghc-lifted-base)
|
||
("ghc-streaming-commons" ,ghc-streaming-commons)
|
||
("ghc-stringsearch" ,ghc-stringsearch)
|
||
("ghc-resourcet" ,ghc-resourcet)
|
||
("ghc-fast-logger" ,ghc-fast-logger)
|
||
("ghc-wai-logger" ,ghc-wai-logger)
|
||
("ghc-zlib" ,ghc-zlib)
|
||
("ghc-word8" ,ghc-word8)
|
||
("ghc-iproute" ,ghc-iproute)
|
||
("ghc-void" ,ghc-void)
|
||
("ghc-wai" ,ghc-wai)
|
||
("ghc-http-types" ,ghc-http-types)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-case-insensitive" ,ghc-case-insensitive)
|
||
("ghc-data-default-class" ,ghc-data-default-class)
|
||
("ghc-unix-compat" ,ghc-unix-compat)
|
||
("ghc-vault" ,ghc-vault)
|
||
("ghc-aeson" ,ghc-aeson)))
|
||
(native-inputs
|
||
`(("hspec-discover" ,hspec-discover)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-hunit" ,ghc-hunit)))
|
||
(home-page "https://github.com/yesodweb/wai")
|
||
(synopsis "Some basic WAI handlers and middleware")
|
||
(description "This library provides basic WAI handlers and middleware
|
||
functionality.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-deepseq-generics
|
||
(package
|
||
(name "ghc-deepseq-generics")
|
||
(version "0.1.1.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"deepseq-generics/deepseq-generics-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:phases
|
||
(modify-phases %standard-phases
|
||
(add-after 'unpack 'relax-ghc-prim-dependency
|
||
(lambda _
|
||
(substitute* "deepseq-generics.cabal"
|
||
(("< 0.4") "< 0.5"))
|
||
#t)))))
|
||
(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 'rnf' implementation.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-pandoc-types
|
||
(package
|
||
(name "ghc-pandoc-types")
|
||
(version "1.16.1.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"pandoc-types/pandoc-types-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"094mzgdxva84kcpjf9m8b5n3chm1wm44bzflh5x6xhddz6pb7zpq"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-syb" ,ghc-syb)
|
||
("ghc-aeson" ,ghc-aeson)
|
||
("ghc-deepseq-generics" ,ghc-deepseq-generics)))
|
||
(home-page "http://johnmacfarlane.net/pandoc")
|
||
(synopsis "Types for representing a structured document")
|
||
(description
|
||
"This module defines the @code{Pandoc} data structure, which is used by
|
||
pandoc to represent structured documents. It also provides functions for
|
||
building up, manipulating and serialising @code{Pandoc} structures.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-texmath
|
||
(package
|
||
(name "ghc-texmath")
|
||
(version "0.8.6.5")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"texmath/texmath-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"143c8k7dyhwa9blpa8svy23ybx7i4xzb9jnfcimj8iigizbw7y1k"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-syb" ,ghc-syb)
|
||
("ghc-network-uri" ,ghc-network-uri)
|
||
("ghc-split" ,ghc-split)
|
||
("ghc-temporary" ,ghc-temporary)
|
||
("ghc-utf8-string" ,ghc-utf8-string)
|
||
("ghc-xml" ,ghc-xml)
|
||
("ghc-parsec" ,ghc-parsec)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-pandoc-types" ,ghc-pandoc-types)))
|
||
(home-page "https://github.com/jgm/texmath")
|
||
(synopsis "Conversion between formats used to represent mathematics")
|
||
(description
|
||
"The texmath library provides functions to read and write TeX math,
|
||
presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
|
||
Office). Support is also included for converting math formats to pandoc's
|
||
native format (allowing conversion, via pandoc, to a variety of different
|
||
markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
|
||
it can parse and apply LaTeX macros.")
|
||
(license license:gpl2+)))
|
||
|
||
(define-public ghc-regex-pcre-builtin
|
||
(package
|
||
(name "ghc-regex-pcre-builtin")
|
||
(version "0.94.4.8.8.35")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"regex-pcre-builtin/regex-pcre-builtin-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-regex-base" ,ghc-regex-base)))
|
||
(home-page "https://hackage.haskell.org/package/regex-pcre")
|
||
(synopsis "Enhancement of the builtin Text.Regex library")
|
||
(description
|
||
"This package is an enhancement of the @code{Text.Regex} library,
|
||
providing the PCRE backend to accompany regex-base, with bundled code from
|
||
@url{http://www.pcre.org}.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-diff
|
||
(package
|
||
(name "ghc-diff")
|
||
(version "0.3.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"Diff/Diff-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://hub.darcs.net/sterlingclover/Diff")
|
||
(synopsis "O(ND) diff algorithm in Haskell")
|
||
(description
|
||
"This package provides an implementation of the standard diff algorithm,
|
||
and utilities for pretty printing.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-highlighting-kate
|
||
(package
|
||
(name "ghc-highlighting-kate")
|
||
(version "0.6.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"highlighting-kate/highlighting-kate-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"03c4flh4h1jd48bx0qmplax3q8w6wj1dhbh6j0xhaf5h95fbinki"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-diff" ,ghc-diff)
|
||
("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
|
||
(native-inputs
|
||
`(("ghc-parsec" ,ghc-parsec)
|
||
("ghc-blaze-html" ,ghc-blaze-html)
|
||
("ghc-utf8-string" ,ghc-utf8-string)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(home-page "https://github.com/jgm/highlighting-kate")
|
||
(synopsis "Syntax highlighting library")
|
||
(description
|
||
"Highlighting-kate is a syntax highlighting library with support for
|
||
nearly one hundred languages. The syntax parsers are automatically generated
|
||
from @uref{http://kate-editor.org/, Kate syntax descriptions}, so any syntax
|
||
supported by Kate can be added. An (optional) command-line program is
|
||
provided, along with a utility for generating new parsers from Kate XML syntax
|
||
descriptions.")
|
||
(license license:gpl2+)))
|
||
|
||
(define-public ghc-cmark
|
||
(package
|
||
(name "ghc-cmark")
|
||
(version "0.5.3.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"cmark/cmark-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"09515h9b26az9c2mbl6l7azimaixa6yff8w359k0ml8jwykjvqaa"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)))
|
||
(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 sources for
|
||
libcmark (0.21.0) and does not require prior installation of the C library.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-executable-path
|
||
(package
|
||
(name "ghc-executable-path")
|
||
(version "0.0.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"executable-path/executable-path-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/executable-path")
|
||
(synopsis "Find out the full path of the executable")
|
||
(description
|
||
"The documentation of @code{System.Environment.getProgName} says that
|
||
\"However, this is hard-to-impossible to implement on some non-Unix OSes, so
|
||
instead, for maximum portability, we just return the leafname of the program
|
||
as invoked.\" This library tries to provide the missing path.")
|
||
(license license:public-domain)))
|
||
|
||
(define-public ghc-enclosed-exceptions
|
||
(package
|
||
(name "ghc-enclosed-exceptions")
|
||
(version "1.0.1.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"enclosed-exceptions/enclosed-exceptions-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-lifted-base" ,ghc-lifted-base)
|
||
("ghc-monad-control" ,ghc-monad-control)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-transformers-base" ,ghc-transformers-base)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/jcristovao/enclosed-exceptions")
|
||
(synopsis "Catch all exceptions from within an enclosed computation")
|
||
(description
|
||
"This library implements a technique to catch all exceptions raised
|
||
within an enclosed computation, while remaining responsive to (external)
|
||
asynchronous exceptions.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-packedstring
|
||
(package
|
||
(name "ghc-packedstring")
|
||
(version "0.1.0.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"packedstring/packedstring-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:phases
|
||
(modify-phases %standard-phases
|
||
(add-after 'unpack 'enable-extension
|
||
(lambda _
|
||
;; This package won't compile without the StandaloneDeriving
|
||
;; extension.
|
||
(substitute* "packedstring.cabal"
|
||
(("CPP") "CPP, StandaloneDeriving"))
|
||
#t)))))
|
||
(home-page "https://hackage.haskell.org/package/packedstring")
|
||
(synopsis "Library for packed strings")
|
||
(description
|
||
"This deprecated library provides an implementation of packed strings.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-th-lift
|
||
(package
|
||
(name "ghc-th-lift")
|
||
(version "0.7.5")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"th-lift/th-lift-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"13xdkk1chdghf059sfx8d3d8r0mj1dbzdi5kf2zf0mjmz3qq7m7k"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-packedstring" ,ghc-packedstring)))
|
||
(home-page "https://github.com/mboes/th-lift")
|
||
(synopsis "Derive Template Haskell's Lift class for datatypes")
|
||
(description
|
||
"This is a Haskell library to derive Template Haskell's Lift class for
|
||
datatypes.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-th-expand-syns
|
||
(package
|
||
(name "ghc-th-expand-syns")
|
||
(version "0.3.0.6")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"th-expand-syns/th-expand-syns-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-syb" ,ghc-syb)))
|
||
(home-page "https://hackage.haskell.org/package/th-expand-syns")
|
||
(synopsis "Expands type synonyms in Template Haskell ASTs")
|
||
(description
|
||
"This package enables users to expand type synonyms in Template Haskell
|
||
@dfn{abstract syntax trees} (ASTs).")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-th-reify-many
|
||
(package
|
||
(name "ghc-th-reify-many")
|
||
(version "0.1.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"th-reify-many/th-reify-many-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-safe" ,ghc-safe)
|
||
("ghc-th-expand-syns" ,ghc-th-expand-syns)))
|
||
(home-page "https://github.com/mgsloan/th-reify-many")
|
||
(synopsis "Recurseively reify template haskell datatype info")
|
||
(description
|
||
"th-reify-many provides functions for recursively reifying top level
|
||
declarations. The main intended use case is for enumerating the names of
|
||
datatypes reachable from an initial datatype, and passing these names to some
|
||
function which generates instances.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-th-orphans
|
||
(package
|
||
(name "ghc-th-orphans")
|
||
(version "0.13.0")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"th-orphans/th-orphans-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"105y03bxh0a2r69l603i7md17gg1vxs1jj1n40pn5q486lmfxbmx"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-th-lift" ,ghc-th-lift)
|
||
("ghc-th-reify-many" ,ghc-th-reify-many)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-generic-deriving" ,ghc-generic-deriving)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "https://hackage.haskell.org/package/th-orphans")
|
||
(synopsis "Orphan instances for TH datatypes")
|
||
(description
|
||
"This package provides orphan instances for Template Haskell datatypes. In particular,
|
||
instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
|
||
and @code{Eq} instances. These instances used to live in the haskell-src-meta
|
||
package, and that's where the version number started.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-haskell-src-meta
|
||
(package
|
||
(name "ghc-haskell-src-meta")
|
||
(version "0.6.0.12")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"haskell-src-meta/haskell-src-meta-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1mzbfrfvl6pj8068w3m6alzry1403ir1gmz3czg66n5z198l4dql"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
|
||
("ghc-syb" ,ghc-syb)
|
||
("ghc-th-orphans" ,ghc-th-orphans)))
|
||
(home-page "https://hackage.haskell.org/package/haskell-src-meta")
|
||
(synopsis "Parse source to template-haskell abstract syntax")
|
||
(description
|
||
"This package provides tools to parse Haskell sources to the
|
||
template-haskell abstract syntax.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-aeson-qq
|
||
(package
|
||
(name "ghc-aeson-qq")
|
||
(version "0.8.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"aeson-qq/aeson-qq-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-base-compat" ,ghc-base-compat)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-attoparsec" ,ghc-attoparsec)
|
||
("ghc-scientific" ,ghc-scientific)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-aeson" ,ghc-aeson)
|
||
("ghc-parsec" ,ghc-parsec)
|
||
("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("hspec-discover" ,hspec-discover)))
|
||
(home-page "https://github.com/zalora/aeson-qq")
|
||
(synopsis "JSON quasiquoter for Haskell")
|
||
(description
|
||
"aeson-qq provides a JSON quasiquoter for Haskell. This package exposes
|
||
the function @code{aesonQQ} that compile-time converts a string representation
|
||
of a JSON value into a @code{Data.Aeson.Value}.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-conduit
|
||
(package
|
||
(name "ghc-conduit")
|
||
(version "1.2.5.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"conduit/conduit-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0aq6wswd5dkhdmy7sjhd99mldpq33dqpgbdcwpm94ahvckqxs7v5"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-lifted-base" ,ghc-lifted-base)
|
||
("ghc-mmorph" ,ghc-mmorph)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-resourcet" ,ghc-resourcet)
|
||
("ghc-transformers-base" ,ghc-transformers-base)
|
||
("ghc-void" ,ghc-void)))
|
||
(native-inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hspec" ,ghc-hspec)
|
||
("ghc-safe" ,ghc-safe)))
|
||
(home-page "https://github.com/snoyberg/conduit")
|
||
(synopsis "Streaming data library ")
|
||
(description
|
||
"conduit is a solution to the streaming data problem, allowing for
|
||
production, transformation, and consumption of streams of data in constant
|
||
memory. It is an alternative to lazy I/O which guarantees deterministic
|
||
resource handling, and fits in the same general solution space as
|
||
enumerator/iteratee and pipes." )
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-logging-facade
|
||
(package
|
||
(name "ghc-logging-facade")
|
||
(version "0.1.0")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"logging-facade/logging-facade-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("hspec-discover" ,hspec-discover)))
|
||
(home-page "https://hackage.haskell.org/package/logging-facade")
|
||
(synopsis "Simple logging abstraction that allows multiple back-ends")
|
||
(description
|
||
"This package provides a simple logging abstraction that allows multiple
|
||
back-ends.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-mockery
|
||
(package
|
||
(name "ghc-mockery")
|
||
(version "0.3.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"mockery/mockery-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0m0lp2z63sgkylz5318j53r5hnrkp705qh7nqbb149ir4gy7g1bg"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-temporary" ,ghc-temporary)
|
||
("ghc-logging-facade" ,ghc-logging-facade)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("hspec-discover" ,hspec-discover)))
|
||
(home-page "https://hackage.haskell.org/package/mockery")
|
||
(synopsis "Support functions for automated testing")
|
||
(description
|
||
"The mockery package provides support functions for automated testing.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-yaml
|
||
(package
|
||
(name "ghc-yaml")
|
||
(version "0.8.15.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"yaml/yaml-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0v6c435xmgm99zxb30pqr7lhkb2a56wxqp70g4hjz8p7rj0vichx"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-conduit" ,ghc-conduit)
|
||
("ghc-resourcet" ,ghc-resourcet)
|
||
("ghc-aeson" ,ghc-aeson)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-attoparsec" ,ghc-attoparsec)
|
||
("ghc-scientific" ,ghc-scientific)
|
||
("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
|
||
("ghc-aeson-qq" ,ghc-aeson-qq)
|
||
("ghc-base-compat" ,ghc-base-compat)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("hspec-discover" ,hspec-discover)
|
||
("ghc-mockery" ,ghc-mockery)))
|
||
(home-page "https://github.com/snoyberg/yaml/")
|
||
(synopsis "Parsing and rendering YAML documents")
|
||
(description
|
||
"This package provides a library to parse and render YAML documents.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-filemanip
|
||
(package
|
||
(name "ghc-filemanip")
|
||
(version "0.3.6.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"filemanip/filemanip-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-unix-compat" ,ghc-unix-compat)))
|
||
(home-page "https://github.com/bos/filemanip")
|
||
(synopsis "File and directory manipulation for Haskell")
|
||
(description
|
||
"This package provides a Haskell library for working with files and
|
||
directories. It includes code for pattern matching, finding files, modifying
|
||
file contents, and more.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-mmap
|
||
(package
|
||
(name "ghc-mmap")
|
||
(version "0.5.9")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"mmap/mmap-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://hackage.haskell.org/package/mmap")
|
||
(synopsis "Memory mapped files for Haskell")
|
||
(description
|
||
"This library provides a wrapper to @code{mmap}, allowing files or
|
||
devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
|
||
@code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
|
||
do on-demand loading.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-juicypixels
|
||
(package
|
||
(name "ghc-juicypixels")
|
||
(version "3.2.6.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"JuicyPixels/JuicyPixels-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0hxa57cdknz86zywpjwfbdhac5lmk7j0wd5hy4mcnb8mw6r2m592"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-zlib" ,ghc-zlib)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-primitive" ,ghc-primitive)
|
||
("ghc-mmap" ,ghc-mmap)))
|
||
(home-page "https://github.com/Twinside/Juicy.Pixels")
|
||
(synopsis "Picture loading and serialization library")
|
||
(description
|
||
"This library can load and store images in PNG, Bitmap, JPEG, Radiance,
|
||
TIFF and GIF formats.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-sha
|
||
(package
|
||
(name "ghc-sha")
|
||
(version "1.6.4.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"SHA/SHA-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
|
||
(home-page "https://hackage.haskell.org/package/SHA")
|
||
(synopsis "SHA suite of message digest functions")
|
||
(description
|
||
"This library implements the SHA suite of message digest functions,
|
||
according to NIST FIPS 180-2 (with the SHA-224 addendum), as well as the
|
||
SHA-based HMAC routines. The functions have been tested against most of the
|
||
NIST and RFC test vectors for the various functions. While some attention has
|
||
been paid to performance, these do not presently reach the speed of well-tuned
|
||
libraries, like OpenSSL.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-hslua
|
||
(package
|
||
(name "ghc-hslua")
|
||
(version "0.4.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"hslua/hslua-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:configure-flags '("-fsystem-lua")))
|
||
(inputs
|
||
`(("lua" ,lua-5.1)
|
||
("ghc-text" ,ghc-text)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)
|
||
("ghc-hspec-contrib" ,ghc-hspec-contrib)
|
||
("hspec-discover" ,hspec-discover)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
|
||
(home-page "https://hackage.haskell.org/package/hslua")
|
||
(synopsis "Lua language interpreter embedding in Haskell")
|
||
(description
|
||
"The Scripting.Lua module is a wrapper of the Lua language interpreter as
|
||
described in @url{http://www.lua.org/}.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-mime-types
|
||
(package
|
||
(name "ghc-mime-types")
|
||
(version "0.1.0.6")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"mime-types/mime-types-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)))
|
||
(home-page "https://github.com/yesodweb/wai")
|
||
(synopsis "Basic MIME type handling types and functions")
|
||
(description
|
||
"This library provides basic MIME type handling types and functions.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-http-client
|
||
(package
|
||
(name "ghc-http-client")
|
||
(version "0.4.24")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"http-client/http-client-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0xz133kdfiyy2rm6z95bmvjj6y2540xzd86cfmdv9s6kz4p1ir4k"))))
|
||
(build-system haskell-build-system)
|
||
;; Tests require access to the web.
|
||
(arguments `(#:tests? #f))
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("ghc-http-types" ,ghc-http-types)
|
||
("ghc-blaze-builder" ,ghc-blaze-builder)
|
||
("ghc-data-default-class" ,ghc-data-default-class)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-streaming-commons" ,ghc-streaming-commons)
|
||
("ghc-case-insensitive" ,ghc-case-insensitive)
|
||
("ghc-base64-bytestring" ,ghc-base64-bytestring)
|
||
("ghc-cookie" ,ghc-cookie)
|
||
("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-mime-types" ,ghc-mime-types)
|
||
("ghc-network-uri" ,ghc-network-uri)
|
||
("ghc-monad-control" ,ghc-monad-control)
|
||
("ghc-zlib" ,ghc-zlib)
|
||
("ghc-async" ,ghc-async)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "https://github.com/snoyberg/http-client")
|
||
(synopsis "HTTP client engine")
|
||
(description
|
||
"This package provides an HTTP client engine, intended as a base layer
|
||
for more user-friendly packages.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-byteable
|
||
(package
|
||
(name "ghc-byteable")
|
||
(version "0.1.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"byteable/byteable-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/vincenthz/hs-byteable")
|
||
(synopsis "Type class for sequence of bytes")
|
||
(description
|
||
"This package provides an abstract class to manipulate sequence of bytes.
|
||
The use case of this class is abstracting manipulation of types that are just
|
||
wrapping a bytestring with stronger and more meaniful name.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-hourglass
|
||
(package
|
||
(name "ghc-hourglass")
|
||
(version "0.2.9")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"hourglass/hourglass-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1xha17nwzxdjizbcp63d2142c6q051y77facs7xribgcl5iz2m4v"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-old-locale" ,ghc-old-locale)))
|
||
(native-inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
|
||
(home-page "https://github.com/vincenthz/hs-hourglass")
|
||
(synopsis "Simple time-related library for Haskell")
|
||
(description
|
||
"This is a simple time library providing a simple but powerful and
|
||
performant API. The backbone of the library are the @code{Timeable} and
|
||
@code{Time} type classes. Each @code{Timeable} instances can be converted to
|
||
a type that has a @code{Time} instances, and thus are different
|
||
representations of current time.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-pem
|
||
(package
|
||
(name "ghc-pem")
|
||
(version "0.2.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"pem/pem-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-base64-bytestring" ,ghc-base64-bytestring)))
|
||
(native-inputs
|
||
`(("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
|
||
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/vincenthz/hs-pem")
|
||
(synopsis "Privacy Enhanced Mail (PEM) format reader and writer")
|
||
(description
|
||
"This library provides readers and writers for the @dfn{Privacy Enhanced
|
||
Mail} (PEM) format.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-asn1-types
|
||
(package
|
||
(name "ghc-asn1-types")
|
||
(version "0.3.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"asn1-types/asn1-types-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1iif9yrh4mmj249gyvam0zb2vb3jnlz777gahh2z9sx00dsx9rja"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-memory" ,ghc-memory)
|
||
("ghc-hourglass" ,ghc-hourglass)))
|
||
(home-page "https://github.com/vincenthz/hs-asn1-types")
|
||
(synopsis "ASN.1 types for Haskell")
|
||
(description
|
||
"The package provides the standard types for dealing with the ASN.1
|
||
format.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-asn1-encoding
|
||
(package
|
||
(name "ghc-asn1-encoding")
|
||
(version "0.9.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"asn1-encoding/asn1-encoding-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"01ki5msrpccgdbdiaaa5a9zw0icp1hki4hca8qx6hzlp0rcf1mwh"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hourglass" ,ghc-hourglass)
|
||
("ghc-asn1-types" ,ghc-asn1-types)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(native-inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
|
||
(home-page "https://github.com/vincenthz/hs-asn1")
|
||
(synopsis "ASN1 data reader and writer in RAW, BER and DER forms")
|
||
(description
|
||
"This package provides a reader and writer for ASN1 data in raw form with
|
||
supports for high level forms of ASN1 (BER, and DER).")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-asn1-parse
|
||
(package
|
||
(name "ghc-asn1-parse")
|
||
(version "0.9.4")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"asn1-parse/asn1-parse-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"025prsihk5g6rdv9xlfmj0zpa0wa3qjzj5i4ilzvg7f6f3sji8y6"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-asn1-types" ,ghc-asn1-types)
|
||
("ghc-asn1-encoding" ,ghc-asn1-encoding)))
|
||
(home-page "https://github.com/vincenthz/hs-asn1")
|
||
(synopsis "Simple monadic parser for ASN1 stream types")
|
||
(description
|
||
"This package provides a simple monadic parser for ASN1 stream types,
|
||
when ASN1 pattern matching is not convenient.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tasty-kat
|
||
(package
|
||
(name "ghc-tasty-kat")
|
||
(version "0.0.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"tasty-kat/tasty-kat-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
|
||
(home-page "https://github.com/vincenthz/tasty-kat")
|
||
(synopsis "Known Answer Tests (KAT) framework for tasty")
|
||
(description
|
||
"This package provides a @dfn{Known Answer Tests} (KAT) framework for
|
||
tasty.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-cryptonite
|
||
(package
|
||
(name "ghc-cryptonite")
|
||
(version "0.19")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"cryptonite/cryptonite-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1rw5k34vpn4134yrzdhf0rsshsrkixfbv9ap18di2n00z2cw1shw"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-memory" ,ghc-memory)
|
||
("ghc-byteable" ,ghc-byteable)))
|
||
(native-inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-tasty-kat" ,ghc-tasty-kat)))
|
||
(home-page "https://github.com/haskell-crypto/cryptonite")
|
||
(synopsis "Cryptography primitives")
|
||
(description
|
||
"This package is a repository of cryptographic primitives for Haskell.
|
||
It supports a wide range of symmetric ciphers, cryptographic hash functions,
|
||
public key algorithms, key derivation numbers, cryptographic random number
|
||
generators, and more.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-memory
|
||
(package
|
||
(name "ghc-memory")
|
||
(version "0.13")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"memory/memory-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"02l742qxjqy3jw1a347gb7sn7pn7a5qha1vzi2qqbvgafcjn0wyw"))))
|
||
(build-system haskell-build-system)
|
||
(native-inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
|
||
(home-page "https://github.com/vincenthz/hs-memory")
|
||
(synopsis "Memory abstractions for Haskell")
|
||
(description
|
||
"This package provides memory abstractions, such as chunk of memory,
|
||
polymorphic byte array management and manipulation functions. It contains a
|
||
polymorphic byte array abstraction and functions similar to strict ByteString,
|
||
different type of byte array abstraction, raw memory IO operations (memory
|
||
set, memory copy, ..) and more")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-x509
|
||
(package
|
||
(name "ghc-x509")
|
||
(version "1.6.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"x509/x509-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1pmsby29abn485fvnymsgipvb3p1ch9c591xj5ncszkf0ivjiiin"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-memory" ,ghc-memory)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-hourglass" ,ghc-hourglass)
|
||
("ghc-pem" ,ghc-pem)
|
||
("ghc-asn1-types" ,ghc-asn1-types)
|
||
("ghc-asn1-encoding" ,ghc-asn1-encoding)
|
||
("ghc-asn1-parse" ,ghc-asn1-parse)
|
||
("ghc-cryptonite" ,ghc-cryptonite)))
|
||
(native-inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
|
||
(home-page "https://github.com/vincenthz/hs-certificate")
|
||
(synopsis "X509 reader and writer")
|
||
(description
|
||
"This library provides functions to read and write X509 certificates.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-x509-store
|
||
(package
|
||
(name "ghc-x509-store")
|
||
(version "1.6.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"x509-store/x509-store-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"01abx528i9f7djq2772xyna8x2mykrnwqkcfrapcx7z3bhprvml3"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-pem" ,ghc-pem)
|
||
("ghc-asn1-types" ,ghc-asn1-types)
|
||
("ghc-asn1-encoding" ,ghc-asn1-encoding)
|
||
("ghc-cryptonite" ,ghc-cryptonite)
|
||
("ghc-x509" ,ghc-x509)))
|
||
(home-page "https://github.com/vincenthz/hs-certificate")
|
||
(synopsis "X.509 collection accessing and storing methods")
|
||
(description
|
||
"This package provides functions for accessing and storing X.509
|
||
collections, certificates, revocation lists, and exception lists.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-x509-validation
|
||
(package
|
||
(name "ghc-x509-validation")
|
||
(version "1.6.3")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"x509-validation/x509-validation-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1qr1v561hdlhjgqjv9pj9mbk0q1xf2mr1j67ghy93nlxxyzd7dw0"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-memory" ,ghc-memory)
|
||
("ghc-byteable" ,ghc-byteable)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-hourglass" ,ghc-hourglass)
|
||
("ghc-data-default-class" ,ghc-data-default-class)
|
||
("ghc-pem" ,ghc-pem)
|
||
("ghc-asn1-types" ,ghc-asn1-types)
|
||
("ghc-asn1-encoding" ,ghc-asn1-encoding)
|
||
("ghc-x509" ,ghc-x509)
|
||
("ghc-x509-store" ,ghc-x509-store)
|
||
("ghc-cryptonite" ,ghc-cryptonite)))
|
||
(home-page "https://github.com/vincenthz/hs-certificate")
|
||
(synopsis "X.509 certificate and revocation list validation")
|
||
(description
|
||
"This package provides functions for X.509 certificate and revocation
|
||
list validation.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-x509-system
|
||
(package
|
||
(name "ghc-x509-system")
|
||
(version "1.6.1")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"x509-system/x509-system-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"10qf60d2f9jqwnbrhsb2cwpi86xg66m6dxndlxw967v1cdb3h6gf"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-pem" ,ghc-pem)
|
||
("ghc-x509" ,ghc-x509)
|
||
("ghc-x509-store" ,ghc-x509-store)))
|
||
(home-page "https://github.com/vincenthz/hs-certificate")
|
||
(synopsis "Handle system X.509 accessors and storage")
|
||
(description
|
||
"This package provides a library to handle system accessors and storage
|
||
for X.509 certificates.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tls
|
||
(package
|
||
(name "ghc-tls")
|
||
(version "1.3.8")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"tls/tls-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1rdidf18i781c0vdvy9yn79yh08hmcacf6fp3sgghyiy3h0wyh5l"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-cereal" ,ghc-cereal)
|
||
("ghc-data-default-class" ,ghc-data-default-class)
|
||
("ghc-memory" ,ghc-memory)
|
||
("ghc-cryptonite" ,ghc-cryptonite)
|
||
("ghc-asn1-types" ,ghc-asn1-types)
|
||
("ghc-asn1-encoding" ,ghc-asn1-encoding)
|
||
("ghc-x509" ,ghc-x509)
|
||
("ghc-x509-store" ,ghc-x509-store)
|
||
("ghc-x509-validation" ,ghc-x509-validation)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-hourglass" ,ghc-hourglass)))
|
||
(native-inputs
|
||
`(("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/vincenthz/hs-tls")
|
||
(synopsis
|
||
"TLS/SSL protocol native implementation (Server and Client)")
|
||
(description
|
||
"Native Haskell TLS and SSL protocol implementation for server and client.
|
||
This provides a high-level implementation of a sensitive security protocol,
|
||
eliminating a common set of security issues through the use of the advanced
|
||
type system, high level constructions and common Haskell features. Currently
|
||
implement the SSL3.0, TLS1.0, TLS1.1 and TLS1.2 protocol, and support RSA and
|
||
Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many
|
||
extensions.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-socks
|
||
(package
|
||
(name "ghc-socks")
|
||
(version "0.5.4")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"socks/socks-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1nmldlwxqasmg359i2aa3a903gi3lmnlspvf12xk49jrg3mf3dg9"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-cereal" ,ghc-cereal)
|
||
("ghc-network" ,ghc-network)))
|
||
(home-page "https://github.com/vincenthz/hs-socks")
|
||
(synopsis "SOCKS proxy (version 5) implementation")
|
||
(description
|
||
"This library provides a SOCKS proxy (version 5) implementation.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-connection
|
||
(package
|
||
(name "ghc-connection")
|
||
(version "0.2.5")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"connection/connection-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"090il95jnm7ihwvcx3s9v6iwnp37nnsdx15q7722l845g51d95c8"))))
|
||
(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-http-client-tls
|
||
(package
|
||
(name "ghc-http-client-tls")
|
||
(version "0.2.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"http-client-tls/http-client-tls-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0a01r05h5fxswyn6k6cgqgak4scqjan72hyy5wbdqzzhl4rmh7j5"))))
|
||
(build-system haskell-build-system)
|
||
;; Tests require Internet access
|
||
(arguments `(#:tests? #f))
|
||
(inputs
|
||
`(("ghc-data-default-class" ,ghc-data-default-class)
|
||
("ghc-http-client" ,ghc-http-client)
|
||
("ghc-connection" ,ghc-connection)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-tls" ,ghc-tls)
|
||
("ghc-http-types" ,ghc-http-types)))
|
||
(native-inputs
|
||
`(("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "https://github.com/snoyberg/http-client")
|
||
(synopsis "Backend for http-client using the TLS library")
|
||
(description
|
||
"This package provides a backend for the http-client package using the
|
||
connection and TLS libraries. It is intended for use by higher-level
|
||
libraries, such as http-conduit.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-pandoc
|
||
(package
|
||
(name "ghc-pandoc")
|
||
(version "1.17.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1v78zq12p71gq0pc24h08inxcq5gxd0xb7m5ds0xw9pv9l2pswl1"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-syb" ,ghc-syb)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-parsec" ,ghc-parsec)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-zip-archive" ,ghc-zip-archive)
|
||
("ghc-http" ,ghc-http)
|
||
("ghc-texmath" ,ghc-texmath)
|
||
("ghc-xml" ,ghc-xml)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
|
||
("ghc-pandoc-types" ,ghc-pandoc-types)
|
||
("ghc-aeson" ,ghc-aeson)
|
||
("ghc-tagsoup" ,ghc-tagsoup)
|
||
("ghc-base64-bytestring" ,ghc-base64-bytestring)
|
||
("ghc-zlib" ,ghc-zlib)
|
||
("ghc-highlighting-kate" ,ghc-highlighting-kate)
|
||
("ghc-data-default" ,ghc-data-default)
|
||
("ghc-temporary" ,ghc-temporary)
|
||
("ghc-blaze-html" ,ghc-blaze-html)
|
||
("ghc-blaze-markup" ,ghc-blaze-markup)
|
||
("ghc-yaml" ,ghc-yaml)
|
||
("ghc-scientific" ,ghc-scientific)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-hslua" ,ghc-hslua)
|
||
("ghc-sha" ,ghc-sha)
|
||
("ghc-haddock-library" ,ghc-haddock-library)
|
||
("ghc-old-time" ,ghc-old-time)
|
||
("ghc-deepseq-generics" ,ghc-deepseq-generics)
|
||
("ghc-juicypixels" ,ghc-juicypixels)
|
||
("ghc-filemanip" ,ghc-filemanip)
|
||
("ghc-cmark" ,ghc-cmark)
|
||
("ghc-network-uri" ,ghc-network-uri)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-http-client" ,ghc-http-client)
|
||
("ghc-http-client-tls" ,ghc-http-client-tls)
|
||
("ghc-http-types" ,ghc-http-types)
|
||
("ghc-diff" ,ghc-diff)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-executable-path" ,ghc-executable-path)))
|
||
(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-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hunit" ,ghc-hunit)))
|
||
(home-page "http://pandoc.org")
|
||
(synopsis "Conversion between markup formats")
|
||
(description
|
||
"Pandoc is a Haskell library for converting from one markup format to
|
||
another, and a command-line tool that uses this library. It can read and
|
||
write Markdown and (subsets of) other formats, such as HTML, reStructuredText,
|
||
LaTeX, DocBook, and many more.
|
||
|
||
Pandoc extends standard Markdown syntax with footnotes, embedded LaTeX,
|
||
definition lists, tables, and other features. A compatibility mode is
|
||
provided for those who need a drop-in replacement for Markdown.pl.")
|
||
(license license:gpl2+)))
|
||
|
||
(define-public ghc-union-find
|
||
(package
|
||
(name "ghc-union-find")
|
||
(version "0.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/union-find/union-find-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/nominolo/union-find")
|
||
(synopsis "Efficient union and equivalence testing of sets")
|
||
(description
|
||
"The Union/Find algorithm implements these operations in (effectively)
|
||
constant-time:
|
||
@enumerate
|
||
@item Check whether two elements are in the same equivalence class.
|
||
@item Create a union of two equivalence classes.
|
||
@item Look up the descriptor of the equivalence class.
|
||
@end enumerate\n")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public idris
|
||
(package
|
||
(name "idris")
|
||
(version "0.9.19.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/idris-"
|
||
version "/idris-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"10641svdsjlxbxmbvylpia04cz5nn9486lpiay8ibqcrc1792qgc"))
|
||
(modules '((guix build utils)))
|
||
(snippet
|
||
'(substitute* "idris.cabal"
|
||
;; Package description file has a too-tight version restriction,
|
||
;; rendering it incompatible with GHC 7.10.2. This is fixed
|
||
;; upstream. See
|
||
;; <https://github.com/idris-lang/Idris-dev/issues/2734>.
|
||
(("vector < 0.11") "vector < 0.12")))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:phases (modify-phases %standard-phases
|
||
(add-before 'configure 'patch-cc-command
|
||
(lambda _
|
||
(setenv "CC" "gcc"))))))
|
||
(inputs
|
||
`(("gmp" ,gmp)
|
||
("ncurses" ,ncurses)
|
||
("ghc-annotated-wl-pprint" ,ghc-annotated-wl-pprint)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)
|
||
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
|
||
("ghc-base64-bytestring" ,ghc-base64-bytestring)
|
||
("ghc-blaze-html" ,ghc-blaze-html)
|
||
("ghc-blaze-markup" ,ghc-blaze-markup)
|
||
("ghc-cheapskate" ,ghc-cheapskate)
|
||
("ghc-fingertree" ,ghc-fingertree)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-network" ,ghc-network)
|
||
("ghc-optparse-applicative" ,ghc-optparse-applicative)
|
||
("ghc-parsers" ,ghc-parsers)
|
||
("ghc-safe" ,ghc-safe)
|
||
("ghc-split" ,ghc-split)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-trifecta" ,ghc-trifecta)
|
||
("ghc-uniplate" ,ghc-uniplate)
|
||
("ghc-unordered-containers" ,ghc-unordered-containers)
|
||
("ghc-utf8-string" ,ghc-utf8-string)
|
||
("ghc-vector-binary-instances" ,ghc-vector-binary-instances)
|
||
("ghc-vector" ,ghc-vector)
|
||
("ghc-zip-archive" ,ghc-zip-archive)
|
||
("ghc-zlib" ,ghc-zlib)))
|
||
(home-page "http://www.idris-lang.org")
|
||
(synopsis "General purpose language with full dependent types")
|
||
(description "Idris is a general purpose language with full dependent
|
||
types. It is compiled, with eager evaluation. Dependent types allow types to
|
||
be predicated on values, meaning that some aspects of a program's behaviour
|
||
can be specified precisely in the type. The language is closely related to
|
||
Epigram and Agda.")
|
||
(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 "http://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-binary
|
||
(package
|
||
(name "ghc-binary")
|
||
(version "0.8.4.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/binary/binary-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1fp7wxnf57cjzhbb7rgqs6fgws4690zh0dxgl924dj4nzq0cf4wd"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-random" ,ghc-random)
|
||
("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hunit" ,ghc-hunit)))
|
||
(home-page "https://github.com/kolmodin/binary")
|
||
(synopsis
|
||
"Binary serialisation for Haskell values using lazy ByteStrings")
|
||
(description
|
||
"Efficient, pure binary serialisation using lazy ByteStrings. Haskell values
|
||
may be encoded to and from binary formats, written to disk as binary, or sent over
|
||
the network. The format used can be automatically generated, or you can choose to
|
||
implement a custom format if needed. Serialisation speeds of over 1 G\\/sec have
|
||
been observed, so this library should be suitable for high performance scenarios.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-cryptohash
|
||
(package
|
||
(name "ghc-cryptohash")
|
||
(version "0.11.9")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/cryptohash/cryptohash-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1yr2iyb779znj79j3fq4ky8l1y8a600a2x1fx9p5pmpwq5zq93y2"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-byteable" ,ghc-byteable)
|
||
("ghc-cryptonite" ,ghc-cryptonite)
|
||
("ghc-memory" ,ghc-memory)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
|
||
(home-page "http://github.com/vincenthz/hs-cryptohash")
|
||
(synopsis "Collection of cryptographic hashes in Haskell")
|
||
(description
|
||
"A collection of crypto hashes, with a practical incremental and one-pass,
|
||
pure APIs, with performance close to the fastest implementations available in
|
||
other languages. The implementations are made in C with a haskell FFI wrapper
|
||
that hides the C implementation.")
|
||
(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 "http://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-haskeline
|
||
(package
|
||
(name "ghc-haskeline")
|
||
(version "0.7.2.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/haskeline/haskeline-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"09wd6sxgn65xxpk7dhy1cg3ywlbk0ccqq7xylycwk4zazy3gjgkd"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ncurses" ,ncurses)))
|
||
(arguments
|
||
`(#:configure-flags (list "-fterminfo")))
|
||
(home-page "https://github.com/judah/haskeline")
|
||
(synopsis "Command-line interface for user input")
|
||
(description
|
||
"Haskeline provides a user interface for line input in command-line
|
||
programs. This library is similar in purpose to readline, but since it
|
||
is written in Haskell it is (hopefully) more easily used in other Haskell
|
||
programs.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-regex-applicative
|
||
(package
|
||
(name "ghc-regex-applicative")
|
||
(version "0.3.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/regex-applicative/"
|
||
"regex-applicative-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1riv7jqf26lbv4rm54sd6mrx8xdh4dvh4xbzymzdfdw13k6a4nb6"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-smallcheck" ,ghc-smallcheck)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
|
||
(home-page "https://github.com/feuerbach/regex-applicative")
|
||
(synopsis "Regex-based parsing with applicative interface")
|
||
(description
|
||
"@code{regex-applicative} is a Haskell library for parsing using
|
||
regular expressions. Parsers can be built using Applicative interface.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-regex-tdfa
|
||
(package
|
||
(name "ghc-regex-tdfa")
|
||
(version "1.2.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/regex-tdfa/regex-tdfa-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0f8x8wyr6m21g8dnxvnvalz5bsq37l125l6qhs0fscbvprsxc4nb"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-parsec" ,ghc-parsec)
|
||
("ghc-regex-base" ,ghc-regex-base)))
|
||
(home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
|
||
(synopsis "POSIX extended regular expressions in Haskell.")
|
||
(description
|
||
"Regex-tdfa is a pure Haskell regular expression library implementing POSIX
|
||
extended regular expressions. It is a \"tagged\" DFA regex engine. It is
|
||
inspired by libtre.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-regex-compat-tdfa
|
||
(package
|
||
(name "ghc-regex-compat-tdfa")
|
||
(version "0.95.1.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/regex-compat-tdfa/regex-compat-tdfa-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-regex-base" ,ghc-regex-base)
|
||
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
|
||
(home-page "http://hub.darcs.net/shelarcy/regex-compat-tdfa")
|
||
(synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
|
||
(description
|
||
"One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
|
||
@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
|
||
This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
|
||
this problem.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tasty-th
|
||
(package
|
||
(name "ghc-tasty-th")
|
||
(version "0.1.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tasty-th/tasty-th-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-tasty" ,ghc-tasty)))
|
||
(home-page "http://github.com/bennofs/tasty-th")
|
||
(synopsis "Automatically generate tasty TestTrees")
|
||
(description
|
||
"Tasty-th automatically generates tasty TestTrees from functions of the
|
||
current module, using TemplateHaskell. This is a fork the original
|
||
test-framework-th package, modified to work with tasty instead of
|
||
test-framework.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-sandi
|
||
(package
|
||
(name "ghc-sandi")
|
||
(version "0.4.0") ; darcs-2.12.4 needs == 0.4.*
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/sandi/sandi-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1smf3bq44qni4zbgxpw7cy7b9g95fbrr73j8njjf6139naj9bj20"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-stringsearch" ,ghc-stringsearch)
|
||
("ghc-conduit" ,ghc-conduit)
|
||
("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-tasty-th" ,ghc-tasty-th)))
|
||
(home-page "http://hackage.haskell.org/package/sandi")
|
||
(synopsis "Data encoding library")
|
||
(description "Reasonably fast data encoding library.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-bytestring-handle
|
||
(package
|
||
(name "ghc-bytestring-handle")
|
||
(version "0.1.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/bytestring-handle/bytestring-handle-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0q5yzx90ad9w7qvaix05bynxwlsbqjrgfc4hqb355ibf991wd0rh"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
|
||
("ghc-test-framework" ,ghc-test-framework)))
|
||
(home-page "http://hub.darcs.net/ganesh/bytestring-handle")
|
||
(synopsis "ByteString-backed Handles")
|
||
(description "ByteString-backed Handles") ; There is no description
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-tar
|
||
(package
|
||
(name "ghc-tar")
|
||
(version "0.5.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/tar/tar-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"18qq94j9bm91iswnxq2dm5dws5c7wm4k01q2rpf8py35cf3svnfq"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-bytestring-handle" ,ghc-bytestring-handle)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
|
||
("ghc-array" ,ghc-array)))
|
||
(home-page "http://hackage.haskell.org/package/tar")
|
||
(synopsis "Reading, writing and manipulating \".tar\" archive files")
|
||
(description
|
||
"This library is for working with \\\"@.tar@\\\" archive files.
|
||
It can read and write a range of common variations of the tar archive format
|
||
including V7, POSIX USTAR and GNU formats. It provides support for packing and
|
||
unpacking portable archives. This makes it suitable for distribution but not
|
||
backup because details like file ownership and exact permissions are not
|
||
preserved. It also provides features for random access to archive content using
|
||
an index.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-transformers
|
||
(package
|
||
(name "ghc-transformers")
|
||
(version "0.5.2.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/transformers/transformers-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1qkhi8ssf8c4jnmrw9dzym3igqbzq7h48iisaykdfzdsm09qfh3c"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://hackage.haskell.org/package/transformers")
|
||
(synopsis "Concrete functor and monad transformers")
|
||
(description
|
||
"A portable library of functor and monad transformers, inspired by the paper
|
||
'Functional Programming with Overloading and Higher-Order Polymorphism',
|
||
by Mark P Jones. This package contains the monad transformer class and IO monad class,
|
||
concrete functor and monad transformers, each with associated operations and functions
|
||
to lift operations associated with other transformers. The package can be used on
|
||
its own in portable Haskell code, in which case operations need to be manually lifted
|
||
through transformer stacks. Alternatively, it can be used with the
|
||
non-portable monad classes in the @code{mtl} or @code{monads-tf} packages,
|
||
which automatically lift operations introduced by monad transformers through
|
||
other transformers.")
|
||
(license license:bsd-3)))
|
||
|
||
;; darcs-2.12.0 requires transformers-0.4.2.0
|
||
(define-public ghc-transformers-0.4.2.0
|
||
(package
|
||
(inherit ghc-transformers)
|
||
(version "0.4.2.0")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/transformers/"
|
||
"transformers-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0a364zfcm17mhpy0c4ms2j88sys4yvgd6071qsgk93la2wjm8mkr"))))))
|
||
|
||
(define-public ghc-findbin
|
||
(package
|
||
(name "ghc-findbin")
|
||
(version "0.0.5")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/FindBin/FindBin-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "https://github.com/audreyt/findbin")
|
||
(synopsis "Get the absolute path of the running program")
|
||
(description
|
||
"This module locates the full directory of the running program, to allow
|
||
the use of paths relative to it. FindBin supports invocation of Haskell
|
||
programs via \"ghci\", via \"runhaskell/runghc\", as well as compiled as
|
||
an executable.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-patience
|
||
(package
|
||
(name "ghc-patience")
|
||
(version "0.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/patience/patience-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://hackage.haskell.org/package/patience")
|
||
(synopsis "Patience diff and longest increasing subsequence")
|
||
(description
|
||
"This library implements the 'patience diff' algorithm, as well as the
|
||
patience algorithm for the longest increasing subsequence problem.
|
||
Patience diff computes the difference between two lists, for example the lines
|
||
of two versions of a source file. It provides a good balance between
|
||
performance, nice output for humans, and simplicity of implementation.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-monads-tf
|
||
(package
|
||
(name "ghc-monads-tf")
|
||
(version "0.1.0.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/monads-tf/monads-tf-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://hackage.haskell.org/package/monads-tf")
|
||
(synopsis "Monad classes, using type families")
|
||
(description
|
||
"Monad classes using type families, with instances for various monad transformers,
|
||
inspired by the paper 'Functional Programming with Overloading and Higher-Order
|
||
Polymorphism', by Mark P Jones. This package is almost a compatible replacement for
|
||
the @code{mtl-tf} package.")
|
||
(license license:bsd-3)))
|
||
|
||
;; Do not use this. Bytestring is a standard library and always included.
|
||
(define-public ghc-bytestring
|
||
(package
|
||
(name "ghc-bytestring")
|
||
(version "0.10.8.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/bytestring/bytestring-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"16zwb1p83z7vc5wlhvknpy80b5a2jxc5awx67rk52qnp9idmyq9d"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-random" ,ghc-random)
|
||
("ghc-test-framework" ,ghc-test-framework)
|
||
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-byteorder" ,ghc-byteorder)
|
||
("ghc-dlist" ,ghc-dlist)
|
||
("ghc-mtl" ,ghc-mtl)))
|
||
(arguments
|
||
`(#:tests? #f)) ; Test number two becomes non-responsive for 20+ minutes
|
||
(home-page "https://github.com/haskell/bytestring")
|
||
(synopsis "Fast, compact, strict and lazy byte strings with a list interface")
|
||
(description
|
||
"An efficient compact, immutable byte string type (both strict and lazy)
|
||
suitable for binary or 8-bit character data. The 'ByteString' type represents
|
||
sequences of bytes or 8-bit characters. It is suitable for high performance use,
|
||
both in terms of large data quantities, or high speed requirements. The 'ByteString'
|
||
functions follow the same style as ordinary lists, so it is easy to convert code
|
||
from using 'String' to 'ByteString'.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-colour
|
||
(package
|
||
(name "ghc-colour")
|
||
(version "2.3.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/colour/colour-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://www.haskell.org/haskellwiki/Colour")
|
||
(synopsis "Model for human colour perception")
|
||
(description
|
||
"This package provides a data type for colours and transparency.
|
||
Colours can be blended and composed. Various colour spaces are
|
||
supported. A module of colour names (\"Data.Colour.Names\") is provided.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-directory
|
||
(package
|
||
(name "ghc-directory")
|
||
(version "1.2.7.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/directory/directory-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0h3hrqskadmbigaxbz2k5xxjjjlmfaq2zdn2g7jh1wv9k6yrxraa"))))
|
||
(build-system haskell-build-system)
|
||
(home-page "http://hackage.haskell.org/package/directory")
|
||
(synopsis "Platform-agnostic library for filesystem operations")
|
||
(description
|
||
"This library provides a basic set of operations for manipulating
|
||
files and directories in a portable way.")
|
||
(license license:bsd-3)))
|
||
|
||
;; Do not use this as an input. It is part of GHC.
|
||
(define-public ghc-process
|
||
(package
|
||
(name "ghc-process")
|
||
(version "1.4.2.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/process/process-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1v1bav5isqxq9fc4lw714x94qbfsjbm2nn12kjp69r1ql8jaaaqw"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:phases
|
||
(modify-phases %standard-phases
|
||
(add-after 'unpack 'patch-reference-to-/bin/sh
|
||
(lambda _
|
||
(substitute* "System/Process/Posix.hs"
|
||
(("/bin/sh") (which "sh")))
|
||
#t)))))
|
||
(home-page "http://hackage.haskell.org/package/process")
|
||
(synopsis "System process libraries")
|
||
(description
|
||
"This package contains libraries for dealing with system processes.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-wl-pprint-text
|
||
(package
|
||
(name "ghc-wl-pprint-text")
|
||
(version "1.1.0.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/wl-pprint-text/wl-pprint-text-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1xgizzimfw17mpmw2afvmnvyag976j8ggn7k5r564rkw9f0m6bgz"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)))
|
||
(home-page "http://hackage.haskell.org/package/wl-pprint-text")
|
||
(synopsis "Wadler/Leijen Pretty Printer for Text values")
|
||
(description
|
||
"A clone of wl-pprint for use with the text library.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-fgl-arbitrary
|
||
(package
|
||
(name "ghc-fgl-arbitrary")
|
||
(version "0.2.0.2")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/fgl-arbitrary/fgl-arbitrary-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"12qbsla4vivffris6y3gj29vrafkpyazqdbdy2m55nggypqpf7ah"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-fgl" ,ghc-fgl)
|
||
("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "http://hackage.haskell.org/package/fgl-arbitrary")
|
||
(synopsis "QuickCheck support for fgl")
|
||
(description
|
||
"Provides Arbitrary instances for fgl graphs to avoid adding a
|
||
QuickCheck dependency for fgl whilst still making the instances
|
||
available to others. Also available are non-fgl-specific functions
|
||
for generating graph-like data structures.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-graphviz
|
||
(package
|
||
(name "ghc-graphviz")
|
||
(version "2999.18.1.2")
|
||
(source (origin
|
||
(method url-fetch)
|
||
(uri (string-append "https://hackage.haskell.org/package/"
|
||
"graphviz/graphviz-" version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1z453is01v0rnxlv6xx4iyaqv5vrp3bpz829mpv1a341sck2135h"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-quickcheck" ,ghc-quickcheck)
|
||
("ghc-colour" ,ghc-colour)
|
||
("ghc-dlist" ,ghc-dlist)
|
||
("ghc-fgl" ,ghc-fgl)
|
||
("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
|
||
("ghc-polyparse" ,ghc-polyparse)
|
||
("ghc-temporary" ,ghc-temporary)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
|
||
(home-page "https://hackage.haskell.org/package/graphviz")
|
||
(synopsis "Bindings to Graphviz for graph visualisation")
|
||
(description
|
||
"This library provides bindings for the Dot language used by
|
||
the @uref{http://graphviz.org/, Graphviz} suite of programs for
|
||
visualising graphs, as well as functions to call those programs.
|
||
Main features of the graphviz library include:
|
||
|
||
@enumerate
|
||
@item Almost complete coverage of all Graphviz attributes and syntax
|
||
@item Support for specifying clusters
|
||
@item The ability to use a custom node type
|
||
@item Functions for running a Graphviz layout tool with all specified output types
|
||
@item Generate and parse Dot code with two options: strict and liberal
|
||
@item Functions to convert FGL graphs and other graph-like data structures
|
||
@item Round-trip support for passing an FGL graph through Graphviz to augment node
|
||
and edge labels with positional information, etc.
|
||
@end enumerate\n")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-array
|
||
(package
|
||
(name "ghc-array")
|
||
(version "0.5.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/array/array-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"08r2rq4blvc737mrg3xhlwiw13jmsz5dlf2fd0ghb9cdaxc6kjc9"))))
|
||
(build-system haskell-build-system)
|
||
(home-page
|
||
"http://hackage.haskell.org/package/array")
|
||
(synopsis "Mutable and immutable arrays")
|
||
(description
|
||
"In addition to providing the @code{Data.Array} module, this package also defines
|
||
the classes @code{IArray} of immutable arrays and @code{MArray} of arrays mutable
|
||
within appropriate monads, as well as some instances of these classes.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-constraints
|
||
(package
|
||
(name "ghc-constraints")
|
||
(version "0.8")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/constraints/constraints-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"120mmv9rwbahslisc1z8zx9lw7v6hl5fzid4l0hiy5as6ijqgl2c"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-hashable" ,ghc-hashable)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-transformers-compat" ,ghc-transformers-compat)))
|
||
(home-page "http://github.com/ekmett/constraints/")
|
||
(synopsis "Constraint manipulation")
|
||
(description
|
||
"GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
|
||
They stopped crashing the compiler in GHC 7.6. This package provides
|
||
a vocabulary for working with them.")
|
||
(license license:bsd-3)))
|
||
|
||
(define-public ghc-lifted-async
|
||
(package
|
||
(name "ghc-lifted-async")
|
||
(version "0.9.0")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/lifted-async/lifted-async-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"00fnwfcnc6niq9jbbb9rap9rkdgv5qhcglwanzc5fi8834j94c1r"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-async" ,ghc-async)
|
||
("ghc-lifted-base" ,ghc-lifted-base)
|
||
("ghc-transformers-base" ,ghc-transformers-base)
|
||
("ghc-monad-control" ,ghc-monad-control)
|
||
("ghc-constraints" ,ghc-constraints)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-mtl" ,ghc-mtl)
|
||
("ghc-tasty" ,ghc-tasty)
|
||
("ghc-tasty-hunit" ,ghc-tasty-hunit)
|
||
("ghc-tasty-th" ,ghc-tasty-th)))
|
||
(home-page "https://github.com/maoe/lifted-async")
|
||
(synopsis "Run lifted IO operations asynchronously and wait for their results")
|
||
(description
|
||
"This package provides IO operations from @code{async} package lifted to any
|
||
instance of @code{MonadBase} or @code{MonadBaseControl}.")
|
||
(license license:bsd-3)))
|
||
|
||
;; Ghc-shelly depends on ghc-system-filepath and ghc-system-fileio, who in turn depend on
|
||
;; ghc-chell and ghc-chell-quickcheck for the test phase. Ghc-chell depends on ghc-options
|
||
;; which depends on ghc-chell and ghc-chell-quickcheck.
|
||
;; Therefore we bootstrap it with tests disabled.
|
||
(define ghc-system-filepath-bootstrap
|
||
(package
|
||
(name "ghc-system-filepath-bootstrap")
|
||
(version "0.4.13.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/system-filepath/system-filepath-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f))
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/fpco/haskell-filesystem")
|
||
(synopsis "High-level, byte-based file and directory path manipulations")
|
||
(description
|
||
"Provides a FilePath datatype and utility functions for operating on it.
|
||
Unlike the filepath package, this package does not simply reuse String,
|
||
increasing type safety.")
|
||
(license license:expat)))
|
||
|
||
;; See ghc-system-filepath-bootstrap. In addition this package depends on
|
||
;; ghc-system-filepath.
|
||
(define ghc-system-fileio-bootstrap
|
||
(package
|
||
(name "ghc-system-fileio-bootstrap")
|
||
(version "0.3.16.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/system-fileio/system-fileio-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f))
|
||
(inputs
|
||
`(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-temporary" ,ghc-temporary)))
|
||
(home-page "https://github.com/fpco/haskell-filesystem")
|
||
(synopsis "Consistent filesystem interaction across GHC versions")
|
||
(description
|
||
"This is a small wrapper around the directory, unix, and Win32 packages,
|
||
for use with system-filepath. It provides a consistent API to the various
|
||
versions of these packages distributed with different versions of GHC.
|
||
In particular, this library supports working with POSIX files that have paths
|
||
which can't be decoded in the current locale encoding.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-shelly
|
||
(package
|
||
(name "ghc-shelly")
|
||
(version "1.6.8")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/shelly/shelly-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0bg1pj5bhswfgwfgz66xr82i8cmjgrnx5ljvjy37052zxb82imnk"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-mtl" ,ghc-mtl)
|
||
("ghc-unix-compat" ,ghc-unix-compat)
|
||
("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
|
||
("ghc-system-fileio-bootstrap" ,ghc-system-fileio-bootstrap)
|
||
("ghc-monad-control" ,ghc-monad-control)
|
||
("ghc-lifted-base" ,ghc-lifted-base)
|
||
("ghc-lifted-async" ,ghc-lifted-async)
|
||
("ghc-exceptions" ,ghc-exceptions)
|
||
("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-async" ,ghc-async)
|
||
("ghc-transformers-base" ,ghc-transformers-base)
|
||
("ghc-hunit" ,ghc-hunit)
|
||
("ghc-hspec" ,ghc-hspec)))
|
||
(home-page "https://github.com/yesodweb/Shelly.hs")
|
||
(synopsis "Shell-like (systems) programming in Haskell")
|
||
(description
|
||
"Shelly provides convenient systems programming in Haskell, similar in
|
||
spirit to POSIX shells. Shelly is originally forked from the Shellish package.")
|
||
(license license:bsd-3)))
|
||
|
||
;; See ghc-system-filepath-bootstrap, chell and chell-quickcheck are required for tests.
|
||
(define ghc-options-bootstrap
|
||
(package
|
||
(name "ghc-options-bootstrap")
|
||
(version "1.2.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/options/options-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
|
||
(build-system haskell-build-system)
|
||
(arguments
|
||
`(#:tests? #f))
|
||
(inputs
|
||
`(("ghc-monads-tf" ,ghc-monads-tf)))
|
||
(home-page "https://john-millikin.com/software/haskell-options/")
|
||
(synopsis "Powerful and easy-to-use command-line option parser")
|
||
(description
|
||
"The @code{options} package lets library and application developers
|
||
easily work with command-line options.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-chell
|
||
(package
|
||
(name "ghc-chell")
|
||
(version "0.4.0.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/chell/chell-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0lb95abzxl4a87nfqxsxpb3a39pd52cci43hcvj8615hyhqvs2jz"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-options-bootstrap" ,ghc-options-bootstrap)
|
||
("ghc-patience" ,ghc-patience)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-ansi-terminal" ,ghc-ansi-terminal)))
|
||
(home-page "https://john-millikin.com/software/chell/")
|
||
(synopsis "Simple and intuitive library for automated testing")
|
||
(description
|
||
"Chell is a simple and intuitive library for automated testing.
|
||
It natively supports assertion-based testing, and can use companion
|
||
libraries such as @code{chell-quickcheck} to support more complex
|
||
testing strategies.")
|
||
(license license:expat)))
|
||
|
||
(define ghc-chell-quickcheck-bootstrap
|
||
(package
|
||
(name "ghc-chell-quickcheck-bootstrap")
|
||
(version "0.2.5")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/chell-quickcheck/chell-quickcheck-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-chell" ,ghc-chell)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(arguments
|
||
`(#:tests? #f))
|
||
(home-page "https://john-millikin.com/software/chell/")
|
||
(synopsis "QuickCheck support for the Chell testing library")
|
||
(description "More complex tests for @code{chell}.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-chell-quickcheck
|
||
(package
|
||
(name "ghc-chell-quickcheck")
|
||
(version "0.2.5")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/chell-quickcheck/chell-quickcheck-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-chell" ,ghc-chell)
|
||
("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap)
|
||
("ghc-random" ,ghc-random)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://john-millikin.com/software/chell/")
|
||
(synopsis "QuickCheck support for the Chell testing library")
|
||
(description "More complex tests for @code{chell}.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-options
|
||
(package
|
||
(name "ghc-options")
|
||
(version "1.2.1.1")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/options/options-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-monads-tf" ,ghc-monads-tf)
|
||
("ghc-chell" ,ghc-chell)
|
||
("ghc-chell-quickcheck" ,ghc-chell-quickcheck)))
|
||
(home-page "https://john-millikin.com/software/haskell-options/")
|
||
(synopsis "Powerful and easy-to-use command-line option parser")
|
||
(description
|
||
"The @code{options} package lets library and application developers
|
||
easily work with command-line options.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-system-filepath
|
||
(package
|
||
(name "ghc-system-filepath")
|
||
(version "0.4.13.4")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/system-filepath/system-filepath-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-text" ,ghc-text)
|
||
("ghc-chell" ,ghc-chell)
|
||
("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
|
||
("ghc-quickcheck" ,ghc-quickcheck)))
|
||
(home-page "https://github.com/fpco/haskell-filesystem")
|
||
(synopsis "High-level, byte-based file and directory path manipulations")
|
||
(description
|
||
"Provides a FilePath datatype and utility functions for operating on it.
|
||
Unlike the filepath package, this package does not simply reuse String,
|
||
increasing type safety.")
|
||
(license license:expat)))
|
||
|
||
(define-public ghc-system-fileio
|
||
(package
|
||
(name "ghc-system-fileio")
|
||
(version "0.3.16.3")
|
||
(source
|
||
(origin
|
||
(method url-fetch)
|
||
(uri (string-append
|
||
"https://hackage.haskell.org/package/system-fileio/system-fileio-"
|
||
version ".tar.gz"))
|
||
(sha256
|
||
(base32
|
||
"1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
|
||
(build-system haskell-build-system)
|
||
(inputs
|
||
`(("ghc-system-filepath" ,ghc-system-filepath)
|
||
("ghc-text" ,ghc-text)
|
||
("ghc-chell" ,ghc-chell)
|
||
("ghc-temporary" ,ghc-temporary)))
|
||
(home-page "https://github.com/fpco/haskell-filesystem")
|
||
(synopsis "Consistent filesystem interaction across GHC versions")
|
||
(description
|
||
"This is a small wrapper around the directory, unix, and Win32 packages,
|
||
for use with system-filepath. It provides a consistent API to the various
|
||
versions of these packages distributed with different versions of GHC.
|
||
In particular, this library supports working with POSIX files that have paths
|
||
which can't be decoded in the current locale encoding.")
|
||
(license license:expat)))
|
||
;;; haskell.scm ends here
|