1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
3 ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
4 ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
5 ;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
7 ;;; This file is part of GNU Guix.
9 ;;; GNU Guix is free software; you can redistribute it and/or modify it
10 ;;; under the terms of the GNU General Public License as published by
11 ;;; the Free Software Foundation; either version 3 of the License, or (at
12 ;;; your option) any later version.
14 ;;; GNU Guix is distributed in the hope that it will be useful, but
15 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;;; GNU General Public License for more details.
19 ;;; You should have received a copy of the GNU General Public License
20 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
22 (define-module (gnu packages haskell)
23 #:use-module (ice-9 regex)
24 #:use-module ((guix licenses) #:select (bsd-3
25 lgpl2.1 lgpl2.1+ gpl2+ gpl3+
28 #:use-module (guix packages)
29 #:use-module (guix download)
30 #:use-module (guix utils)
31 #:use-module (guix build-system gnu)
32 #:use-module (guix build-system haskell)
33 #:use-module (gnu packages pkg-config)
34 #:use-module (gnu packages perl)
35 #:use-module (gnu packages compression)
36 #:use-module (gnu packages elf)
37 #:use-module (gnu packages gl)
38 #:use-module (gnu packages sdl)
39 #:use-module (gnu packages bootstrap)
40 #:use-module (gnu packages zip)
41 #:use-module (gnu packages gcc)
42 #:use-module (gnu packages ghostscript)
43 #:use-module (gnu packages libffi)
44 #:use-module (gnu packages libedit)
45 #:use-module (gnu packages multiprecision)
46 #:use-module (gnu packages ncurses)
47 #:use-module (gnu packages python)
48 #:use-module (gnu packages pcre)
49 #:use-module ((gnu packages xml) #:select (libxml2))
50 #:use-module (gnu packages xorg))
52 (define ghc-bootstrap-x86_64-7.8.4
56 "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-x86_64-unknown-linux-deb7.tar.xz")
59 "13azsl53xgj20mi1hj9x0xb32vvcvs6cpmvwx6znxhas7blh0bpn"))))
61 (define ghc-bootstrap-i686-7.8.4
65 "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-i386-unknown-linux-deb7.tar.xz")
68 "0wj5s435j0zgww70bj1d3f6wvnnpzlxwvwcyh2qv4qjq5z8j64kg"))))
70 ;; 43 tests out of 3965 fail.
72 ;; Most of them do not appear to be serious:
74 ;; - some tests generate files referring to "/bin/sh" and "/bin/ls". I've not
75 ;; figured out how these references are generated.
77 ;; - Some tests allocate more memory than expected (ca. 3% above upper limit)
79 ;; - Some tests try to load unavailable libriries: Control.Concurrent.STM,
80 ;; Data.Vector, Control.Monad.State.
82 ;; - Test posix010 tries to check the existence of a user on the system:
83 ;; getUserEntryForName: does not exist (no such user)
91 (uri (string-append "https://www.haskell.org/ghc/dist/"
92 version "/" name "-" version "-src.tar.xz"))
95 "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal"))))
96 (build-system gnu-build-system)
97 (supported-systems '("i686-linux" "x86_64-linux"))
98 (outputs '("out" "doc"))
108 "https://www.haskell.org/ghc/dist/"
109 version "/" name "-" version "-testsuite.tar.xz"))
112 "0qp9da9ar87zbyn6wjgacd2ic1vgzbi3cklxnhsmjqyafv9qaj4b"))))))
115 ("python" ,python-2) ; for tests (fails with python-3)
116 ("ghostscript" ,ghostscript) ; for tests
117 ("patchelf" ,patchelf)
118 ;; GHC is built with GHC. Therefore we need bootstrap binaries.
120 ,(if (string-match "x86_64" (or (%current-target-system) (%current-system)))
121 ghc-bootstrap-x86_64-7.8.4
122 ghc-bootstrap-i686-7.8.4))))
124 `(#:test-target "test"
125 ;; We get a smaller number of test failures by disabling parallel test
129 ;; The DSOs use $ORIGIN to refer to each other, but (guix build
130 ;; gremlin) doesn't support it yet, so skip this phase.
131 #:validate-runpath? #f
133 ;; Don't pass --build=<triplet>, because the configure script
134 ;; auto-detects slightly different triplets for --host and --target and
135 ;; then complains that they don't match.
138 #:modules ((guix build gnu-build-system)
143 #:imported-modules (,@%gnu-build-system-modules
147 (string-append "--with-gmp-libraries="
148 (assoc-ref %build-inputs "gmp") "/lib")
149 (string-append "--with-gmp-includes="
150 (assoc-ref %build-inputs "gmp") "/include")
151 "--with-system-libffi"
152 (string-append "--with-ffi-libraries="
153 (assoc-ref %build-inputs "libffi") "/lib")
154 (string-append "--with-ffi-includes="
155 (assoc-ref %build-inputs "libffi") "/include"))
156 ;; FIXME: The user-guide needs dblatex, docbook-xsl and docbook-utils.
157 ;; Currently we do not have the last one.
159 ;; (list "BUILD_DOCBOOK_HTML = YES")
161 (let* ((ghc-bootstrap-path
162 (string-append (getcwd) "/" ,name "-" ,version "/ghc-bin"))
163 (ghc-bootstrap-prefix
164 (string-append ghc-bootstrap-path "/usr" )))
166 'unpack-bin 'unpack-testsuite-and-fix-bins
167 (lambda* (#:key inputs outputs #:allow-other-keys)
168 (with-directory-excursion ".."
169 (copy-file (assoc-ref inputs "ghc-testsuite")
170 "ghc-testsuite.tar.xz")
171 (system* "tar" "xvf" "ghc-testsuite.tar.xz"))
173 (list "testsuite/timeout/Makefile"
174 "testsuite/timeout/timeout.py"
175 "testsuite/timeout/timeout.hs"
176 "testsuite/tests/rename/prog006/Setup.lhs"
177 "testsuite/tests/programs/life_space_leak/life.test"
178 "libraries/process/System/Process/Internals.hs"
179 "libraries/unix/cbits/execvpe.c")
180 (("/bin/sh") (which "sh"))
185 (lambda* (#:key inputs outputs #:allow-other-keys)
186 (mkdir-p ghc-bootstrap-prefix)
187 (with-directory-excursion ghc-bootstrap-path
188 (copy-file (assoc-ref inputs "ghc-binary")
190 (zero? (system* "tar" "xvf" "ghc-bin.tar.xz"))))
192 'install-bin 'configure-bin
193 (lambda* (#:key inputs outputs #:allow-other-keys)
196 "./utils/ghc-pwd/dist-install/build/tmp/ghc-pwd"
197 "./utils/hpc/dist-install/build/tmp/hpc"
198 "./utils/haddock/dist/build/tmp/haddock"
199 "./utils/hsc2hs/dist-install/build/tmp/hsc2hs"
200 "./utils/runghc/dist-install/build/tmp/runghc"
201 "./utils/ghc-cabal/dist-install/build/tmp/ghc-cabal"
202 "./utils/hp2ps/dist/build/tmp/hp2ps"
203 "./utils/ghc-pkg/dist-install/build/tmp/ghc-pkg"
204 "./utils/unlit/dist/build/tmp/unlit"
205 "./ghc/stage2/build/tmp/ghc-stage2"))
206 (gmp (assoc-ref inputs "gmp"))
207 (gmp-lib (string-append gmp "/lib"))
208 (gmp-include (string-append gmp "/include"))
210 (string-append (assoc-ref inputs "ncurses") "/lib"))
211 (ld-so (string-append (assoc-ref inputs "libc")
212 ,(glibc-dynamic-linker)))
214 (string-append ghc-bootstrap-prefix
215 "/lib/ghc-7.8.4/terminfo-0.4.0.0")))
216 (with-directory-excursion
217 (string-append ghc-bootstrap-path "/ghc-7.8.4")
218 (setenv "CONFIG_SHELL" (which "bash"))
219 (setenv "LD_LIBRARY_PATH" gmp-lib)
220 ;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded.
222 (cut system* "patchelf" "--set-interpreter" ld-so <>)
224 ;; The binaries include a reference to libtinfo.so.5 which
225 ;; is a subset of libncurses.so.5. We create a symlink in a
226 ;; directory included in the bootstrap binaries rpath.
227 (mkdir-p libtinfo-dir)
229 (string-append ncurses-lib "/libncursesw.so."
230 ,(version-major+minor
231 (package-version ncurses)))
232 (string-append libtinfo-dir "/libtinfo.so.5"))
234 (string-append (getenv "PATH") ":"
235 ghc-bootstrap-prefix "/bin"))
237 (string-append (getcwd) "/configure")
238 (string-append "--prefix=" ghc-bootstrap-prefix)
239 (string-append "--with-gmp-libraries=" gmp-lib)
240 (string-append "--with-gmp-includes=" gmp-include)))))
242 'configure 'install-bin
243 (lambda* (#:key inputs outputs #:allow-other-keys)
244 (with-directory-excursion
245 (string-append ghc-bootstrap-path "/ghc-7.8.4")
246 (zero? (system* "make" "install"))))
247 %standard-phases)))))))
248 (home-page "https://www.haskell.org/ghc")
249 (synopsis "The Glasgow Haskell Compiler")
251 "The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
252 interactive environment for the functional language Haskell.")
255 (define-public ghc-hostname
257 (name "ghc-hostname")
262 (uri (string-append "http://hackage.haskell.org/package/hostname/"
263 "hostname-" version ".tar.gz"))
266 "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
267 (build-system haskell-build-system)
268 (home-page "https://hackage.haskell.org/package/hostname")
269 (synopsis "Hostname in Haskell")
270 (description "Network.HostName is a simple package providing a means to
271 determine the hostname.")
274 (define-public ghc-libxml
281 (uri (string-append "http://hackage.haskell.org/package/libxml/"
282 "libxml-" version ".tar.gz"))
285 "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
286 (build-system haskell-build-system)
288 `(("ghc-mtl" ,ghc-mtl)
289 ("libxml2" ,libxml2)))
292 `(,(string-append "--extra-include-dirs="
293 (assoc-ref %build-inputs "libxml2")
294 "/include/libxml2"))))
295 (home-page "http://hackage.haskell.org/package/libxml")
296 (synopsis "Haskell bindings to libxml2")
298 "This library provides minimal Haskell binding to libxml2.")
301 (define-public ghc-prelude-extras
303 (name "ghc-prelude-extras")
309 "http://hackage.haskell.org/package/prelude-extras/prelude-extras-"
314 "1q7mj9hysy747vimnlyrwsk1wb2axymxixa76fwcbcnmz3fi4llp"))))
315 (build-system haskell-build-system)
316 (home-page "http://github.com/ekmett/prelude-extras")
317 (synopsis "Higher order versions of Prelude classes")
318 (description "This library provides higher order versions of
319 @code{Prelude} classes to ease programming with polymorphic recursion and
320 reduce @code{UndecidableInstances}.")
323 (define-public ghc-data-default
325 (name "ghc-data-default")
331 "http://hackage.haskell.org/package/data-default/data-default-"
335 (base32 "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c"))))
336 (build-system haskell-build-system)
338 `(("ghc-data-default-class"
339 ,ghc-data-default-class)
340 ("ghc-data-default-instances-base"
341 ,ghc-data-default-instances-base)
342 ("ghc-data-default-instances-containers"
343 ,ghc-data-default-instances-containers)
344 ("ghc-data-default-instances-dlist"
345 ,ghc-data-default-instances-dlist)
346 ("ghc-data-default-instances-old-locale"
347 ,ghc-data-default-instances-old-locale)))
348 (home-page "http://hackage.haskell.org/package/data-default")
349 (synopsis "Types with default values")
351 "This package defines a class for types with a default value, and
352 provides instances for types from the base, containers, dlist and old-locale
356 (define-public ghc-data-default-class
358 (name "ghc-data-default-class")
364 "http://hackage.haskell.org/package/data-default-class/"
365 "data-default-class-" version ".tar.gz"))
367 (base32 "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d"))))
368 (build-system haskell-build-system)
369 (home-page "http://hackage.haskell.org/package/data-default-class")
370 (synopsis "Types with default values")
372 "This package defines a class for types with default values.")
375 (define-public ghc-data-default-instances-base
377 (name "ghc-data-default-instances-base")
383 "http://hackage.haskell.org/package/"
384 "data-default-instances-base/"
385 "data-default-instances-base-" version ".tar.gz"))
387 (base32 "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb"))))
388 (build-system haskell-build-system)
390 `(("ghc-data-default-class" ,ghc-data-default-class)))
391 (home-page "http://hackage.haskell.org/package/data-default-instances-base")
392 (synopsis "Default instances for types in base")
394 "This package provides default instances for types from the base
398 (define-public ghc-data-default-instances-containers
400 (name "ghc-data-default-instances-containers")
406 "http://hackage.haskell.org/package/"
407 "data-default-instances-containers/"
408 "data-default-instances-containers-" version ".tar.gz"))
410 (base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
411 (build-system haskell-build-system)
413 `(("ghc-data-default-class" ,ghc-data-default-class)))
414 (home-page "http://hackage.haskell.org/package/data-default-instances-containers")
415 (synopsis "Default instances for types in containers")
416 (description "Provides default instances for types from the containers
420 (define-public ghc-data-default-instances-dlist
422 (name "ghc-data-default-instances-dlist")
428 "http://hackage.haskell.org/package/"
429 "data-default-instances-dlist/"
430 "data-default-instances-dlist-" version ".tar.gz"))
432 (base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
433 (build-system haskell-build-system)
435 `(("ghc-data-default-class" ,ghc-data-default-class)
436 ("ghc-dlist" ,ghc-dlist)))
437 (home-page "http://hackage.haskell.org/package/data-default-instances-dlist")
438 (synopsis "Default instances for types in dlist")
439 (description "Provides default instances for types from the dlist
443 (define-public ghc-haddock-library
445 (name "ghc-haddock-library")
451 "http://hackage.haskell.org/package/haddock-library/haddock-library-"
456 "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g"))))
457 (build-system haskell-build-system)
459 `(("ghc-base-compat" ,ghc-base-compat)
460 ("ghc-hspec" ,ghc-hspec)
461 ("ghc-quickcheck" ,ghc-quickcheck)))
462 (home-page "http://www.haskell.org/haddock/")
464 "Library exposing some functionality of Haddock")
466 "Haddock is a documentation-generation tool for Haskell libraries. These
467 modules expose some functionality of it without pulling in the GHC dependency.
468 Please note that the API is likely to change so specify upper bounds in your
469 project if you can't release often. For interacting with Haddock itself, see
470 the ‘haddock’ package.")
473 (define-public ghc-haddock-api
475 (name "ghc-haddock-api")
481 "http://hackage.haskell.org/package/haddock-api/haddock-api-"
486 "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2"))))
487 (build-system haskell-build-system)
489 `(("ghc-paths" ,ghc-paths)
490 ("ghc-haddock-library" ,ghc-haddock-library)))
491 (home-page "http://www.haskell.org/haddock/")
492 (synopsis "API for documentation-generation tool Haddock")
493 (description "This package provides an API to Haddock, the
494 documentation-generation tool for Haskell libraries.")
497 (define-public ghc-haddock
505 "http://hackage.haskell.org/package/haddock/haddock-"
510 "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26"))))
511 (build-system haskell-build-system)
512 (arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed
514 ; <https://github.com/haskell/haddock/issues/427>
515 (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
516 (home-page "http://www.haskell.org/haddock/")
518 "Documentation-generation tool for Haskell libraries")
520 "Haddock is a documentation-generation tool for Haskell libraries.")
523 (define-public ghc-simple-reflect
525 (name "ghc-simple-reflect")
531 "http://hackage.haskell.org/package/simple-reflect/simple-reflect-"
536 "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq"))))
537 (build-system haskell-build-system)
539 "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
541 "Simple reflection of expressions containing variables")
543 "This package allows simple reflection of expressions containing
544 variables. Reflection here means that a Haskell expression is turned into a
545 string. The primary aim of this package is teaching and understanding; there
546 are no options for manipulating the reflected expressions beyond showing
550 (define-public ghc-multipart
552 (name "ghc-multipart")
558 "http://hackage.haskell.org/package/multipart/multipart-"
563 "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
564 (build-system haskell-build-system)
565 (inputs `(("ghc-parsec" ,ghc-parsec)))
567 "http://www.github.com/silkapp/multipart")
569 "HTTP multipart library")
571 "HTTP multipart split out of the cgi package, for Haskell.")
574 (define-public ghc-html
582 "http://hackage.haskell.org/package/html/html-"
587 "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
588 (build-system haskell-build-system)
590 "http://hackage.haskell.org/package/html")
591 (synopsis "HTML combinator library")
593 "This package contains a combinator library for constructing HTML
597 (define-public ghc-xhtml
605 "http://hackage.haskell.org/package/xhtml/xhtml-"
610 "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
611 (build-system haskell-build-system)
612 (home-page "https://github.com/haskell/xhtml")
613 (synopsis "XHTML combinator library")
615 "This package provides combinators for producing XHTML 1.0, including the
616 Strict, Transitional and Frameset variants.")
619 (define-public ghc-haskell-src
621 (name "ghc-haskell-src")
627 "http://hackage.haskell.org/package/haskell-src/haskell-src-"
632 "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a"))))
633 (build-system haskell-build-system)
635 `(("ghc-happy" ,ghc-happy)
636 ("ghc-syb" ,ghc-syb)))
638 "http://hackage.haskell.org/package/haskell-src")
640 "Support for manipulating Haskell source code")
642 "The 'haskell-src' package provides support for manipulating Haskell
643 source code. The package provides a lexer, parser and pretty-printer, and a
644 definition of a Haskell abstract syntax tree (AST). Common uses of this
645 package are to parse or generate Haskell 98 code.")
648 (define-public ghc-alex
656 "http://hackage.haskell.org/package/alex/alex-"
661 "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn"))))
662 (build-system haskell-build-system)
663 (arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10. Fixed
665 ; <https://github.com/simonmar/alex/issues/62>
666 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
667 (home-page "http://www.haskell.org/alex/")
669 "Tool for generating lexical analysers in Haskell")
671 "Alex is a tool for generating lexical analysers in Haskell. It takes a
672 description of tokens based on regular expressions and generates a Haskell
673 module containing code for scanning text efficiently. It is similar to the
674 tool lex or flex for C/C++.")
677 (define-public ghc-cgi
680 (version "3001.2.2.2")
685 "http://hackage.haskell.org/package/cgi/cgi-"
690 "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193"))))
691 (build-system haskell-build-system)
693 `(("ghc-parsec" ,ghc-parsec)
694 ("ghc-old-locale" ,ghc-old-locale)
695 ("ghc-old-time" ,ghc-old-time)
696 ("ghc-exceptions" ,ghc-exceptions)
697 ("ghc-multipart" ,ghc-multipart)
698 ("ghc-network-uri" ,ghc-network-uri)
699 ("ghc-network" ,ghc-network)
700 ("ghc-mtl" ,ghc-mtl)))
702 "https://github.com/cheecheeo/haskell-cgi")
703 (synopsis "Library for writing CGI programs")
705 "This is a Haskell library for writing CGI programs.")
708 (define-public ghc-cmdargs
716 "http://hackage.haskell.org/package/cmdargs/cmdargs-"
721 "0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6"))))
722 (build-system haskell-build-system)
724 "http://community.haskell.org/~ndm/cmdargs/")
725 (synopsis "Command line argument processing")
727 "This library provides an easy way to define command line parsers.")
730 (define-public ghc-happy
738 "http://hackage.haskell.org/package/happy/happy-"
743 "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32"))))
744 (build-system haskell-build-system)
745 (arguments `(#:tests? #f)) ;; cannot satisfy -package mtl. Possible Cabal
748 `(("ghc-mtl" ,ghc-mtl)))
749 (home-page "https://hackage.haskell.org/package/happy")
750 (synopsis "Parser generator for Haskell")
751 (description "Happy is a parser generator for Haskell. Given a grammar
752 specification in BNF, Happy generates Haskell code to parse the grammar.
753 Happy works in a similar way to the yacc tool for C.")
756 (define-public ghc-haskell-src-exts
758 (name "ghc-haskell-src-exts")
764 "http://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
769 "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz"))))
770 (build-system haskell-build-system)
774 ("ghc-happy" ,ghc-happy)
775 ("ghc-syb" ,ghc-syb)))
777 `(("ghc-smallcheck" ,ghc-smallcheck)
778 ("ghc-tasty" ,ghc-tasty)
779 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
780 ("ghc-tasty-golden" ,ghc-tasty-golden)))
781 (home-page "https://github.com/haskell-suite/haskell-src-exts")
782 (synopsis "Library for manipulating Haskell source")
783 (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
784 extension of the standard @code{haskell-src} package, and handles most
785 registered syntactic extensions to Haskell. All extensions implemented in GHC
786 are supported. Apart from these standard extensions, it also handles regular
787 patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
798 "http://hackage.haskell.org/package/" name
799 "/" name "-" version ".tar.gz"))
802 "14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546"))))
803 (build-system haskell-build-system)
806 ("ghc-cmdargs" ,ghc-cmdargs)
807 ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
808 ("ghc-uniplate" ,ghc-uniplate)
809 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
810 ("ghc-extra" ,ghc-extra)
811 ("hscolour" ,hscolour)))
812 (home-page "http://community.haskell.org/~ndm/hlint/")
813 (synopsis "Suggest improvements for Haskell source code")
814 (description "HLint reads Haskell programs and suggests changes that
815 hopefully make them easier to read. HLint also makes it easy to disable
816 unwanted suggestions, and to add your own custom suggestions.")
819 (define-public ghc-resourcet
821 (name "ghc-resourcet")
827 "http://hackage.haskell.org/package/resourcet/resourcet-"
832 "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y"))))
833 (build-system haskell-build-system)
835 `(("ghc-transformers-base" ,ghc-transformers-base)
836 ("ghc-monad-control" ,ghc-monad-control)
837 ("ghc-transformers-compat" ,ghc-transformers-compat)
839 ("ghc-mmorph" ,ghc-mmorph)
840 ("ghc-exceptions" ,ghc-exceptions)))
842 `(("ghc-lifted-base" ,ghc-lifted-base)
843 ("ghc-hspec" ,ghc-hspec)))
844 (home-page "http://github.com/snoyberg/conduit")
845 (synopsis "Deterministic allocation and freeing of scarce resources")
846 (description "ResourceT is a monad transformer which creates a region of
847 code where you can safely allocate resources.")
850 (define-public ghc-xss-sanitize
852 (name "ghc-xss-sanitize")
858 "http://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
863 "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
864 (build-system haskell-build-system)
866 `(("ghc-tagsoup" ,ghc-tagsoup)
867 ("ghc-utf8-string" ,ghc-utf8-string)
868 ("ghc-css-text" ,ghc-css-text)
869 ("ghc-network-uri" ,ghc-network-uri)))
871 `(("ghc-text" ,ghc-text)
872 ("ghc-attoparsec" ,ghc-attoparsec)
873 ("ghc-hspec" ,ghc-hspec)
874 ("ghc-hunit" ,ghc-hunit)))
875 (home-page "http://github.com/yesodweb/haskell-xss-sanitize")
876 (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
877 (description "This library provides @code{sanitizeXSS}. Run untrusted
878 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
882 (define-public ghc-objectname
884 (name "ghc-objectname")
890 "http://hackage.haskell.org/package/ObjectName/ObjectName-"
895 "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg"))))
896 (build-system haskell-build-system)
897 (home-page "https://hackage.haskell.org/package/ObjectName")
898 (synopsis "Helper library for Haskell OpenGL")
899 (description "This tiny package contains the class ObjectName, which
900 corresponds to the general notion of explicitly handled identifiers for API
901 objects, e.g. a texture object name in OpenGL or a buffer object name in
905 (define-public ghc-sdl
913 "http://hackage.haskell.org/package/SDL/SDL-"
918 "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46"))))
919 (build-system haskell-build-system)
922 (home-page "https://hackage.haskell.org/package/SDL")
923 (synopsis "LibSDL for Haskell")
924 (description "Simple DirectMedia Layer (libSDL) is a cross-platform
925 multimedia library designed to provide low level access to audio, keyboard,
926 mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
927 by MPEG playback software, emulators, and many popular games, including the
928 award winning Linux port of \"Civilization: Call To Power.\"")
931 (define-public ghc-sdl-mixer
933 (name "ghc-sdl-mixer")
939 "http://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
944 "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z"))))
945 (build-system haskell-build-system)
948 (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
949 (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
950 (list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
952 `(("ghc-sdl" ,ghc-sdl)))
954 `(("sdl-mixer" ,sdl-mixer)))
955 (home-page "http://hackage.haskell.org/package/SDL-mixer")
956 (synopsis "Haskell bindings to libSDL_mixer")
957 (description "SDL_mixer is a sample multi-channel audio mixer library. It
958 supports any number of simultaneously playing channels of 16 bit stereo audio,
959 plus a single channel of music, mixed by the popular MikMod MOD, Timidity
960 MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
963 (define-public ghc-sdl-image
965 (name "ghc-sdl-image")
971 "http://hackage.haskell.org/package/SDL-image/SDL-image-"
976 "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq"))))
977 (build-system haskell-build-system)
980 (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
981 (sdl-image-include (string-append sdl-image "/include/SDL")))
982 (list (string-append "--extra-include-dirs=" sdl-image-include)))))
984 `(("ghc-sdl" ,ghc-sdl)))
986 `(("sdl-image" ,sdl-image)))
987 (home-page "http://hackage.haskell.org/package/SDL-image")
988 (synopsis "Haskell bindings to libSDL_image")
989 (description "SDL_image is an image file loading library. It loads images
990 as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
991 PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
994 (define-public ghc-half
1002 "http://hackage.haskell.org/package/half/half-"
1007 "0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1"))))
1008 (build-system haskell-build-system)
1009 (home-page "http://github.com/ekmett/half")
1010 (synopsis "Half-precision floating-point computations")
1011 (description "This library provides a half-precision floating-point
1012 computation library for Haskell.")
1015 (define-public ghc-openglraw
1017 (name "ghc-openglraw")
1023 "http://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
1028 "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k"))))
1029 (build-system haskell-build-system)
1031 `(("ghc-half" ,ghc-half)
1033 ("ghc-text" ,ghc-text)))
1034 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1035 (synopsis "Raw Haskell bindings for the OpenGL graphics system")
1036 (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
1037 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
1038 of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
1039 offers access to all necessary functions, tokens and types plus a general
1040 facility for loading extension entries. The module hierarchy closely mirrors
1041 the naming structure of the OpenGL extensions, making it easy to find the
1042 right module to import. All API entries are loaded dynamically, so no special
1043 C header files are needed for building this package. If an API entry is not
1044 found at runtime, a userError is thrown.")
1047 (define-public ghc-glut
1055 "http://hackage.haskell.org/package/GLUT/GLUT-"
1060 "1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2"))))
1061 (build-system haskell-build-system)
1063 `(("ghc-statevar" ,ghc-statevar)
1064 ("ghc-openglraw" ,ghc-openglraw)
1065 ("freeglut" ,freeglut)))
1067 `(("ghc-opengl" ,ghc-opengl)))
1068 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1069 (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
1070 (description "This library provides Haskell bindings for the OpenGL
1071 Utility Toolkit, a window system-independent toolkit for writing OpenGL
1075 (define-public ghc-gluraw
1083 "http://hackage.haskell.org/package/GLURaw/GLURaw-"
1088 "0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x"))))
1089 (build-system haskell-build-system)
1091 `(("ghc-openglraw" ,ghc-openglraw)))
1092 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1093 (synopsis "Raw Haskell bindings GLU")
1094 (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
1095 utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
1096 basis for a nicer interface.")
1099 (define-public ghc-opengl
1102 (version "2.12.0.1")
1107 "http://hackage.haskell.org/package/OpenGL/OpenGL-"
1112 "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b"))))
1113 (build-system haskell-build-system)
1115 `(("ghc-text" ,ghc-text)
1116 ("ghc-objectname" ,ghc-objectname)
1117 ("ghc-gluraw" ,ghc-gluraw)
1118 ("ghc-statevar" ,ghc-statevar)
1119 ("ghc-openglraw" ,ghc-openglraw)))
1120 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1121 (synopsis "Haskell bindings for the OpenGL graphics system")
1122 (description "This package provides Haskell bindings for the OpenGL
1123 graphics system (GL, version 4.5) and its accompanying utility library (GLU,
1127 (define-public ghc-streaming-commons
1129 (name "ghc-streaming-commons")
1130 (version "0.1.14.2")
1135 "http://hackage.haskell.org/package/streaming-commons/streaming-commons-"
1140 "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
1141 (build-system haskell-build-system)
1143 `(("ghc-random" ,ghc-random)))
1145 `(("ghc-quickcheck" ,ghc-quickcheck)
1146 ("ghc-async" ,ghc-async)
1147 ("ghc-blaze-builder" ,ghc-blaze-builder)
1148 ("ghc-hspec" ,ghc-hspec)
1149 ("ghc-stm" ,ghc-stm)
1150 ("ghc-text" ,ghc-text)
1151 ("ghc-network" ,ghc-network)
1152 ("ghc-zlib" ,ghc-zlib)))
1153 (home-page "https://hackage.haskell.org/package/streaming-commons")
1154 (synopsis "Conduit and pipes needed by some streaming data libraries")
1155 (description "Provides low-dependency functionality commonly needed by
1156 various Haskell streaming data libraries, such as @code{conduit} and
1160 (define-public cpphs
1168 "http://hackage.haskell.org/package/" name "/"
1169 name "-" version ".tar.gz"))
1172 "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
1173 (build-system haskell-build-system)
1175 `(("ghc-polyparse" ,ghc-polyparse)
1176 ("ghc-old-locale" ,ghc-old-locale)
1177 ("ghc-old-time" ,ghc-old-time)))
1178 (home-page "http://projects.haskell.org/cpphs/")
1179 (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
1180 (description "Cpphs is a re-implementation of the C pre-processor that is
1181 both more compatible with Haskell, and itself written in Haskell so that it
1182 can be distributed with compilers. This version of the C pre-processor is
1183 pretty-much feature-complete and compatible with traditional (K&R)
1184 pre-processors. Additional features include: a plain-text mode; an option to
1185 unlit literate code files; and an option to turn off macro-expansion.")
1186 (license (list lgpl2.1+ gpl3+))))
1188 (define-public ghc-reflection
1190 (name "ghc-reflection")
1196 "http://hackage.haskell.org/package/reflection/reflection-"
1201 "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
1202 (build-system haskell-build-system)
1203 (inputs `(("ghc-tagged" ,ghc-tagged)))
1204 (home-page "http://github.com/ekmett/reflection")
1205 (synopsis "Reify arbitrary terms into types that can be reflected back
1207 (description "This package addresses the 'configuration problem' which is
1208 propogating configurations that are available at run-time, allowing multiple
1209 configurations to coexist without resorting to mutable global variables or
1210 @code{System.IO.Unsafe.unsafePerformIO}.")
1213 (define-public ghc-old-locale
1215 (name "ghc-old-locale")
1221 "http://hackage.haskell.org/package/old-locale/old-locale-"
1225 (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
1226 (build-system haskell-build-system)
1227 (home-page "http://hackage.haskell.org/package/old-locale")
1228 (synopsis "Adapt to locale conventions")
1230 "This package provides the ability to adapt to locale conventions such as
1231 date and time formats.")
1234 (define-public ghc-old-time
1236 (name "ghc-old-time")
1242 "http://hackage.haskell.org/package/old-time/old-time-"
1247 "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
1248 (build-system haskell-build-system)
1250 `(("ghc-old-locale" ,ghc-old-locale)))
1251 (home-page "http://hackage.haskell.org/package/old-time")
1252 (synopsis "Time compatibility library for Haskell")
1253 (description "Old-time is a package for backwards compatibility with the
1254 old @code{time} library. For new projects, the newer
1255 @uref{http://hackage.haskell.org/package/time, time library} is recommended.")
1258 (define-public ghc-data-default-instances-old-locale
1260 (name "ghc-data-default-instances-old-locale")
1266 "http://hackage.haskell.org/package/"
1267 "data-default-instances-old-locale/"
1268 "data-default-instances-old-locale-" version ".tar.gz"))
1270 (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
1271 (build-system haskell-build-system)
1273 `(("ghc-data-default-class" ,ghc-data-default-class)
1274 ("ghc-old-locale" ,ghc-old-locale)))
1276 "http://hackage.haskell.org/package/data-default-instances-old-locale")
1277 (synopsis "Default instances for types in old-locale")
1278 (description "Provides Default instances for types from the old-locale
1282 (define-public ghc-dlist
1290 "http://hackage.haskell.org/package/dlist/dlist-"
1294 (base32 "10rp96rryij7d8gz5kv8ygc6chm1624ck5mbnqs2a3fkdzqj2b9k"))))
1295 (build-system haskell-build-system)
1297 `(("ghc-quickcheck" ,ghc-quickcheck)))
1298 (home-page "https://github.com/spl/dlist")
1299 (synopsis "Difference lists")
1301 "Difference lists are a list-like type supporting O(1) append. This is
1302 particularly useful for efficient logging and pretty printing (e.g. with the
1303 Writer monad), where list append quickly becomes too expensive.")
1306 (define-public ghc-extensible-exceptions
1308 (name "ghc-extensible-exceptions")
1313 (uri (string-append "http://hackage.haskell.org/package/"
1314 "extensible-exceptions/extensible-exceptions-"
1317 (base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
1318 (build-system haskell-build-system)
1319 (home-page "http://hackage.haskell.org/package/extensible-exceptions")
1320 (synopsis "Extensible exceptions for Haskell")
1322 "This package provides extensible exceptions for both new and old
1323 versions of GHC (i.e., < 6.10).")
1326 (define-public cabal-install
1328 (name "cabal-install")
1329 (version "1.22.6.0")
1334 "http://hackage.haskell.org/package/cabal-install/cabal-install-"
1338 (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx"))))
1339 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
1340 (build-system haskell-build-system)
1342 `(("ghc-http" ,ghc-http)
1343 ("ghc-mtl" ,ghc-mtl)
1344 ("ghc-network-uri" ,ghc-network-uri)
1345 ("ghc-network" ,ghc-network)
1346 ("ghc-random" ,ghc-random)
1347 ("ghc-stm" ,ghc-stm)
1348 ("ghc-zlib" ,ghc-zlib)))
1349 (home-page "http://www.haskell.org/cabal/")
1350 (synopsis "Command-line interface for Cabal and Hackage")
1352 "The cabal command-line program simplifies the process of managing
1353 Haskell software by automating the fetching, configuration, compilation and
1354 installation of Haskell libraries and programs.")
1357 (define-public ghc-mtl
1361 (outputs '("out" "doc"))
1366 "http://hackage.haskell.org/package/mtl/mtl-"
1371 "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
1372 (build-system haskell-build-system)
1373 (home-page "http://github.com/ekmett/mtl")
1375 "Monad classes, using functional dependencies")
1376 (description "Monad classes using functional dependencies, with instances
1377 for various monad transformers, inspired by the paper 'Functional Programming
1378 with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced
1379 School of Functional Programming', 1995. See
1380 @uref{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
1383 (define-public ghc-paths
1387 (outputs '("out" "doc"))
1392 "http://hackage.haskell.org/package/ghc-paths/ghc-paths-"
1397 "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
1398 (build-system haskell-build-system)
1399 (home-page "https://github.com/simonmar/ghc-paths")
1401 "Knowledge of GHC's installation directories")
1403 "Knowledge of GHC's installation directories.")
1406 (define-public ghc-utf8-string
1408 (name "ghc-utf8-string")
1414 "http://hackage.haskell.org/package/utf8-string/utf8-string-"
1418 (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
1419 (build-system haskell-build-system)
1420 (home-page "http://github.com/glguy/utf8-string/")
1421 (synopsis "Support for reading and writing UTF8 Strings")
1423 "A UTF8 layer for Strings. The utf8-string package provides operations
1424 for encoding UTF8 strings to Word8 lists and back, and for reading and writing
1425 UTF8 without truncation.")
1428 (define-public ghc-setenv
1436 "http://hackage.haskell.org/package/setenv/setenv-"
1441 "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
1442 (build-system haskell-build-system)
1443 (home-page "http://hackage.haskell.org/package/setenv")
1444 (synopsis "Library for setting environment variables")
1445 (description "This package provides a Haskell library for setting
1446 environment variables.")
1449 (define-public ghc-x11
1456 (uri (string-append "http://hackage.haskell.org/package/X11/"
1457 "X11-" version ".tar.gz"))
1459 (base32 "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj"))))
1460 (build-system haskell-build-system)
1462 `(("libx11" ,libx11)
1463 ("libxrandr" ,libxrandr)
1464 ("libxinerama" ,libxinerama)
1465 ("libxscrnsaver" ,libxscrnsaver)))
1467 `(("ghc-data-default" ,ghc-data-default)))
1468 (home-page "https://github.com/haskell-pkg-janitors/X11")
1469 (synopsis "Bindings to the X11 graphics library")
1471 "This package provides Haskell bindings to the X11 graphics library. The
1472 bindings are a direct translation of the C bindings.")
1475 (define-public ghc-x11-xft
1477 (name "ghc-x11-xft")
1482 (uri (string-append "http://hackage.haskell.org/package/X11-xft/"
1483 "X11-xft-" version ".tar.gz"))
1485 (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
1487 `(("ghc-x11" ,ghc-x11)
1488 ("ghc-utf8-string" ,ghc-utf8-string)))
1490 `(("libx11" ,libx11)
1492 ("xproto" ,xproto)))
1494 `(("pkg-config" ,pkg-config)))
1495 (build-system haskell-build-system)
1496 (home-page "http://hackage.haskell.org/package/X11-xft")
1497 (synopsis "Bindings to Xft")
1499 "Bindings to the Xft, X Free Type interface library, and some Xrender
1503 (define-public ghc-stringbuilder
1505 (name "ghc-stringbuilder")
1511 "http://hackage.haskell.org/package/stringbuilder/stringbuilder-"
1516 "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9"))))
1517 (build-system haskell-build-system)
1518 (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
1520 (home-page "http://hackage.haskell.org/package/stringbuilder")
1521 (synopsis "Writer monad for multi-line string literals")
1522 (description "This package provides a writer monad for multi-line string
1526 (define-public ghc-zlib
1530 (outputs '("out" "doc"))
1535 "http://hackage.haskell.org/package/zlib/zlib-"
1540 "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
1541 (build-system haskell-build-system)
1542 (inputs `(("zlib" ,zlib)))
1543 (home-page "http://hackage.haskell.org/package/zlib")
1545 "Compression and decompression in the gzip and zlib formats")
1547 "This package provides a pure interface for compressing and decompressing
1548 streams of data represented as lazy 'ByteString's. It uses the zlib C library
1549 so it has high performance. It supports the 'zlib', 'gzip' and 'raw'
1550 compression formats. It provides a convenient high level API suitable for
1551 most tasks and for the few cases where more control is needed it provides
1552 access to the full zlib feature set.")
1555 (define-public ghc-stm
1559 (outputs '("out" "doc"))
1564 "http://hackage.haskell.org/package/stm/stm-"
1569 "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
1570 (build-system haskell-build-system)
1571 (home-page "http://hackage.haskell.org/package/stm")
1572 (synopsis "Software Transactional Memory")
1574 "A modular composable concurrency abstraction.")
1577 (define-public ghc-parallel
1579 (name "ghc-parallel")
1581 (outputs '("out" "doc"))
1586 "http://hackage.haskell.org/package/parallel/parallel-"
1591 "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
1592 (build-system haskell-build-system)
1593 (home-page "http://hackage.haskell.org/package/parallel")
1594 (synopsis "Parallel programming library")
1596 "This package provides a library for parallel programming.")
1599 (define-public ghc-text
1603 (outputs '("out" "doc"))
1608 "http://hackage.haskell.org/package/text/text-"
1613 "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq"))))
1614 (build-system haskell-build-system)
1616 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
1617 (home-page "https://github.com/bos/text")
1618 (synopsis "Efficient packed Unicode text type library")
1620 "An efficient packed, immutable Unicode text type (both strict and
1621 lazy), with a powerful loop fusion optimization framework.
1623 The 'Text' type represents Unicode character strings, in a time and
1624 space-efficient manner. This package provides text processing
1625 capabilities that are optimized for performance critical use, both
1626 in terms of large data quantities and high speed.")
1629 (define-public ghc-hashable
1631 (name "ghc-hashable")
1633 (outputs '("out" "doc"))
1638 "http://hackage.haskell.org/package/hashable/hashable-"
1643 "0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw"))))
1644 (build-system haskell-build-system)
1646 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
1647 ;; these inputs are necessary to use this library
1649 `(("ghc-text" ,ghc-text)))
1650 (home-page "http://github.com/tibbe/hashable")
1652 "Class for types that can be converted to a hash value")
1654 "This package defines a class, 'Hashable', for types that can be
1655 converted to a hash value. This class exists for the benefit of hashing-based
1656 data structures. The package provides instances for basic types and a way to
1657 combine hash values.")
1660 (define-public ghc-hunit
1664 (outputs '("out" "doc"))
1669 "http://hackage.haskell.org/package/HUnit/HUnit-"
1674 "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
1675 (build-system haskell-build-system)
1676 (home-page "http://hunit.sourceforge.net/")
1677 (synopsis "Unit testing framework for Haskell")
1679 "HUnit is a unit testing framework for Haskell, inspired by the
1680 JUnit tool for Java.")
1683 (define-public ghc-random
1687 (outputs '("out" "doc"))
1692 "http://hackage.haskell.org/package/random/random-"
1696 (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
1697 (build-system haskell-build-system)
1698 (home-page "http://hackage.haskell.org/package/random")
1699 (synopsis "Random number library")
1700 (description "This package provides a basic random number generation
1701 library, including the ability to split random number generators.")
1704 (define-public ghc-primitive
1706 (name "ghc-primitive")
1708 (outputs '("out" "doc"))
1713 "http://hackage.haskell.org/package/primitive/primitive-"
1718 "1j1q7l21rdm8kfs93vibr3xwkkhqis181w2k6klfhx5g5skiywwk"))))
1719 (build-system haskell-build-system)
1721 "https://github.com/haskell/primitive")
1722 (synopsis "Primitive memory-related operations")
1724 "This package provides various primitive memory-related operations.")
1727 (define-public ghc-test-framework
1729 (name "ghc-test-framework")
1734 (uri (string-append "http://hackage.haskell.org/package/test-framework/"
1735 "test-framework-" version ".tar.gz"))
1738 "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
1739 (build-system haskell-build-system)
1741 `(("ghc-hunit" ,ghc-hunit)
1742 ("ghc-libxml" ,ghc-libxml)
1743 ("ghc-quickcheck" ,ghc-quickcheck)))
1745 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
1746 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
1747 ("ghc-hostname" ,ghc-hostname)
1748 ("ghc-old-locale" ,ghc-old-locale)
1749 ("ghc-random" ,ghc-random)
1750 ("ghc-regex-posix" ,ghc-regex-posix)
1751 ("ghc-xml" ,ghc-xml)))
1752 (home-page "https://batterseapower.github.io/test-framework/")
1753 (synopsis "Framework for running and organising tests")
1755 "This package allows tests such as QuickCheck properties and HUnit test
1756 cases to be assembled into test groups, run in parallel (but reported in
1757 deterministic order, to aid diff interpretation) and filtered and controlled
1758 by command line options. All of this comes with colored test output, progress
1759 reporting and test statistics output.")
1762 (define-public ghc-test-framework-hunit
1764 (name "ghc-test-framework-hunit")
1769 (uri (string-append "http://hackage.haskell.org/package/"
1770 "test-framework-hunit/test-framework-hunit-"
1774 "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
1775 (build-system haskell-build-system)
1777 `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
1778 ("ghc-hunit" ,ghc-hunit)
1779 ("ghc-test-framework" ,ghc-test-framework)))
1780 (home-page "https://batterseapower.github.io/test-framework/")
1781 (synopsis "HUnit support for test-framework")
1783 "This package provides HUnit support for the test-framework package.")
1786 (define-public ghc-test-framework-quickcheck2
1788 (name "ghc-test-framework-quickcheck2")
1793 (uri (string-append "http://hackage.haskell.org/package/"
1794 "test-framework-quickcheck2/"
1795 "test-framework-quickcheck2-" version ".tar.gz"))
1798 "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
1799 (modules '((guix build utils)))
1801 ;; The Hackage page and the cabal file linked there for this package
1802 ;; both list 2.9 as the upper version limit, but the source tarball
1803 ;; specifies 2.8. Assume the Hackage page is correct.
1804 '(substitute* "test-framework-quickcheck2.cabal"
1805 (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
1806 (build-system haskell-build-system)
1808 `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
1809 ("ghc-quickcheck" ,ghc-quickcheck)
1810 ("ghc-random" ,ghc-random)
1811 ("ghc-test-framework" ,ghc-test-framework)))
1812 (home-page "https://batterseapower.github.io/test-framework/")
1813 (synopsis "QuickCheck2 support for test-framework")
1815 "This packages provides QuickCheck2 support for the test-framework
1819 (define-public ghc-tf-random
1821 (name "ghc-tf-random")
1823 (outputs '("out" "doc"))
1828 "http://hackage.haskell.org/package/tf-random/tf-random-"
1832 (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
1833 (build-system haskell-build-system)
1834 ;; these inputs are necessary to use this package
1836 `(("ghc-primitive" ,ghc-primitive)
1837 ("ghc-random" ,ghc-random)))
1838 (home-page "http://hackage.haskell.org/package/tf-random")
1839 (synopsis "High-quality splittable pseudorandom number generator")
1840 (description "This package contains an implementation of a high-quality
1841 splittable pseudorandom number generator. The generator is based on a
1842 cryptographic hash function built on top of the ThreeFish block cipher. See
1843 the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
1844 Hashing\" by Claessen, Pałka for details and the rationale of the design.")
1847 (define-public ghc-transformers-base
1849 (name "ghc-transformers-base")
1855 "http://hackage.haskell.org/package/transformers-base/transformers-base-"
1860 "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va"))))
1861 (build-system haskell-build-system)
1863 `(("ghc-stm" ,ghc-stm)))
1865 `(("ghc-transformers-compat" ,ghc-transformers-compat)))
1867 "http://hackage.haskell.org/package/transformers-compat")
1869 "Backported transformer library")
1871 "Backported versions of types that were added to transformers in
1872 transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
1873 compatibility to run on old versions of the platform.")
1876 (define-public ghc-transformers-compat
1878 (name "ghc-transformers-compat")
1884 "http://hackage.haskell.org/package/transformers-compat"
1885 "/transformers-compat-" version ".tar.gz"))
1888 "0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym"))))
1889 (build-system haskell-build-system)
1890 (home-page "http://github.com/ekmett/transformers-compat/")
1891 (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
1892 (description "This package includes backported versions of types that were
1893 added to transformers in transformers 0.3 and 0.4 for users who need strict
1894 transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
1895 but also need those types.")
1898 (define-public ghc-unix-time
1900 (name "ghc-unix-time")
1906 "http://hackage.haskell.org/package/unix-time/unix-time-"
1911 "0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax"))))
1912 (build-system haskell-build-system)
1914 `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
1915 ; is weird, that should be provided by GHC 7.10.2.
1917 `(("ghc-old-time" ,ghc-old-time)
1918 ("ghc-old-locale" ,ghc-old-locale)))
1919 (home-page "http://hackage.haskell.org/package/unix-time")
1920 (synopsis "Unix time parser/formatter and utilities")
1921 (description "This library provides fast parsing and formatting utilities
1922 for Unix time in Haskell.")
1925 (define-public ghc-unix-compat
1927 (name "ghc-unix-compat")
1933 "http://hackage.haskell.org/package/unix-compat/unix-compat-"
1938 "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps"))))
1939 (build-system haskell-build-system)
1941 "http://github.com/jystic/unix-compat")
1942 (synopsis "Portable POSIX-compatibility layer")
1944 "This package provides portable implementations of parts of the unix
1945 package. This package re-exports the unix package when available. When it
1946 isn't available, portable implementations are used.")
1949 (define-public ghc-http-types
1951 (name "ghc-http-types")
1957 "http://hackage.haskell.org/package/http-types/http-types-"
1962 "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
1963 (build-system haskell-build-system)
1964 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find
1965 ; Blaze.Bytestring.Builder, which should be
1966 ; provided by ghc-blaze-builder.
1968 `(("ghc-case-insensitive" ,ghc-case-insensitive)
1969 ("ghc-blaze-builder" ,ghc-blaze-builder)))
1971 `(("ghc-text" ,ghc-text)))
1972 (home-page "https://github.com/aristidb/http-types")
1973 (synopsis "Generic HTTP types for Haskell")
1974 (description "This package provides generic HTTP types for Haskell (for
1975 both client and server code).")
1978 (define-public ghc-iproute
1980 (name "ghc-iproute")
1986 "http://hackage.haskell.org/package/iproute/iproute-"
1991 "1ply0i110c2sppjbfyysgw48jfjnsbam5zwil8xws0hp20rh1pb5"))))
1992 (build-system haskell-build-system)
1993 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
1994 ; exported by ghc-byteorder. Doctest issue.
1996 `(("ghc-appar" ,ghc-appar)
1997 ("ghc-byteorder" ,ghc-byteorder)))
1999 `(("ghc-network" ,ghc-network)
2000 ("ghc-safe" ,ghc-safe)))
2001 (home-page "http://www.mew.org/~kazu/proj/iproute/")
2002 (synopsis "IP routing table")
2003 (description "IP Routing Table is a tree of IP ranges to search one of
2004 them on the longest match base. It is a kind of TRIE with one way branching
2005 removed. Both IPv4 and IPv6 are supported.")
2008 (define-public ghc-regex-base
2010 (name "ghc-regex-base")
2016 "http://hackage.haskell.org/package/regex-base/regex-base-"
2021 "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
2022 (build-system haskell-build-system)
2024 `(("ghc-mtl" ,ghc-mtl)))
2026 "http://sourceforge.net/projects/lazy-regex")
2027 (synopsis "Replaces/Enhances Text.Regex")
2028 (description "@code{Text.Regex.Base} provides the interface API for
2029 regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
2032 (define-public ghc-regex-posix
2034 (name "ghc-regex-posix")
2040 "http://hackage.haskell.org/package/regex-posix/regex-posix-"
2045 "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
2046 (build-system haskell-build-system)
2048 `(("ghc-regex-base" ,ghc-regex-base)))
2049 (home-page "http://sourceforge.net/projects/lazy-regex")
2050 (synopsis "POSIX regular expressions for Haskell")
2051 (description "This library provides the POSIX regex backend used by the
2052 Haskell library @code{regex-base}.")
2055 (define-public ghc-regex-compat
2057 (name "ghc-regex-compat")
2063 "http://hackage.haskell.org/package/regex-compat/regex-compat-"
2068 "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
2069 (build-system haskell-build-system)
2071 `(("ghc-regex-base" ,ghc-regex-base)
2072 ("ghc-regex-posix" ,ghc-regex-posix)))
2073 (home-page "http://sourceforge.net/projects/lazy-regex")
2074 (synopsis "Replaces/Enhances Text.Regex")
2075 (description "This library provides one module layer over
2076 @code{regex-posix} to replace @code{Text.Regex}.")
2079 (define-public ghc-regex-tdfa-rc
2081 (name "ghc-regex-tdfa-rc")
2087 "http://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-"
2092 "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3"))))
2093 (build-system haskell-build-system)
2095 `(("ghc-regex-base" ,ghc-regex-base)
2096 ("ghc-parsec" ,ghc-parsec)))
2098 `(("ghc-mtl" ,ghc-mtl)))
2100 "http://hackage.haskell.org/package/regex-tdfa")
2101 (synopsis "Tagged DFA regex engine for Haskell")
2102 (description "A new all-Haskell \"tagged\" DFA regex engine, inspired by
2103 @code{libtre} (fork by Roman Cheplyaka).")
2106 (define-public ghc-parsers
2108 (name "ghc-parsers")
2114 "http://hackage.haskell.org/package/parsers/parsers-"
2119 "18wzmp8y3py4qa8hdsxqm0jfzmwy744dw7xa48r5s8ynhpimi462"))))
2120 (build-system haskell-build-system)
2121 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2122 ; -package attoparsec-0.13.0.1"
2124 `(("ghc-base-orphans" ,ghc-base-orphans)
2125 ("ghc-attoparsec" ,ghc-attoparsec)
2126 ("ghc-parsec" ,ghc-parsec)
2127 ("ghc-scientific" ,ghc-scientific)
2128 ("ghc-charset" ,ghc-charset)))
2130 `(("ghc-text" ,ghc-text)
2131 ("ghc-unordered-containers" ,ghc-unordered-containers)))
2132 (home-page "http://github.com/ekmett/parsers/")
2133 (synopsis "Parsing combinators")
2134 (description "This library provides convenient combinators for working
2135 with and building parsing combinator libraries. Given a few simple instances,
2136 you get access to a large number of canned definitions. Instances exist for
2137 the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
2141 (define-public ghc-trifecta
2143 (name "ghc-trifecta")
2149 "http://hackage.haskell.org/package/trifecta/trifecta-"
2154 "0fjhnsbafl3yw34pyhcsvrqy6a2mnhyqys6gna3rrlygs8ck7hpb"))))
2155 (build-system haskell-build-system)
2156 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2157 ; -package ansi-terminal-0.6.2.3"
2159 `(("ghc-charset" ,ghc-charset)
2160 ("ghc-comonad" ,ghc-comonad)
2161 ("ghc-lens" ,ghc-lens)
2162 ("ghc-profunctors" ,ghc-profunctors)
2163 ("ghc-reducers" ,ghc-reducers)
2164 ("ghc-semigroups" ,ghc-semigroups)))
2166 `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
2167 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
2168 ("ghc-blaze-builder" ,ghc-blaze-builder)
2169 ("ghc-blaze-html" ,ghc-blaze-html)
2170 ("ghc-blaze-markup" ,ghc-blaze-markup)
2171 ("ghc-fingertree" ,ghc-fingertree)
2172 ("ghc-hashable" ,ghc-hashable)
2173 ("ghc-mtl" ,ghc-mtl)
2174 ("ghc-parsers" ,ghc-parsers)
2175 ("ghc-unordered-containers" ,ghc-unordered-containers)
2176 ("ghc-utf8-string" ,ghc-utf8-string)))
2177 (home-page "http://github.com/ekmett/trifecta/")
2178 (synopsis "Parser combinator library with convenient diagnostics")
2179 (description "Trifecta is a modern parser combinator library for Haskell,
2180 with slicing and Clang-style colored diagnostics.")
2183 (define-public ghc-attoparsec
2185 (name "ghc-attoparsec")
2186 (version "0.13.0.1")
2191 "http://hackage.haskell.org/package/attoparsec/attoparsec-"
2196 "0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f"))))
2197 (build-system haskell-build-system)
2199 `(("ghc-scientific" ,ghc-scientific)))
2201 `(("ghc-quickcheck" ,ghc-quickcheck)
2202 ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
2203 ("ghc-test-framework" ,ghc-test-framework)
2204 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
2205 ("ghc-text" ,ghc-text)
2206 ("ghc-vector" ,ghc-vector)))
2207 (home-page "https://github.com/bos/attoparsec")
2208 (synopsis "Fast combinator parsing for bytestrings and text")
2209 (description "This library provides a fast parser combinator library,
2210 aimed particularly at dealing efficiently with network protocols and
2211 complicated text/binary file formats.")
2214 (define-public ghc-css-text
2216 (name "ghc-css-text")
2222 "http://hackage.haskell.org/package/css-text/css-text-"
2227 "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
2228 (build-system haskell-build-system)
2230 `(("ghc-text" ,ghc-text)
2231 ("ghc-attoparsec" ,ghc-attoparsec)
2232 ("ghc-hspec" ,ghc-hspec)
2233 ("ghc-quickcheck" ,ghc-quickcheck)))
2234 (home-page "http://www.yesodweb.com/")
2235 (synopsis "CSS parser and renderer")
2236 (description "This package provides a CSS parser and renderer for
2240 (define-public ghc-zip-archive
2242 (name "ghc-zip-archive")
2248 "http://hackage.haskell.org/package/zip-archive/zip-archive-"
2253 "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1"))))
2254 (build-system haskell-build-system)
2256 `(("ghc-old-time" ,ghc-old-time)
2257 ("ghc-digest" ,ghc-digest)))
2259 `(("ghc-hunit" ,ghc-hunit)
2260 ("ghc-mtl" ,ghc-mtl)
2262 ("ghc-text" ,ghc-text)
2263 ("ghc-zlib" ,ghc-zlib)))
2264 (home-page "https://hackage.haskell.org/package/zip-archive")
2265 (synopsis "Zip archive library for Haskell")
2266 (description "The zip-archive library provides functions for creating,
2267 modifying, and extracting files from zip archives in Haskell.")
2270 (define-public ghc-distributive
2272 (name "ghc-distributive")
2278 "http://hackage.haskell.org/package/distributive/distributive-"
2283 "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2"))))
2284 (build-system haskell-build-system)
2285 (arguments `(#:tests? #f)) ; FIXME: fails with "cannot satisfy -package
2286 ; tagged-0.8.1". Suspected Cabal issue.
2288 `(("ghc-tagged" ,ghc-tagged)
2289 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2290 (home-page "http://github.com/ekmett/distributive/")
2291 (synopsis "Distributive functors for Haskell")
2292 (description "This package provides distributive functors for Haskell.
2293 Dual to @code{Traversable}.")
2296 (define-public ghc-cereal
2304 "http://hackage.haskell.org/package/cereal/cereal-"
2309 "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z"))))
2310 (build-system haskell-build-system)
2311 (home-page "http://hackage.haskell.org/package/cereal")
2312 (synopsis "Binary serialization library")
2313 (description "This package provides a binary serialization library,
2314 similar to @code{binary}, that introduces an @code{isolate} primitive for
2315 parser isolation, and labeled blocks for better error messages.")
2318 (define-public ghc-comonad
2320 (name "ghc-comonad")
2326 "http://hackage.haskell.org/package/comonad/comonad-"
2331 "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp"))))
2332 (build-system haskell-build-system)
2334 `(("ghc-distributive" ,ghc-distributive)
2335 ("ghc-transformers-compat" ,ghc-transformers-compat)
2336 ("ghc-contravariant" ,ghc-contravariant)))
2337 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2338 ; -package contravariant-1.3.3"
2340 `(("ghc-semigroups" ,ghc-semigroups)
2341 ("ghc-tagged" ,ghc-tagged)
2342 ("ghc-contravariant" ,ghc-contravariant)))
2343 (home-page "http://github.com/ekmett/comonad/")
2344 (synopsis "Comonads for Haskell")
2345 (description "This library provides @code{Comonad}s for Haskell.")
2348 (define-public hscolour
2356 "http://hackage.haskell.org/package/hscolour/hscolour-"
2361 "1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp"))))
2362 (build-system haskell-build-system)
2363 (home-page "https://hackage.haskell.org/package/hscolour")
2364 (synopsis "Script to colourise Haskell code")
2365 (description "HSColour is a small Haskell script to colourise Haskell
2366 code. It currently has six output formats: ANSI terminal codes (optionally
2367 XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01
2368 with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX,
2369 and mIRC chat codes.")
2372 (define-public ghc-polyparse
2374 (name "ghc-polyparse")
2380 "http://hackage.haskell.org/package/polyparse/polyparse-"
2385 "1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh"))))
2386 (build-system haskell-build-system)
2388 `(("ghc-text" ,ghc-text)))
2390 "http://code.haskell.org/~malcolm/polyparse/")
2392 "Alternative parser combinator libraries")
2394 "This package provides a variety of alternative parser combinator
2395 libraries, including the original HuttonMeijer set. The Poly sets have
2396 features like good error reporting, arbitrary token type, running state, lazy
2397 parsing, and so on. Finally, Text.Parse is a proposed replacement for the
2398 standard Read class, for better deserialisation of Haskell values from
2402 (define-public ghc-extra
2410 "http://hackage.haskell.org/package/extra/extra-"
2415 "1h9hxkrqrqscx420yz1lmivbrhi6jc3a5ap61vkxd2mhdgark9hf"))))
2416 (build-system haskell-build-system)
2417 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
2418 (home-page "https://github.com/ndmitchell/extra")
2419 (synopsis "Extra Haskell functions")
2420 (description "This library provides extra functions for the standard
2421 Haskell libraries. Most functions are simple additions, filling out missing
2422 functionality. A few functions are available in later versions of GHC, but
2423 this package makes them available back to GHC 7.2.")
2426 (define-public ghc-profunctors
2428 (name "ghc-profunctors")
2434 "http://hackage.haskell.org/package/profunctors/profunctors-"
2439 "0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7"))))
2440 (build-system haskell-build-system)
2442 `(("ghc-distributive" ,ghc-distributive)))
2444 `(("ghc-comonad" ,ghc-comonad)
2445 ("ghc-tagged" ,ghc-tagged)))
2446 (home-page "http://github.com/ekmett/profunctors/")
2447 (synopsis "Profunctors for Haskell")
2448 (description "This library provides profunctors for Haskell.")
2451 (define-public ghc-reducers
2453 (name "ghc-reducers")
2459 "http://hackage.haskell.org/package/reducers/reducers-"
2464 "0pkddg0s3cn759miq0nfrq7lnp3imk5sx784ihsilsbjh9kvffz4"))))
2465 (build-system haskell-build-system)
2467 `(("ghc-semigroupoids" ,ghc-semigroupoids)))
2469 `(("ghc-fingertree" ,ghc-fingertree)
2470 ("ghc-hashable" ,ghc-hashable)
2471 ("ghc-text" ,ghc-text)
2472 ("ghc-unordered-containers" ,ghc-unordered-containers)
2473 ("ghc-semigroups" ,ghc-semigroups)))
2474 (home-page "http://github.com/ekmett/reducers/")
2475 (synopsis "Semigroups, specialized containers and a general map/reduce framework")
2476 (description "This library provides various semigroups, specialized
2477 containers and a general map/reduce framework for Haskell.")
2480 (define-public ghc-appar
2488 "http://hackage.haskell.org/package/appar/appar-"
2493 "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
2494 (build-system haskell-build-system)
2496 "http://hackage.haskell.org/package/appar")
2497 (synopsis "Simple applicative parser")
2498 (description "This package provides a simple applicative parser in Parsec
2502 (define-public ghc-safe
2510 "http://hackage.haskell.org/package/safe/safe-"
2515 "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh"))))
2516 (build-system haskell-build-system)
2517 (home-page "https://github.com/ndmitchell/safe#readme")
2518 (synopsis "Library of safe (exception free) functions")
2519 (description "This library provides wrappers around @code{Prelude} and
2520 @code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
2524 (define-public ghc-generic-deriving
2526 (name "ghc-generic-deriving")
2532 "http://hackage.haskell.org/package/generic-deriving/generic-deriving-"
2537 "1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6"))))
2538 (build-system haskell-build-system)
2539 (home-page "https://hackage.haskell.org/package/generic-deriving")
2540 (synopsis "Generalise the deriving mechanism to arbitrary classes")
2541 (description "This package provides functionality for generalising the
2542 deriving mechanism in Haskell to arbitrary classes.")
2545 (define-public ghc-pcre-light
2547 (name "ghc-pcre-light")
2553 "http://hackage.haskell.org/package/pcre-light/pcre-light-"
2558 "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf"))))
2559 (build-system haskell-build-system)
2562 (home-page "https://github.com/Daniel-Diaz/pcre-light")
2563 (synopsis "Haskell library for Perl 5 compatible regular expressions")
2564 (description "This package provides a small, efficient, and portable regex
2565 library for Perl 5 compatible regular expressions. The PCRE library is a set
2566 of functions that implement regular expression pattern matching using the same
2567 syntax and semantics as Perl 5.")
2570 (define-public ghc-logict
2578 "http://hackage.haskell.org/package/logict/logict-"
2583 "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
2584 (build-system haskell-build-system)
2585 (inputs `(("ghc-mtl" ,ghc-mtl)))
2586 (home-page "http://code.haskell.org/~dolio/")
2587 (synopsis "Backtracking logic-programming monad")
2588 (description "This library provides a continuation-based, backtracking,
2589 logic programming monad. An adaptation of the two-continuation implementation
2590 found in the paper \"Backtracking, Interleaving, and Terminating Monad
2591 Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
2595 (define-public ghc-xml
2603 "http://hackage.haskell.org/package/xml/xml-"
2608 "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
2609 (build-system haskell-build-system)
2611 `(("ghc-text" ,ghc-text)))
2612 (home-page "http://code.galois.com")
2613 (synopsis "Simple XML library for Haskell")
2614 (description "This package provides a simple XML library for Haskell.")
2617 (define-public ghc-exceptions
2619 (name "ghc-exceptions")
2625 "http://hackage.haskell.org/package/exceptions/exceptions-"
2630 "1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7"))))
2631 (build-system haskell-build-system)
2632 (arguments `(#:tests? #f)) ; FIXME: Missing test-framework package.
2634 `(("ghc-stm" ,ghc-stm)
2635 ("ghc-mtl" ,ghc-mtl)
2636 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2637 (home-page "http://github.com/ekmett/exceptions/")
2638 (synopsis "Extensible optionally-pure exceptions")
2639 (description "This library provides extensible optionally-pure exceptions
2643 (define-public ghc-temporary
2645 (name "ghc-temporary")
2651 "http://hackage.haskell.org/package/temporary/temporary-"
2656 "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a"))))
2657 (build-system haskell-build-system)
2658 (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions)))
2659 (home-page "http://www.github.com/batterseapower/temporary")
2660 (synopsis "Temporary file and directory support")
2661 (description "The functions for creating temporary files and directories
2662 in the Haskelll base library are quite limited. This library just repackages
2663 the Cabal implementations of its own temporary file and folder functions so
2664 that you can use them without linking against Cabal or depending on it being
2668 (define-public ghc-temporary-rc
2670 (name "ghc-temporary-rc")
2676 "http://hackage.haskell.org/package/temporary-rc/temporary-rc-"
2681 "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
2682 (build-system haskell-build-system)
2683 (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions)))
2685 "http://www.github.com/feuerbach/temporary")
2687 "Portable temporary file and directory support")
2689 "The functions for creating temporary files and directories in the base
2690 library are quite limited. The unixutils package contains some good ones, but
2691 they aren't portable to Windows. This library just repackages the Cabal
2692 implementations of its own temporary file and folder functions so that you can
2693 use them without linking against Cabal or depending on it being installed.
2694 This is a better maintained fork of the \"temporary\" package.")
2697 (define-public ghc-smallcheck
2699 (name "ghc-smallcheck")
2705 "http://hackage.haskell.org/package/smallcheck/smallcheck-"
2710 "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
2711 (build-system haskell-build-system)
2713 `(("ghc-logict" ,ghc-logict)))
2715 `(("ghc-mtl" ,ghc-mtl)))
2717 "https://github.com/feuerbach/smallcheck")
2718 (synopsis "Property-based testing library")
2719 (description "SmallCheck is a testing library that allows to verify
2720 properties for all test cases up to some depth. The test cases are generated
2721 automatically by SmallCheck.")
2724 (define-public ghc-tasty-ant-xml
2726 (name "ghc-tasty-ant-xml")
2732 "http://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
2737 "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
2738 (build-system haskell-build-system)
2740 `(("ghc-generic-deriving" ,ghc-generic-deriving)
2741 ("ghc-xml" ,ghc-xml)))
2743 `(("ghc-mtl" ,ghc-mtl)
2744 ("ghc-stm" ,ghc-stm)
2745 ("ghc-tagged" ,ghc-tagged)
2746 ("ghc-tasty" ,ghc-tasty)))
2748 "http://github.com/ocharles/tasty-ant-xml")
2750 "Render tasty output to XML for Jenkins")
2752 "A tasty ingredient to output test results in XML, using the Ant
2753 schema. This XML can be consumed by the Jenkins continuous integration
2757 (define-public ghc-tasty-smallcheck
2759 (name "ghc-tasty-smallcheck")
2765 "http://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
2770 "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
2771 (build-system haskell-build-system)
2773 `(("ghc-tasty" ,ghc-tasty)
2774 ("ghc-smallcheck" ,ghc-smallcheck)
2775 ("ghc-async" ,ghc-async)
2776 ("ghc-tagged" ,ghc-tagged)))
2777 (home-page "http://documentup.com/feuerbach/tasty")
2778 (synopsis "SmallCheck support for the Tasty test framework")
2779 (description "This package provides SmallCheck support for the Tasty
2780 Haskell test framework.")
2783 (define-public ghc-silently
2785 (name "ghc-silently")
2791 "http://hackage.haskell.org/package/silently/silently-"
2796 "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
2797 (build-system haskell-build-system)
2798 (arguments `(#:tests? #f)) ;; circular dependency with nanospec
2800 ;; `(("ghc-temporary" ,ghc-temporary)))
2801 (home-page "https://github.com/hspec/silently")
2802 (synopsis "Prevent writing to stdout")
2803 (description "This package provides functions to prevent or capture
2804 writing to stdout and other handles.")
2807 (define-public ghc-quickcheck-instances
2809 (name "ghc-quickcheck-instances")
2815 "http://hackage.haskell.org/package/"
2816 "quickcheck-instances/quickcheck-instances-"
2820 "041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2"))))
2821 (build-system haskell-build-system)
2823 `(("ghc-old-time" ,ghc-old-time)
2824 ("ghc-unordered-containers" ,ghc-unordered-containers)))
2826 `(("ghc-hashable" ,ghc-hashable)
2827 ("ghc-quickcheck" ,ghc-quickcheck)
2828 ("ghc-text" ,ghc-text)))
2830 "https://github.com/aslatter/qc-instances")
2831 (synopsis "Common quickcheck instances")
2832 (description "This package provides QuickCheck instances for types
2833 provided by the Haskell Platform.")
2836 (define-public ghc-quickcheck-unicode
2838 (name "ghc-quickcheck-unicode")
2844 "http://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
2849 "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
2850 (build-system haskell-build-system)
2851 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
2853 "https://github.com/bos/quickcheck-unicode")
2854 (synopsis "Generator functions Unicode-related tests")
2855 (description "This package provides generator and shrink functions for
2856 testing Unicode-related software.")
2859 (define-public ghc-quickcheck-io
2861 (name "ghc-quickcheck-io")
2867 "http://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
2872 "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
2873 (build-system haskell-build-system)
2875 `(("ghc-quickcheck" ,ghc-quickcheck)
2876 ("ghc-hunit" ,ghc-hunit)))
2878 "https://github.com/hspec/quickcheck-io#readme")
2879 (synopsis "Use HUnit assertions as QuickCheck properties")
2880 (description "This package provides an orphan instance that allows you to
2881 use HUnit assertions as QuickCheck properties.")
2884 (define-public ghc-quickcheck
2886 (name "ghc-quickcheck")
2888 (outputs '("out" "doc"))
2893 "http://hackage.haskell.org/package/QuickCheck/QuickCheck-"
2898 "0fvnfl30fxmj5q920l13641ar896d53z0z6z66m7c1366lvalwvh"))))
2899 (build-system haskell-build-system)
2901 `(#:tests? #f ; FIXME: currently missing libraries used for tests.
2902 #:configure-flags '("-f base4")))
2903 ;; these inputs are necessary to use this package
2905 `(("ghc-tf-random" ,ghc-tf-random)))
2907 "https://github.com/nick8325/quickcheck")
2909 "Automatic testing of Haskell programs")
2911 "QuickCheck is a library for random testing of program properties.")
2914 (define-public ghc-case-insensitive
2916 (name "ghc-case-insensitive")
2918 (outputs '("out" "doc"))
2923 "http://hackage.haskell.org/package/case-insensitive/case-insensitive-"
2928 "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
2929 (build-system haskell-build-system)
2931 `(("ghc-hunit" ,ghc-hunit)))
2932 ;; these inputs are necessary to use this library
2934 `(("ghc-text" ,ghc-text)
2935 ("ghc-hashable" ,ghc-hashable)))
2937 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
2939 "https://github.com/basvandijk/case-insensitive")
2940 (synopsis "Case insensitive string comparison")
2942 "The module 'Data.CaseInsensitive' provides the 'CI' type constructor
2943 which can be parameterised by a string-like type like: 'String', 'ByteString',
2944 'Text', etc.. Comparisons of values of the resulting type will be insensitive
2948 (define-public ghc-syb
2952 (outputs '("out" "doc"))
2957 "http://hackage.haskell.org/package/syb/syb-"
2962 "1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3"))))
2963 (build-system haskell-build-system)
2965 `(("ghc-hunit" ,ghc-hunit)
2966 ("ghc-mtl" ,ghc-mtl)))
2968 "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
2969 (synopsis "Scrap Your Boilerplate")
2970 (description "This package contains the generics system described in the
2971 /Scrap Your Boilerplate/ papers (see
2972 @uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It
2973 defines the 'Data' class of types permitting folding and unfolding of
2974 constructor applications, instances of this class for primitive types, and a
2975 variety of traversals.")
2978 (define-public ghc-fgl
2982 (outputs '("out" "doc"))
2987 "http://hackage.haskell.org/package/fgl/fgl-"
2992 "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga"))))
2993 (build-system haskell-build-system)
2994 (inputs `(("ghc-mtl" ,ghc-mtl)))
2995 (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
2997 "Martin Erwig's Functional Graph Library")
2998 (description "The functional graph library, FGL, is a collection of type
2999 and function definitions to address graph problems. The basis of the library
3000 is an inductive definition of graphs in the style of algebraic data types that
3001 encourages inductive, recursive definitions of graph algorithms.")
3004 (define-public ghc-chasingbottoms
3006 (name "ghc-chasingbottoms")
3007 (version "1.3.0.13")
3011 (uri (string-append "http://hackage.haskell.org/package/ChasingBottoms/"
3012 "ChasingBottoms-" version ".tar.gz"))
3015 "1fb86jd6cdz4rx3fj3r9n8d60kx824ywwy7dw4qnrdran46ja3pl"))
3016 (modules '((guix build utils)))
3018 ;; The Hackage page and the cabal file linked there for this package
3019 ;; both list 0.7 as the upper version limit, but the source tarball
3020 ;; specifies 0.6. Assume the Hackage page is correct.
3021 '(substitute* "ChasingBottoms.cabal"
3022 (("syb >= 0.1.0.2 && < 0.6") "syb >= 0.1.0.2 && < 0.7")))))
3023 (build-system haskell-build-system)
3025 `(("ghc-mtl" ,ghc-mtl)
3026 ("ghc-quickcheck" ,ghc-quickcheck)
3027 ("ghc-random" ,ghc-random)
3028 ("ghc-syb" ,ghc-syb)))
3029 (home-page "http://hackage.haskell.org/package/ChasingBottoms")
3030 (synopsis "Testing of partial and infinite values in Haskell")
3032 ;; FIXME: There should be a @comma{} in the uref text, but it is not
3033 ;; rendered properly.
3034 "This is a library for testing code involving bottoms or infinite values.
3035 For the underlying theory and a larger example involving use of QuickCheck,
3037 @uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
3038 \"Chasing Bottoms A Case Study in Program Verification in the Presence of
3039 Partial and Infinite Values\"}.")
3042 (define-public ghc-unordered-containers
3044 (name "ghc-unordered-containers")
3046 (outputs '("out" "doc"))
3051 "http://hackage.haskell.org/package/unordered-containers"
3052 "/unordered-containers-" version ".tar.gz"))
3055 "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
3056 (build-system haskell-build-system)
3058 `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
3059 ("ghc-hunit" ,ghc-hunit)
3060 ("ghc-quickcheck" ,ghc-quickcheck)
3061 ("ghc-test-framework" ,ghc-test-framework)
3062 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
3063 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
3064 ;; these inputs are necessary to use this library
3065 (propagated-inputs `(("ghc-hashable" ,ghc-hashable)))
3067 "https://github.com/tibbe/unordered-containers")
3069 "Efficient hashing-based container types")
3071 "Efficient hashing-based container types. The containers have been
3072 optimized for performance critical use, both in terms of large data quantities
3076 (define-public ghc-uniplate
3078 (name "ghc-uniplate")
3084 "http://hackage.haskell.org/package/uniplate/uniplate-"
3089 "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
3090 (build-system haskell-build-system)
3092 `(("ghc-syb" ,ghc-syb)
3093 ("ghc-hashable" ,ghc-hashable)
3094 ("ghc-unordered-containers" ,ghc-unordered-containers)))
3095 (home-page "http://community.haskell.org/~ndm/uniplate/")
3096 (synopsis "Simple, concise and fast generic operations")
3097 (description "Uniplate is a library for writing simple and concise generic
3098 operations. Uniplate has similar goals to the original Scrap Your Boilerplate
3099 work, but is substantially simpler and faster.")
3102 (define-public ghc-base64-bytestring
3104 (name "ghc-base64-bytestring")
3110 "http://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
3115 "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db"))))
3116 (build-system haskell-build-system)
3117 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3118 (home-page "https://github.com/bos/base64-bytestring")
3119 (synopsis "Base64 encoding and decoding for ByteStrings")
3120 (description "This library provides fast base64 encoding and decoding for
3121 Haskell @code{ByteString}s.")
3124 (define-public ghc-annotated-wl-pprint
3126 (name "ghc-annotated-wl-pprint")
3132 "http://hackage.haskell.org/package/annotated-wl-pprint"
3133 "/annotated-wl-pprint-" version
3137 "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
3138 (build-system haskell-build-system)
3140 "https://github.com/david-christiansen/annotated-wl-pprint")
3142 "The Wadler/Leijen Pretty Printer, with annotation support")
3143 (description "This is a modified version of wl-pprint, which was based on
3144 Wadler's paper \"A Prettier Printer\". This version allows the library user
3145 to annotate the text with semantic information, which can later be rendered in
3146 a variety of ways.")
3149 (define-public ghc-ansi-wl-pprint
3151 (name "ghc-ansi-wl-pprint")
3157 "http://hackage.haskell.org/package/ansi-wl-pprint/ansi-wl-pprint-"
3162 "025pyphsjf0dnbrmj5nscbi6gzyigwgp3ifxb3psn7kji6mfr29p"))))
3163 (build-system haskell-build-system)
3165 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
3166 (home-page "http://github.com/ekmett/ansi-wl-pprint")
3167 (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
3168 (description "This is a pretty printing library based on Wadler's paper
3169 \"A Prettier Printer\". It has been enhanced with support for ANSI terminal
3170 colored output using the ansi-terminal package.")
3173 (define-public ghc-split
3177 (outputs '("out" "doc"))
3182 "http://hackage.haskell.org/package/split/split-"
3187 "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))
3188 (modules '((guix build utils)))
3190 ;; The Cabal file on Hackage is updated, but the tar.gz does not
3192 ;; <https://hackage.haskell.org/package/split-0.2.2/revisions/>.
3193 '(substitute* "split.cabal"
3194 (("base <4.8") "base <4.9")))))
3195 (build-system haskell-build-system)
3197 `(("ghc-quickcheck" ,ghc-quickcheck)))
3198 (home-page "http://hackage.haskell.org/package/split")
3199 (synopsis "Combinator library for splitting lists")
3200 (description "This package provides a collection of Haskell functions for
3201 splitting lists into parts, akin to the @code{split} function found in several
3202 mainstream languages.")
3205 (define-public ghc-parsec
3209 (outputs '("out" "doc"))
3214 "http://hackage.haskell.org/package/parsec/parsec-"
3218 (base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
3219 (build-system haskell-build-system)
3221 `(("ghc-hunit" ,ghc-hunit)))
3222 ;; these inputs are necessary to use this library
3224 `(("ghc-text" ,ghc-text)
3225 ("ghc-mtl" ,ghc-mtl)))
3227 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3229 "https://github.com/aslatter/parsec")
3230 (synopsis "Monadic parser combinators")
3231 (description "Parsec is a parser library. It is simple, safe, well
3232 documented, has extensive libraries, good error messages, and is fast. It is
3233 defined as a monad transformer that can be stacked on arbitrary monads, and it
3234 is also parametric in the input stream type.")
3237 (define-public ghc-vector
3240 (version "0.11.0.0")
3241 (outputs '("out" "doc"))
3246 "http://hackage.haskell.org/package/vector/vector-"
3251 "1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa"))))
3252 (build-system haskell-build-system)
3254 `(("ghc-quickcheck" ,ghc-quickcheck)))
3255 ;; these inputs are necessary to use this library
3257 `(("ghc-primitive" ,ghc-primitive)))
3259 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3260 (home-page "https://github.com/haskell/vector")
3261 (synopsis "Efficient Arrays")
3262 (description "This library provides an efficient implementation of
3263 Int-indexed arrays (both mutable and immutable), with a powerful loop
3264 optimisation framework.")
3267 (define-public ghc-vector-binary-instances
3269 (name "ghc-vector-binary-instances")
3275 "http://hackage.haskell.org/package/"
3276 "vector-binary-instances/vector-binary-instances-"
3280 "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l"))))
3281 (build-system haskell-build-system)
3283 `(("ghc-cereal" ,ghc-cereal)))
3285 `(("ghc-vector" ,ghc-vector)))
3286 (home-page "https://github.com/bos/vector-binary-instances")
3287 (synopsis "Instances of Data.Binary and Data.Serialize for vector")
3288 (description "This library provides instances of @code{Binary} for the
3289 types defined in the @code{vector} package, making it easy to serialize
3290 vectors to and from disk. We use the generic interface to vectors, so all
3291 vector types are supported. Specific instances are provided for unboxed,
3292 boxed and storable vectors.")
3295 (define-public ghc-network
3297 (name "ghc-network")
3299 (outputs '("out" "doc"))
3304 "http://hackage.haskell.org/package/network/network-"
3309 "1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3"))))
3310 (build-system haskell-build-system)
3312 `(("ghc-hunit" ,ghc-hunit)))
3314 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3315 (home-page "https://github.com/haskell/network")
3316 (synopsis "Low-level networking interface")
3318 "This package provides a low-level networking interface.")
3321 (define-public ghc-network-uri
3323 (name "ghc-network-uri")
3325 (outputs '("out" "doc"))
3330 "http://hackage.haskell.org/package/network-uri/network-uri-"
3335 "1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg"))))
3336 (build-system haskell-build-system)
3338 `(("ghc-hunit" ,ghc-hunit)
3339 ("ghc-network" ,ghc-network)))
3341 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3343 `(("ghc-parsec" ,ghc-parsec)))
3345 "https://github.com/haskell/network-uri")
3346 (synopsis "Library for URI manipulation")
3347 (description "This package provides an URI manipulation interface. In
3348 'network-2.6' the 'Network.URI' module was split off from the 'network'
3349 package into this package.")
3352 (define-public ghc-ansi-terminal
3354 (name "ghc-ansi-terminal")
3360 "http://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
3365 "0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d"))))
3366 (build-system haskell-build-system)
3367 (home-page "https://github.com/feuerbach/ansi-terminal")
3368 (synopsis "ANSI terminal support for Haskell")
3369 (description "This package provides ANSI terminal support for Haskell. It
3370 allows cursor movement, screen clearing, color output showing or hiding the
3371 cursor, and changing the title.")
3374 (define-public ghc-http
3377 (version "4000.2.20")
3378 (outputs '("out" "doc"))
3383 "http://hackage.haskell.org/package/HTTP/HTTP-"
3388 "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
3389 (build-system haskell-build-system)
3391 `(("ghc-hunit" ,ghc-hunit)))
3393 `(("ghc-old-time" ,ghc-old-time)
3394 ("ghc-parsec" ,ghc-parsec)
3395 ("ghc-mtl" ,ghc-mtl)
3396 ("ghc-network" ,ghc-network)
3397 ("ghc-network-uri" ,ghc-network-uri)))
3399 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3400 (home-page "https://github.com/haskell/HTTP")
3401 (synopsis "Library for client-side HTTP")
3403 "The HTTP package supports client-side web programming in Haskell. It
3404 lets you set up HTTP connections, transmitting requests and processing the
3405 responses coming back.")
3408 (define-public ghc-hspec
3416 "http://hackage.haskell.org/package/hspec/hspec-"
3421 "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
3422 (build-system haskell-build-system)
3424 `(("ghc-hspec-core" ,ghc-hspec-core)
3425 ("hspec-discover" ,hspec-discover)
3426 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3427 ("ghc-quickcheck" ,ghc-quickcheck)
3428 ("ghc-hunit" ,ghc-hunit)))
3430 `(("ghc-stringbuilder" ,ghc-stringbuilder)
3431 ("ghc-hspec-meta" ,ghc-hspec-meta)))
3432 (home-page "http://hspec.github.io/")
3433 (synopsis "Testing Framework for Haskell")
3434 (description "This library provides the Hspec testing framework for
3435 Haskell, inspired by the Ruby library RSpec.")
3438 (define-public ghc-hspec-contrib
3440 (name "ghc-hspec-contrib")
3444 (uri (string-append "http://hackage.haskell.org/package/"
3445 "hspec-contrib/hspec-contrib-"
3449 "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
3450 (build-system haskell-build-system)
3452 `(("ghc-hspec-core" ,ghc-hspec-core)
3453 ("ghc-hunit" ,ghc-hunit)
3454 ("ghc-hspec" ,ghc-hspec)
3455 ("ghc-quickcheck" ,ghc-quickcheck)))
3456 (home-page "http://hspec.github.io/")
3457 (synopsis "Contributed functionality for Hspec")
3459 "This package provides contributed Hspec extensions.")
3462 (define-public ghc-hspec-expectations
3464 (name "ghc-hspec-expectations")
3470 "http://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
3475 "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
3476 (build-system haskell-build-system)
3477 (inputs `(("ghc-hunit" ,ghc-hunit)))
3478 (home-page "https://github.com/sol/hspec-expectations")
3479 (synopsis "Catchy combinators for HUnit")
3480 (description "This library provides catchy combinators for HUnit, see
3481 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
3484 (define-public hspec-discover
3486 (name "hspec-discover")
3492 "http://hackage.haskell.org/package/hspec-discover/hspec-discover-"
3497 "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
3498 (build-system haskell-build-system)
3499 (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
3500 ; documentation files.
3501 (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
3502 (home-page "http://hspec.github.io/")
3503 (synopsis "Automatically discover and run Hspec tests")
3504 (description "hspec-discover is a tool which automatically discovers and
3508 (define-public ghc-hspec-core
3510 (name "ghc-hspec-core")
3516 "http://hackage.haskell.org/package/hspec-core/hspec-core-"
3521 "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
3522 (build-system haskell-build-system)
3523 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3525 `(("ghc-setenv" ,ghc-setenv)
3526 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
3527 ("ghc-async" ,ghc-async)
3528 ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
3530 `(("ghc-hunit" ,ghc-hunit)
3531 ("ghc-quickcheck" ,ghc-quickcheck)
3532 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3533 ("ghc-silently" ,ghc-silently)))
3534 (home-page "http://hspec.github.io/")
3535 (synopsis "Testing framework for Haskell")
3536 (description "This library exposes internal types and functions that can
3537 be used to extend Hspec's functionality.")
3540 (define-public ghc-hspec-meta
3542 (name "ghc-hspec-meta")
3548 "http://hackage.haskell.org/package/hspec-meta/hspec-meta-"
3553 "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
3554 (build-system haskell-build-system)
3556 `(("ghc-quickcheck" ,ghc-quickcheck)
3557 ("ghc-hunit" ,ghc-hunit)
3558 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
3559 ("ghc-async" ,ghc-async)
3560 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3561 ("ghc-setenv" ,ghc-setenv)
3562 ("ghc-random" ,ghc-random)
3563 ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
3564 (home-page "http://hspec.github.io/")
3565 (synopsis "Version of Hspec to test Hspec itself")
3566 (description "This library provides a stable version of Hspec which is
3567 used to test the in-development version of Hspec.")
3570 (define-public ghc-vault
3578 "http://hackage.haskell.org/package/vault/vault-"
3583 "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn"))))
3584 (build-system haskell-build-system)
3586 `(("ghc-unordered-containers" ,ghc-unordered-containers)
3587 ("ghc-hashable" ,ghc-hashable)))
3589 "https://github.com/HeinrichApfelmus/vault")
3590 (synopsis "Persistent store for arbitrary values")
3591 (description "This package provides vaults for Haskell. A vault is a
3592 persistent store for values of arbitrary types. It's like having first-class
3593 access to the storage space behind @code{IORefs}. The data structure is
3594 analogous to a bank vault, where you can access different bank boxes with
3595 different keys; hence the name. Also provided is a @code{locker} type,
3596 representing a store for a single element.")
3599 (define-public ghc-mmorph
3607 "http://hackage.haskell.org/package/mmorph/mmorph-"
3612 "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2"))))
3613 (build-system haskell-build-system)
3615 "http://hackage.haskell.org/package/mmorph")
3616 (synopsis "Monad morphisms")
3618 "This library provides monad morphism utilities, most commonly used for
3619 manipulating monad transformer stacks.")
3622 (define-public ghc-monad-control
3624 (name "ghc-monad-control")
3630 "http://hackage.haskell.org/package/monad-control"
3631 "/monad-control-" version ".tar.gz"))
3634 "07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179"))))
3635 (build-system haskell-build-system)
3637 `(("ghc-stm" ,ghc-stm)
3638 ("ghc-transformers-base" ,ghc-transformers-base)
3639 ("ghc-transformers-compat" ,ghc-transformers-compat)))
3640 (home-page "https://github.com/basvandijk/monad-control")
3641 (synopsis "Monad transformers to lift control operations like exception
3643 (description "This package defines the type class @code{MonadBaseControl},
3644 a subset of @code{MonadBase} into which generic control operations such as
3645 @code{catch} can be lifted from @code{IO} or any other base monad.")
3648 (define-public ghc-byteorder
3650 (name "ghc-byteorder")
3656 "http://hackage.haskell.org/package/byteorder/byteorder-"
3661 "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
3662 (build-system haskell-build-system)
3664 "http://community.haskell.org/~aslatter/code/byteorder")
3666 "Exposes the native endianness of the system")
3668 "This package is for working with the native byte-ordering of the
3672 (define-public ghc-base-compat
3674 (name "ghc-base-compat")
3680 "http://hackage.haskell.org/package/base-compat/base-compat-"
3685 "02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q"))))
3686 (build-system haskell-build-system)
3688 `(("ghc-quickcheck" ,ghc-quickcheck)
3689 ("ghc-hspec" ,ghc-hspec)))
3690 (home-page "https://hackage.haskell.org/package/base-compat")
3691 (synopsis "Haskell compiler compatibility library")
3692 (description "This library provides functions available in later versions
3693 of base to a wider range of compilers, without requiring the use of CPP
3694 pragmas in your code.")
3697 (define-public ghc-blaze-builder
3699 (name "ghc-blaze-builder")
3705 "http://hackage.haskell.org/package/blaze-builder/blaze-builder-"
3710 "1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1"))))
3711 (build-system haskell-build-system)
3712 (arguments `(#:tests? #f)) ; FIXME: Missing test libraries.
3714 `(("ghc-text" ,ghc-text)
3715 ("ghc-utf8-string" ,ghc-utf8-string)))
3716 (home-page "http://github.com/lpsmith/blaze-builder")
3717 (synopsis "Efficient buffered output")
3718 (description "This library provides an implementation of the older
3719 @code{blaze-builder} interface in terms of the new builder that shipped with
3720 @code{bytestring-0.10.4.0}. This implementation is mostly intended as a
3721 bridge to the new builder, so that code that uses the old interface can
3722 interoperate with code that uses the new implementation.")
3725 (define-public ghc-blaze-markup
3727 (name "ghc-blaze-markup")
3733 "http://hackage.haskell.org/package/blaze-markup/blaze-markup-"
3738 "080vlhd8dwjxrma4bb524lh8gxs5lm3xh122icy6lnnyipla0s9y"))))
3739 (build-system haskell-build-system)
3740 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3742 `(("ghc-blaze-builder" ,ghc-blaze-builder)
3743 ("ghc-text" ,ghc-text)))
3744 (home-page "http://jaspervdj.be/blaze")
3745 (synopsis "Fast markup combinator library for Haskell")
3746 (description "This library provides core modules of a markup combinator
3747 library for Haskell.")
3750 (define-public ghc-blaze-html
3752 (name "ghc-blaze-html")
3758 "http://hackage.haskell.org/package/blaze-html/blaze-html-"
3763 "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
3764 (build-system haskell-build-system)
3765 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3767 `(("ghc-blaze-builder" ,ghc-blaze-builder)
3768 ("ghc-text" ,ghc-text)
3769 ("ghc-blaze-markup" ,ghc-blaze-markup)))
3770 (home-page "http://jaspervdj.be/blaze")
3771 (synopsis "Fast HTML combinator library")
3772 (description "This library provides HTML combinators for Haskell.")
3775 (define-public ghc-easy-file
3777 (name "ghc-easy-file")
3783 "http://hackage.haskell.org/package/easy-file/easy-file-"
3788 "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz"))))
3789 (build-system haskell-build-system)
3791 "http://github.com/kazu-yamamoto/easy-file")
3792 (synopsis "File handling library for Haskell")
3793 (description "This library provides file handling utilities for Haskell.")
3796 (define-public ghc-async
3804 "http://hackage.haskell.org/package/async/async-"
3809 "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v"))))
3810 (build-system haskell-build-system)
3812 `(("ghc-hunit" ,ghc-hunit)
3813 ("ghc-test-framework" ,ghc-test-framework)
3814 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
3816 `(("ghc-stm" ,ghc-stm)))
3817 (home-page "https://github.com/simonmar/async")
3818 (synopsis "Library to run IO operations asynchronously")
3819 (description "Async provides a library to run IO operations
3820 asynchronously, and wait for their results. It is a higher-level interface
3821 over threads in Haskell, in which @code{Async a} is a concurrent thread that
3822 will eventually deliver a value of type @code{a}.")
3825 (define-public ghc-fingertree
3827 (name "ghc-fingertree")
3833 "http://hackage.haskell.org/package/fingertree/fingertree-"
3838 "1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n"))))
3839 (build-system haskell-build-system)
3840 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3841 (home-page "http://hackage.haskell.org/package/fingertree")
3842 (synopsis "Generic finger-tree structure")
3843 (description "This library provides finger trees, a general sequence
3844 representation with arbitrary annotations, for use as a base for
3845 implementations of various collection types. It includes examples, as
3846 described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
3847 simple general-purpose data structure\".")
3850 (define-public ghc-optparse-applicative
3852 (name "ghc-optparse-applicative")
3853 (version "0.11.0.2")
3858 "http://hackage.haskell.org/package/optparse-applicative"
3859 "/optparse-applicative-" version ".tar.gz"))
3862 "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii"))))
3863 (build-system haskell-build-system)
3865 `(("ghc-transformers-compat" ,ghc-transformers-compat)
3866 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
3867 (home-page "https://github.com/pcapriotti/optparse-applicative")
3868 (synopsis "Utilities and combinators for parsing command line options")
3869 (description "This package provides utilities and combinators for parsing
3870 command line options in Haskell.")
3873 (define-public ghc-base-orphans
3875 (name "ghc-base-orphans")
3881 "http://hackage.haskell.org/package/base-orphans/base-orphans-"
3886 "0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl"))))
3887 (build-system haskell-build-system)
3889 `(("ghc-quickcheck" ,ghc-quickcheck)
3890 ("ghc-hspec" ,ghc-hspec)))
3891 (home-page "https://hackage.haskell.org/package/base-orphans")
3892 (synopsis "Orphan instances for backwards compatibility")
3893 (description "This package defines orphan instances that mimic instances
3894 available in later versions of base to a wider (older) range of compilers.")
3897 (define-public ghc-auto-update
3899 (name "ghc-auto-update")
3905 "http://hackage.haskell.org/package/auto-update/auto-update-"
3910 "1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v"))))
3911 (build-system haskell-build-system)
3912 (home-page "https://github.com/yesodweb/wai")
3913 (synopsis "Efficiently run periodic, on-demand actions")
3914 (description "This library provides mechanisms to efficiently run
3915 periodic, on-demand actions in Haskell.")
3918 (define-public ghc-tagged
3926 "http://hackage.haskell.org/package/tagged/tagged-"
3931 "1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav"))))
3932 (build-system haskell-build-system)
3933 (home-page "https://hackage.haskell.org/package/tagged")
3934 (synopsis "Haskell phantom types to avoid passing dummy arguments")
3935 (description "This library provides phantom types for Haskell 98, to avoid
3936 having to unsafely pass dummy arguments.")
3939 (define-public ghc-unbounded-delays
3941 (name "ghc-unbounded-delays")
3947 "http://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
3952 "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420"))))
3953 (build-system haskell-build-system)
3954 (home-page "https://github.com/basvandijk/unbounded-delays")
3955 (synopsis "Unbounded thread delays and timeouts")
3956 (description "The @code{threadDelay} and @code{timeout} functions from the
3957 Haskell base library use the bounded @code{Int} type for specifying the delay
3958 or timeout period. This package provides alternative functions which use the
3959 unbounded @code{Integer} type.")
3962 ;; This package builds `clock` without tests, since the tests rely on tasty
3963 ;; and tasty-quickcheck, which in turn require clock to build. When tasty and
3964 ;; tasty-quickcheck are added, we will add ghc-clock with tests enabled.
3965 (define ghc-clock-bootstrap
3967 (name "ghc-clock-bootstrap")
3973 "http://hackage.haskell.org/package/"
3975 "clock-" version ".tar.gz"))
3977 (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
3978 (build-system haskell-build-system)
3979 (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
3980 ;; tasty-quickcheck, which need clock to build.
3981 (home-page "https://hackage.haskell.org/package/clock")
3982 (synopsis "High-resolution clock for Haskell")
3983 (description "A package for convenient access to high-resolution clock and
3984 timer functions of different operating systems via a unified API.")
3987 (define-public ghc-clock
3995 "http://hackage.haskell.org/package/"
3997 "clock-" version ".tar.gz"))
3999 (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
4000 (build-system haskell-build-system)
4002 `(("ghc-tasty" ,ghc-tasty)
4003 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
4004 (home-page "https://hackage.haskell.org/package/clock")
4005 (synopsis "High-resolution clock for Haskell")
4006 (description "A package for convenient access to high-resolution clock and
4007 timer functions of different operating systems via a unified API.")
4010 (define-public ghc-charset
4012 (name "ghc-charset")
4018 "http://hackage.haskell.org/package/charset/charset-"
4023 "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
4024 (build-system haskell-build-system)
4026 `(("ghc-semigroups" ,ghc-semigroups)))
4028 `(("ghc-unordered-containers" ,ghc-unordered-containers)))
4029 (home-page "http://github.com/ekmett/charset")
4030 (synopsis "Fast unicode character sets for Haskell")
4031 (description "This package provides fast unicode character sets for
4032 Haskell, based on complemented PATRICIA tries.")
4035 (define-public ghc-bytestring-builder
4037 (name "ghc-bytestring-builder")
4038 (version "0.10.6.0.0")
4043 "http://hackage.haskell.org/package/bytestring-builder"
4044 "/bytestring-builder-" version ".tar.gz"))
4047 "1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww"))))
4048 (build-system haskell-build-system)
4049 (arguments `(#:haddock? #f)) ; Package contains no documentation.
4050 (home-page "http://hackage.haskell.org/package/bytestring-builder")
4051 (synopsis "The new bytestring builder, packaged outside of GHC")
4052 (description "This package provides the bytestring builder that is
4053 debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
4054 Compatibility package for older packages.")
4057 (define-public ghc-nats
4065 "http://hackage.haskell.org/package/nats/nats-"
4070 "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0"))))
4071 (build-system haskell-build-system)
4072 (arguments `(#:haddock? #f))
4074 `(("ghc-hashable" ,ghc-hashable)))
4075 (home-page "https://hackage.haskell.org/package/nats")
4076 (synopsis "Natural numbers")
4077 (description "This library provides the natural numbers for Haskell.")
4080 (define-public ghc-void
4088 "http://hackage.haskell.org/package/void/void-"
4093 "1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69"))))
4094 (build-system haskell-build-system)
4096 `(("ghc-semigroups" ,ghc-semigroups)))
4098 `(("ghc-hashable" ,ghc-hashable)))
4099 (home-page "http://github.com/ekmett/void")
4101 "Logically uninhabited data type")
4103 "A Haskell 98 logically uninhabited data type, used to indicate that a
4104 given term should not exist.")
4107 (define-public ghc-kan-extensions
4109 (name "ghc-kan-extensions")
4115 "http://hackage.haskell.org/package/kan-extensions/kan-extensions-"
4120 "0iywbadpy8s3isfzlx9dlz3apaywhqq4gdbxkwygksq8pzdhwkrk"))))
4121 (build-system haskell-build-system)
4123 `(("ghc-adjunctions" ,ghc-adjunctions)))
4125 `(("ghc-comonad" ,ghc-comonad)
4126 ("ghc-contravariant" ,ghc-contravariant)
4127 ("ghc-distributive" ,ghc-distributive)
4128 ("ghc-free" ,ghc-free)
4129 ("ghc-mtl" ,ghc-mtl)
4130 ("ghc-semigroupoids" ,ghc-semigroupoids)
4131 ("ghc-tagged" ,ghc-tagged)))
4132 (home-page "http://github.com/ekmett/kan-extensions/")
4133 (synopsis "Kan extensions library")
4134 (description "This library provides Kan extensions, Kan lifts, various
4135 forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
4138 (define-public ghc-statevar
4140 (name "ghc-statevar")
4146 "http://hackage.haskell.org/package/StateVar/StateVar-"
4151 "1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf"))))
4152 (build-system haskell-build-system)
4154 `(("ghc-stm" ,ghc-stm)))
4155 (home-page "http://hackage.haskell.org/package/StateVar")
4156 (synopsis "State variables for Haskell")
4157 (description "This package provides state variables, which are references
4158 in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
4161 (define-public ghc-lens
4169 "http://hackage.haskell.org/package/lens/lens-"
4174 "0g4g0xksrb2m8wgsmraaq8qnk1sssb42kr65fc7clgyid6zyfmim"))))
4175 (build-system haskell-build-system)
4176 (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
4178 `(("ghc-base-orphans" ,ghc-base-orphans)
4179 ("ghc-bifunctors" ,ghc-bifunctors)
4180 ("ghc-distributive" ,ghc-distributive)
4181 ("ghc-exceptions" ,ghc-exceptions)
4182 ("ghc-free" ,ghc-free)
4183 ("ghc-kan-extensions" ,ghc-kan-extensions)
4184 ("ghc-parallel" ,ghc-parallel)
4185 ("ghc-reflection" ,ghc-reflection)
4186 ("ghc-semigroupoids" ,ghc-semigroupoids)
4187 ("ghc-vector" ,ghc-vector)))
4189 `(("ghc-comonad" ,ghc-comonad)
4190 ("ghc-contravariant" ,ghc-contravariant)
4191 ("ghc-hashable" ,ghc-hashable)
4192 ("ghc-mtl" ,ghc-mtl)
4193 ("ghc-profunctors" ,ghc-profunctors)
4194 ("ghc-semigroups" ,ghc-semigroups)
4195 ("ghc-tagged" ,ghc-tagged)
4196 ("ghc-text" ,ghc-text)
4197 ("ghc-transformers-compat" ,ghc-transformers-compat)
4198 ("ghc-unordered-containers" ,ghc-unordered-containers)
4199 ("ghc-void" ,ghc-void)
4200 ("ghc-generic-deriving" ,ghc-generic-deriving)
4201 ("ghc-nats" ,ghc-nats)
4202 ("ghc-simple-reflect" ,ghc-simple-reflect)
4204 (home-page "http://github.com/ekmett/lens/")
4205 (synopsis "Lenses, Folds and Traversals")
4206 (description "This library provides @code{Control.Lens}. The combinators
4207 in @code{Control.Lens} provide a highly generic toolbox for composing families
4208 of getters, folds, isomorphisms, traversals, setters and lenses and their
4212 (define-public ghc-tagsoup
4214 (name "ghc-tagsoup")
4220 "http://hackage.haskell.org/package/tagsoup/tagsoup-"
4225 "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j"))))
4226 (build-system haskell-build-system)
4227 (inputs `(("ghc-text" ,ghc-text)))
4229 "http://community.haskell.org/~ndm/tagsoup/")
4231 "Parsing and extracting information from (possibly malformed) HTML/XML
4234 "TagSoup is a library for parsing HTML/XML. It supports the HTML 5
4235 specification, and can be used to parse either well-formed XML, or
4236 unstructured and malformed HTML from the web. The library also provides
4237 useful functions to extract information from an HTML document, making it ideal
4238 for screen-scraping.")
4241 (define-public ghc-digest
4249 "http://hackage.haskell.org/package/digest/digest-"
4254 "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4"))))
4255 (build-system haskell-build-system)
4259 "http://hackage.haskell.org/package/digest")
4261 "Various cryptographic hashes for bytestrings")
4263 "This package provides efficient cryptographic hash implementations for
4264 strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they
4265 are implemented as FFI bindings to efficient code from zlib.")
4268 (define-public ghc-cheapskate
4270 (name "ghc-cheapskate")
4276 "http://hackage.haskell.org/package/cheapskate/cheapskate-"
4281 "0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2"))))
4282 (build-system haskell-build-system)
4284 `(("ghc-xss-sanitize" ,ghc-xss-sanitize)
4285 ("ghc-data-default" ,ghc-data-default)))
4287 `(("ghc-mtl" ,ghc-mtl)
4288 ("ghc-text" ,ghc-text)
4289 ("ghc-blaze-html" ,ghc-blaze-html)
4290 ("ghc-syb" ,ghc-syb)
4291 ("ghc-uniplate" ,ghc-uniplate)
4292 ("ghc-aeson" ,ghc-aeson)
4293 ("ghc-wai-extra" ,ghc-wai-extra)
4294 ("ghc-wai" ,ghc-wai)
4295 ("ghc-http-types" ,ghc-http-types)))
4296 (home-page "http://github.com/jgm/cheapskate")
4297 (synopsis "Experimental markdown processor")
4298 (description "Cheapskate is an experimental Markdown processor in pure
4299 Haskell. It aims to process Markdown efficiently and in the most forgiving
4300 possible way. It is designed to deal with any input, including garbage, with
4301 linear performance. Output is sanitized by default for protection against XSS
4305 (define-public ghc-bifunctors
4307 (name "ghc-bifunctors")
4313 "http://hackage.haskell.org/package/bifunctors/bifunctors-"
4318 "13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1"))))
4319 (build-system haskell-build-system)
4321 `(("ghc-tagged" ,ghc-tagged)
4322 ("ghc-semigroups" ,ghc-semigroups)))
4323 (home-page "http://github.com/ekmett/bifunctors/")
4324 (synopsis "Bifunctors for Haskell")
4325 (description "This package provides bifunctors for Haskell.")
4328 (define-public ghc-semigroupoids
4330 (name "ghc-semigroupoids")
4336 "http://hackage.haskell.org/package/semigroupoids/semigroupoids-"
4341 "1jf7jnfhdvl6p18wdr21yi2fim1xb8alcn6szhrdswj0dkilgq6d"))))
4342 (build-system haskell-build-system)
4344 `(("ghc-base-orphans" ,ghc-base-orphans)
4345 ("ghc-transformers-compat" ,ghc-transformers-compat)
4346 ("ghc-bifunctors" ,ghc-bifunctors)
4347 ("ghc-comonad" ,ghc-comonad)
4348 ("ghc-contravariant" ,ghc-contravariant)
4349 ("ghc-distributive" ,ghc-distributive)))
4350 (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
4352 `(("ghc-semigroups" ,ghc-semigroups)
4353 ("ghc-tagged" ,ghc-tagged)))
4354 (home-page "http://github.com/ekmett/semigroupoids")
4355 (synopsis "Semigroupoids operations for Haskell")
4356 (description "This library provides a wide array of (semi)groupoids and
4357 operations for working with them. A @code{Semigroupoid} is a @code{Category}
4358 without the requirement of identity arrows for every object in the category.
4359 A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
4360 Finally, to work with these weaker structures it is beneficial to have
4361 containers that can provide stronger guarantees about their contents, so
4362 versions of @code{Traversable} and @code{Foldable} that can be folded with
4363 just a @code{Semigroup} are added.")
4366 (define-public ghc-contravariant
4368 (name "ghc-contravariant")
4374 "http://hackage.haskell.org/package/contravariant/contravariant-"
4379 "184hcmhsznqrkmqlc1kza9pb5p591anva574ry8wrh81vqmhwfb5"))))
4380 (build-system haskell-build-system)
4382 `(("ghc-void" ,ghc-void)
4383 ("ghc-transformers-compat" ,ghc-transformers-compat)
4384 ("ghc-statevar" ,ghc-statevar)))
4386 `(("ghc-semigroups" ,ghc-semigroups)))
4388 "http://github.com/ekmett/contravariant/")
4389 (synopsis "Contravariant functors")
4390 (description "Contravariant functors for Haskell.")
4393 (define-public ghc-semigroups
4395 (name "ghc-semigroups")
4396 (version "0.17.0.1")
4401 "http://hackage.haskell.org/package/semigroups/semigroups-"
4406 "0gvpfi7s6ys4qha3y9a1zl1a15gf9cgg33wjb94ghg82ivcxnc3r"))))
4407 (build-system haskell-build-system)
4409 `(("ghc-nats" ,ghc-nats)
4410 ("ghc-tagged" ,ghc-tagged)
4411 ("ghc-unordered-containers" ,ghc-unordered-containers)))
4413 `(("ghc-text" ,ghc-text)
4414 ("ghc-hashable" ,ghc-hashable)))
4415 (home-page "http://github.com/ekmett/semigroups/")
4416 (synopsis "Semigroup operations for Haskell")
4417 (description "This package provides semigroups for Haskell. In
4418 mathematics, a semigroup is an algebraic structure consisting of a set
4419 together with an associative binary operation. A semigroup generalizes a
4420 monoid in that there might not exist an identity element. It
4421 also (originally) generalized a group (a monoid with all inverses) to a type
4422 where every element did not have to have an inverse, thus the name
4426 (define-public ghc-free
4434 "http://hackage.haskell.org/package/free/free-"
4439 "0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p"))))
4440 (build-system haskell-build-system)
4442 `(("ghc-prelude-extras" ,ghc-prelude-extras)
4443 ("ghc-profunctors" ,ghc-profunctors)
4444 ("ghc-exceptions" ,ghc-exceptions)))
4446 `(("ghc-bifunctors" ,ghc-bifunctors)
4447 ("ghc-comonad" ,ghc-comonad)
4448 ("ghc-distributive" ,ghc-distributive)
4449 ("ghc-mtl" ,ghc-mtl)
4450 ("ghc-semigroupoids" ,ghc-semigroupoids)
4451 ("ghc-semigroups" ,ghc-semigroups)))
4452 (home-page "http://github.com/ekmett/free/")
4453 (synopsis "Unrestricted monads for Haskell")
4454 (description "This library provides free monads, which are useful for many
4455 tree-like structures and domain specific languages. If @code{f} is a
4456 @code{Functor} then the free @code{Monad} on @code{f} is the type of trees
4457 whose nodes are labeled with the constructors of @code{f}. The word \"free\"
4458 is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
4459 f} makes no constraining assumptions beyond those given by @code{f} and the
4460 definition of @code{Monad}.")
4463 (define-public ghc-adjunctions
4465 (name "ghc-adjunctions")
4471 "http://hackage.haskell.org/package/adjunctions/adjunctions-"
4476 "00p030iypjzjib8pxz1x6mxfi59wvyrwjj11zv9bh766dgkdbwjq"))))
4477 (build-system haskell-build-system)
4479 `(("ghc-profunctors" ,ghc-profunctors)))
4481 `(("ghc-comonad" ,ghc-comonad)
4482 ("ghc-contravariant" ,ghc-contravariant)
4483 ("ghc-distributive" ,ghc-distributive)
4484 ("ghc-free" ,ghc-free)
4485 ("ghc-mtl" ,ghc-mtl)
4486 ("ghc-tagged" ,ghc-tagged)
4487 ("ghc-semigroupoids" ,ghc-semigroupoids)
4488 ("ghc-semigroups" ,ghc-semigroups)
4489 ("ghc-void" ,ghc-void)))
4490 (home-page "http://github.com/ekmett/adjunctions/")
4491 (synopsis "Adjunctions and representable functors")
4492 (description "This library provides adjunctions and representable functors
4496 (define-public ghc-fast-logger
4498 (name "ghc-fast-logger")
4504 "http://hackage.haskell.org/package/fast-logger/fast-logger-"
4509 "0kjk1861qcls8m8y7i55msfpprws5wk6c5mxzi35g2qbl2sih4p5"))))
4510 (build-system haskell-build-system)
4512 `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
4513 ("ghc-auto-update" ,ghc-auto-update)))
4515 `(("ghc-hspec" ,ghc-hspec)
4516 ("ghc-text" ,ghc-text)))
4517 (home-page "https://hackage.haskell.org/package/fast-logger")
4518 (synopsis "Fast logging system")
4519 (description "This library provides a fast logging system for Haskell.")
4522 (define-public ghc-doctest
4524 (name "ghc-doctest")
4530 "http://hackage.haskell.org/package/doctest/doctest-"
4535 "1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm"))))
4536 (build-system haskell-build-system)
4537 (arguments `(#:tests? #f)) ; FIXME: missing test framework
4539 `(("ghc-syb" ,ghc-syb)
4540 ("ghc-paths" ,ghc-paths)))
4542 `(("ghc-base-compat" ,ghc-base-compat)
4543 ("ghc-hunit" ,ghc-hunit)
4544 ("ghc-hspec" ,ghc-hspec)
4545 ("ghc-quickcheck" ,ghc-quickcheck)
4546 ("ghc-stringbuilder" ,ghc-stringbuilder)
4547 ("ghc-silently" ,ghc-silently)
4548 ("ghc-setenv" ,ghc-setenv)))
4550 "https://github.com/sol/doctest#readme")
4551 (synopsis "Test interactive Haskell examples")
4552 (description "The doctest program checks examples in source code comments.
4553 It is modeled after doctest for Python, see
4554 @uref{http://docs.python.org/library/doctest.html, the Doctest website}.")
4557 (define-public ghc-lifted-base
4559 (name "ghc-lifted-base")
4565 "http://hackage.haskell.org/package/lifted-base/lifted-base-"
4570 "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap"))))
4571 (build-system haskell-build-system)
4572 (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
4574 `(("ghc-transformers-base" ,ghc-transformers-base)
4575 ("ghc-monad-control" ,ghc-monad-control)))
4577 `(("ghc-transformers-compat" ,ghc-transformers-compat)
4578 ("ghc-hunit" ,ghc-hunit)))
4579 (home-page "https://github.com/basvandijk/lifted-base")
4580 (synopsis "Lifted IO operations from the base library")
4581 (description "Lifted-base exports IO operations from the @code{base}
4582 library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
4583 Note that not all modules from @code{base} are converted yet. The package
4584 includes a copy of the @code{monad-peel} test suite written by Anders
4588 (define-public ghc-word8
4596 "http://hackage.haskell.org/package/word8/word8-"
4601 "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw"))))
4602 (build-system haskell-build-system)
4604 `(("ghc-hspec" ,ghc-hspec)))
4605 (home-page "http://hackage.haskell.org/package/word8")
4606 (synopsis "Word8 library for Haskell")
4607 (description "Word8 library to be used with @code{Data.ByteString}.")
4610 (define-public ghc-stringsearch
4612 (name "ghc-stringsearch")
4618 "http://hackage.haskell.org/package/stringsearch/stringsearch-"
4623 "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
4624 (build-system haskell-build-system)
4625 (home-page "https://bitbucket.org/dafis/stringsearch")
4626 (synopsis "Fast searching, splitting and replacing of ByteStrings")
4627 (description "This package provides several functions to quickly search
4628 for substrings in strict or lazy @code{ByteStrings}. It also provides
4629 functions for breaking or splitting on substrings and replacing all
4630 occurrences of a substring (the first in case of overlaps) with another.")
4633 (define-public ghc-tasty-quickcheck
4635 (name "ghc-tasty-quickcheck")
4641 "http://hackage.haskell.org/package/tasty-quickcheck/"
4642 "tasty-quickcheck-" version ".tar.gz"))
4645 "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
4646 (build-system haskell-build-system)
4648 `(("ghc-quickcheck" ,ghc-quickcheck)))
4650 `(("ghc-tagged" ,ghc-tagged)
4651 ("ghc-tasty" ,ghc-tasty)
4652 ("ghc-random" ,ghc-random)
4653 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
4654 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4655 ("ghc-pcre-light" ,ghc-pcre-light)))
4656 (home-page "http://documentup.com/feuerbach/tasty")
4657 (synopsis "QuickCheck support for the Tasty test framework")
4658 (description "This package provides QuickCheck support for the Tasty
4659 Haskell test framework.")
4662 (define-public ghc-tasty-golden
4664 (name "ghc-tasty-golden")
4670 "http://hackage.haskell.org/package/tasty-golden/tasty-golden-"
4675 "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
4676 (build-system haskell-build-system)
4678 `(("ghc-temporary" ,ghc-temporary)))
4680 `(("ghc-tasty" ,ghc-tasty)
4681 ("ghc-mtl" ,ghc-mtl)
4682 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
4683 ("ghc-tagged" ,ghc-tagged)
4684 ("ghc-async" ,ghc-async)
4685 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4686 ("ghc-temporary-rc" ,ghc-temporary-rc)))
4688 "https://github.com/feuerbach/tasty-golden")
4689 (synopsis "Golden tests support for tasty")
4691 "This package provides support for 'golden testing'. A golden test is an
4692 IO action that writes its result to a file. To pass the test, this output
4693 file should be identical to the corresponding 'golden' file, which contains
4694 the correct result for the test.")
4697 (define-public ghc-tasty
4700 (version "0.11.0.1")
4705 "http://hackage.haskell.org/package/tasty/tasty-"
4710 "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
4711 (build-system haskell-build-system)
4713 `(("ghc-stm" ,ghc-stm)
4714 ("ghc-mtl" ,ghc-mtl)
4715 ("ghc-tagged" ,ghc-tagged)
4716 ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
4717 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
4718 ("ghc-unbounded-delays" ,ghc-unbounded-delays)
4719 ("ghc-async" ,ghc-async)
4720 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
4721 ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
4722 (home-page "http://documentup.com/feuerbach/tasty")
4723 (synopsis "Modern and extensible testing framework")
4724 (description "Tasty is a modern testing framework for Haskell. It lets
4725 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
4726 and any other types of tests into a single test suite.")
4729 (define-public ghc-tasty-hunit
4731 (name "ghc-tasty-hunit")
4737 "http://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
4742 "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
4743 (build-system haskell-build-system)
4745 `(("ghc-tasty" ,ghc-tasty)))
4746 (home-page "http://documentup.com/feuerbach/tasty")
4747 (synopsis "HUnit support for the Tasty test framework")
4748 (description "This package provides HUnit support for the Tasty Haskell
4752 (define-public ghc-cookie
4760 "http://hackage.haskell.org/package/cookie/cookie-"
4765 "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
4766 (build-system haskell-build-system)
4768 `(("ghc-old-locale" ,ghc-old-locale)))
4770 `(("ghc-blaze-builder" ,ghc-blaze-builder)
4771 ("ghc-text" ,ghc-text)
4772 ("ghc-data-default-class" ,ghc-data-default-class)
4773 ("ghc-hunit" ,ghc-hunit)
4774 ("ghc-quickcheck" ,ghc-quickcheck)
4775 ("ghc-tasty" ,ghc-tasty)
4776 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4777 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
4778 (home-page "http://github.com/snoyberg/cookie")
4779 (synopsis "HTTP cookie parsing and rendering")
4780 (description "HTTP cookie parsing and rendering library for Haskell.")
4783 (define-public ghc-scientific
4785 (name "ghc-scientific")
4791 "http://hackage.haskell.org/package/scientific/scientific-"
4796 "0mimdkva0cgzaychr6whv9if29z0r5wwhkss9bmd4rz8kq1kgngn"))))
4797 (build-system haskell-build-system)
4799 `(("ghc-hashable" ,ghc-hashable)
4800 ("ghc-vector" ,ghc-vector)))
4802 `(("ghc-text" ,ghc-text)
4803 ("ghc-tasty" ,ghc-tasty)
4804 ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
4805 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4806 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
4807 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
4808 ("ghc-smallcheck" ,ghc-smallcheck)
4809 ("ghc-quickcheck" ,ghc-quickcheck)))
4810 (home-page "https://github.com/basvandijk/scientific")
4811 (synopsis "Numbers represented using scientific notation")
4812 (description "This package provides @code{Data.Scientific}, which provides
4813 the number type @code{Scientific}. Scientific numbers are arbitrary precision
4814 and space efficient. They are represented using
4815 @uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific
4819 (define-public ghc-aeson
4822 (version "0.10.0.0")
4827 "http://hackage.haskell.org/package/aeson/aeson-"
4832 "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
4833 (build-system haskell-build-system)
4834 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
4836 `(("ghc-attoparsec" ,ghc-attoparsec)
4837 ("ghc-dlist" ,ghc-dlist)
4838 ("ghc-mtl" ,ghc-mtl)
4839 ("ghc-scientific" ,ghc-scientific)
4840 ("ghc-syb" ,ghc-syb)
4841 ("ghc-unordered-containers" ,ghc-unordered-containers)
4842 ("ghc-vector" ,ghc-vector)))
4844 `(("ghc-hashable" ,ghc-hashable)
4845 ("ghc-text" ,ghc-text)
4846 ("ghc-hunit" ,ghc-hunit)
4847 ("ghc-quickcheck" ,ghc-quickcheck)))
4848 (home-page "https://github.com/bos/aeson")
4849 (synopsis "Fast JSON parsing and encoding")
4850 (description "This package provides a JSON parsing and encoding library
4851 for Haskell, optimized for ease of use and high performance. (A note on
4852 naming: in Greek mythology, Aeson was the father of Jason.)")
4855 (define-public ghc-wai
4863 "http://hackage.haskell.org/package/wai/wai-"
4868 "1551n0g0n22vml33v0jz5xgjcy6j79algvsdqg11a1z5ljjrjlqf"))))
4869 (build-system haskell-build-system)
4871 `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
4872 ("ghc-unix-compat" ,ghc-unix-compat)
4873 ("ghc-vault" ,ghc-vault)
4874 ("ghc-blaze-builder" ,ghc-blaze-builder)
4875 ("ghc-network" ,ghc-network)))
4877 `(("ghc-quickcheck" ,ghc-quickcheck)
4878 ("ghc-hunit" ,ghc-hunit)
4879 ("ghc-hspec" ,ghc-hspec)
4880 ("ghc-text" ,ghc-text)
4881 ("ghc-http-types" ,ghc-http-types)))
4882 (home-page "https://hackage.haskell.org/package/wai")
4883 (synopsis "Web application interface for Haskell")
4884 (description "This package provides a Web Application Interface (WAI)
4885 library for the Haskell language. It defines a common protocol for
4886 communication between web applications and web servers.")
4889 (define-public ghc-wai-logger
4891 (name "ghc-wai-logger")
4897 "http://hackage.haskell.org/package/wai-logger/wai-logger-"
4902 "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
4903 (build-system haskell-build-system)
4904 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
4905 ; by propagated-inputs.
4907 `(("ghc-auto-update" ,ghc-auto-update)
4908 ("ghc-byteorder" ,ghc-byteorder)
4909 ("ghc-easy-file" ,ghc-easy-file)
4910 ("ghc-unix-time" ,ghc-unix-time)))
4912 `(("ghc-blaze-builder" ,ghc-blaze-builder)
4913 ("ghc-case-insensitive" ,ghc-case-insensitive)
4914 ("ghc-fast-logger" ,ghc-fast-logger)
4915 ("ghc-http-types" ,ghc-http-types)
4916 ("ghc-network" ,ghc-network)
4917 ("ghc-wai" ,ghc-wai)))
4918 (home-page "http://hackage.haskell.org/package/wai-logger")
4919 (synopsis "Logging system for WAI")
4920 (description "This package provides the logging system for WAI.")
4923 (define-public ghc-wai-extra
4925 (name "ghc-wai-extra")
4926 (version "3.0.11.1")
4931 "http://hackage.haskell.org/package/wai-extra/wai-extra-"
4936 "1kr2s5qyx1dvnwr372h7pca4sgxjv0pdx96xkgsfi180h3mb0vq8"))))
4937 (build-system haskell-build-system)
4939 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
4940 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
4941 ("ghc-cookie" ,ghc-cookie)
4942 ("ghc-blaze-builder" ,ghc-blaze-builder)
4943 ("ghc-network" ,ghc-network)
4944 ("ghc-lifted-base" ,ghc-lifted-base)
4945 ("ghc-streaming-commons" ,ghc-streaming-commons)
4946 ("ghc-stringsearch" ,ghc-stringsearch)
4947 ("ghc-resourcet" ,ghc-resourcet)
4948 ("ghc-fast-logger" ,ghc-fast-logger)
4949 ("ghc-wai-logger" ,ghc-wai-logger)
4950 ("ghc-zlib" ,ghc-zlib)
4951 ("ghc-word8" ,ghc-word8)
4952 ("ghc-iproute" ,ghc-iproute)
4953 ("ghc-void" ,ghc-void)))
4955 `(("ghc-wai" ,ghc-wai)
4956 ("ghc-http-types" ,ghc-http-types)
4957 ("ghc-text" ,ghc-text)
4958 ("ghc-case-insensitive" ,ghc-case-insensitive)
4959 ("ghc-data-default-class" ,ghc-data-default-class)
4960 ("ghc-unix-compat" ,ghc-unix-compat)
4961 ("ghc-vault" ,ghc-vault)
4962 ("ghc-aeson" ,ghc-aeson)
4963 ("ghc-hspec" ,ghc-hspec)
4964 ("ghc-hunit" ,ghc-hunit)))
4965 (home-page "http://github.com/yesodweb/wai")
4966 (synopsis "Some basic WAI handlers and middleware")
4967 (description "This library provides basic WAI handlers and middleware
4971 (define-public ghc-deepseq-generics
4973 (name "ghc-deepseq-generics")
4977 (uri (string-append "http://hackage.haskell.org/package/"
4978 "deepseq-generics/deepseq-generics-"
4982 "01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3"))))
4983 (build-system haskell-build-system)
4986 (modify-phases %standard-phases
4987 (add-after 'unpack 'relax-ghc-prim-dependency
4989 (substitute* "deepseq-generics.cabal"
4990 (("< 0.4") "< 0.5"))
4993 `(("ghc-hunit" ,ghc-hunit)
4994 ("ghc-test-framework" ,ghc-test-framework)
4995 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
4996 (home-page "https://github.com/hvr/deepseq-generics")
4997 (synopsis "Generic RNF implementation")
4999 "This package provides a @code{GHC.Generics}-based
5000 @code{Control.DeepSeq.Generics.genericRnf} function which can be used for
5001 providing an 'rnf' implementation.")
5004 (define-public ghc-pandoc-types
5006 (name "ghc-pandoc-types")
5007 (version "1.12.4.7")
5010 (uri (string-append "http://hackage.haskell.org/package/"
5011 "pandoc-types/pandoc-types-"
5015 "108n11kbdaj2ii3cyf0xczhsx90p1gjbxwqp1f0wyn2m3cls632n"))))
5016 (build-system haskell-build-system)
5018 `(("ghc-syb" ,ghc-syb)
5019 ("ghc-aeson" ,ghc-aeson)
5020 ("ghc-deepseq-generics" ,ghc-deepseq-generics)))
5021 (home-page "http://johnmacfarlane.net/pandoc")
5022 (synopsis "Types for representing a structured document")
5024 "This module defines the @code{Pandoc} data structure, which is used by
5025 pandoc to represent structured documents. It also provides functions for
5026 building up, manipulating and serialising @code{Pandoc} structures.")
5029 (define-public ghc-texmath
5031 (name "ghc-texmath")
5035 (uri (string-append "http://hackage.haskell.org/package/"
5036 "texmath/texmath-" version ".tar.gz"))
5039 "15821jg64fbr4rwaglp5ksah6q8qqz1vkjxlqp6d3bbb1rj8v2ri"))))
5040 (build-system haskell-build-system)
5042 `(("ghc-syb" ,ghc-syb)
5043 ("ghc-network-uri" ,ghc-network-uri)
5044 ("ghc-split" ,ghc-split)
5045 ("ghc-temporary" ,ghc-temporary)
5046 ("ghc-utf8-string" ,ghc-utf8-string)
5047 ("ghc-xml" ,ghc-xml)
5048 ("ghc-parsec" ,ghc-parsec)
5049 ("ghc-mtl" ,ghc-mtl)
5050 ("ghc-pandoc-types" ,ghc-pandoc-types)))
5051 (home-page "http://github.com/jgm/texmath")
5052 (synopsis "Conversion between formats used to represent mathematics")
5054 "The texmath library provides functions to read and write TeX math,
5055 presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
5056 Office). Support is also included for converting math formats to pandoc's
5057 native format (allowing conversion, via pandoc, to a variety of different
5058 markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
5059 it can parse and apply LaTeX macros.")
5062 (define-public ghc-regex-pcre-builtin
5064 (name "ghc-regex-pcre-builtin")
5065 (version "0.94.4.8.8.35")
5068 (uri (string-append "http://hackage.haskell.org/package/"
5069 "regex-pcre-builtin/regex-pcre-builtin-"
5073 "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
5074 (build-system haskell-build-system)
5076 `(("ghc-regex-base" ,ghc-regex-base)))
5077 (home-page "http://hackage.haskell.org/package/regex-pcre")
5078 (synopsis "Enhancement of the builtin Text.Regex library")
5080 "This package is an enhancement of the @code{Text.Regex} library,
5081 providing the PCRE backend to accompany regex-base, with bundled code from
5082 @url{http://www.pcre.org}.")
5085 (define-public ghc-diff
5091 (uri (string-append "http://hackage.haskell.org/package/"
5092 "Diff/Diff-" version ".tar.gz"))
5095 "13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz"))))
5096 (build-system haskell-build-system)
5097 (home-page "http://hub.darcs.net/sterlingclover/Diff")
5098 (synopsis "O(ND) diff algorithm in Haskell")
5100 "This package provides an implementation of the standard diff algorithm,
5101 and utilities for pretty printing.")
5104 (define-public ghc-highlighting-kate
5106 (name "ghc-highlighting-kate")
5110 (uri (string-append "http://hackage.haskell.org/package/"
5111 "highlighting-kate/highlighting-kate-"
5115 "16334fbiyq6017zbgc59qc00h0bk24xh4dcrbqx63dvf72ac37dk"))))
5116 (build-system haskell-build-system)
5118 `(("ghc-diff" ,ghc-diff)
5119 ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
5121 `(("ghc-parsec" ,ghc-parsec)
5122 ("ghc-blaze-html" ,ghc-blaze-html)
5123 ("ghc-utf8-string" ,ghc-utf8-string)
5124 ("ghc-mtl" ,ghc-mtl)))
5125 (home-page "http://github.com/jgm/highlighting-kate")
5126 (synopsis "Syntax highlighting library")
5128 "Highlighting-kate is a syntax highlighting library with support for
5129 nearly one hundred languages. The syntax parsers are automatically generated
5130 from @uref{http://kate-editor.org/, Kate syntax descriptions}, so any syntax
5131 supported by Kate can be added. An (optional) command-line program is
5132 provided, along with a utility for generating new parsers from Kate XML syntax
5136 (define-public ghc-cmark
5142 (uri (string-append "http://hackage.haskell.org/package/"
5143 "cmark/cmark-" version ".tar.gz"))
5146 "0c134qh65viaq4q6pv7bnnr5wchzivg94nv0dj8pc1326sx0dw12"))))
5147 (build-system haskell-build-system)
5149 `(("ghc-text" ,ghc-text)))
5151 `(("ghc-hunit" ,ghc-hunit)))
5152 (home-page "https://github.com/jgm/commonmark-hs")
5153 (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
5155 "This package provides Haskell bindings for
5156 @uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
5157 CommonMark, a fully specified variant of Markdown. It includes sources for
5158 libcmark (0.21.0) and does not require prior installation of the C library.")
5161 (define-public ghc-executable-path
5163 (name "ghc-executable-path")
5167 (uri (string-append "http://hackage.haskell.org/package/"
5168 "executable-path/executable-path-"
5172 "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc"))))
5173 (build-system haskell-build-system)
5174 (home-page "http://hackage.haskell.org/package/executable-path")
5175 (synopsis "Find out the full path of the executable")
5177 "The documentation of @code{System.Environment.getProgName} says that
5178 \"However, this is hard-to-impossible to implement on some non-Unix OSes, so
5179 instead, for maximum portability, we just return the leafname of the program
5180 as invoked.\" This library tries to provide the missing path.")
5181 (license public-domain)))
5183 (define-public ghc-enclosed-exceptions
5185 (name "ghc-enclosed-exceptions")
5189 (uri (string-append "http://hackage.haskell.org/package/"
5190 "enclosed-exceptions/enclosed-exceptions-"
5194 "16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5"))))
5195 (build-system haskell-build-system)
5197 `(("ghc-lifted-base" ,ghc-lifted-base)
5198 ("ghc-monad-control" ,ghc-monad-control)
5199 ("ghc-async" ,ghc-async)
5200 ("ghc-transformers-base" ,ghc-transformers-base)))
5202 `(("ghc-hspec" ,ghc-hspec)
5203 ("ghc-quickcheck" ,ghc-quickcheck)))
5204 (home-page "https://github.com/jcristovao/enclosed-exceptions")
5205 (synopsis "Catch all exceptions from within an enclosed computation")
5207 "This library implements a technique to catch all exceptions raised
5208 within an enclosed computation, while remaining responsive to (external)
5209 asynchronous exceptions.")
5212 (define-public ghc-packedstring
5214 (name "ghc-packedstring")
5218 (uri (string-append "http://hackage.haskell.org/package/"
5219 "packedstring/packedstring-"
5223 "1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8"))))
5224 (build-system haskell-build-system)
5227 (modify-phases %standard-phases
5228 (add-after 'unpack 'enable-extension
5230 ;; This package won't compile without the StandaloneDeriving
5232 (substitute* "packedstring.cabal"
5233 (("CPP") "CPP, StandaloneDeriving"))
5235 (home-page "http://hackage.haskell.org/package/packedstring")
5236 (synopsis "Library for packed strings")
5238 "This deprecated library provides an implementation of packed strings.")
5241 (define-public ghc-th-lift
5243 (name "ghc-th-lift")
5247 (uri (string-append "http://hackage.haskell.org/package/"
5248 "th-lift/th-lift-" version ".tar.gz"))
5251 "13xdkk1chdghf059sfx8d3d8r0mj1dbzdi5kf2zf0mjmz3qq7m7k"))))
5252 (build-system haskell-build-system)
5254 `(("ghc-packedstring" ,ghc-packedstring)))
5255 (home-page "http://github.com/mboes/th-lift")
5256 (synopsis "Derive Template Haskell's Lift class for datatypes")
5258 "This is a Haskell library to derive Template Haskell's Lift class for
5262 (define-public ghc-th-expand-syns
5264 (name "ghc-th-expand-syns")
5268 (uri (string-append "http://hackage.haskell.org/package/"
5269 "th-expand-syns/th-expand-syns-"
5273 "03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j"))))
5274 (build-system haskell-build-system)
5276 `(("ghc-syb" ,ghc-syb)))
5277 (home-page "http://hackage.haskell.org/package/th-expand-syns")
5278 (synopsis "Expands type synonyms in Template Haskell ASTs")
5280 "This package enables users to expand type synonyms in Template Haskell
5281 @dfn{abstract syntax trees} (ASTs).")
5284 (define-public ghc-th-reify-many
5286 (name "ghc-th-reify-many")
5290 (uri (string-append "http://hackage.haskell.org/package/"
5291 "th-reify-many/th-reify-many-"
5295 "00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx"))))
5296 (build-system haskell-build-system)
5298 `(("ghc-mtl" ,ghc-mtl)
5299 ("ghc-safe" ,ghc-safe)
5300 ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
5301 (home-page "http://github.com/mgsloan/th-reify-many")
5302 (synopsis "Recurseively reify template haskell datatype info")
5304 "th-reify-many provides functions for recursively reifying top level
5305 declarations. The main intended use case is for enumerating the names of
5306 datatypes reachable from an initial datatype, and passing these names to some
5307 function which generates instances.")
5310 (define-public ghc-th-orphans
5312 (name "ghc-th-orphans")
5316 (uri (string-append "http://hackage.haskell.org/package/"
5317 "th-orphans/th-orphans-" version ".tar.gz"))
5320 "105y03bxh0a2r69l603i7md17gg1vxs1jj1n40pn5q486lmfxbmx"))))
5321 (build-system haskell-build-system)
5323 `(("ghc-th-lift" ,ghc-th-lift)
5324 ("ghc-th-reify-many" ,ghc-th-reify-many)
5325 ("ghc-mtl" ,ghc-mtl)
5326 ("ghc-generic-deriving" ,ghc-generic-deriving)))
5328 `(("ghc-hspec" ,ghc-hspec)))
5329 (home-page "http://hackage.haskell.org/package/th-orphans")
5330 (synopsis "Orphan instances for TH datatypes")
5332 "This package provides orphan instances for Template Haskell datatypes. In particular,
5333 instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
5334 and @code{Eq} instances. These instances used to live in the haskell-src-meta
5335 package, and that's where the version number started.")
5338 (define-public ghc-haskell-src-meta
5340 (name "ghc-haskell-src-meta")
5341 (version "0.6.0.12")
5344 (uri (string-append "http://hackage.haskell.org/package/"
5345 "haskell-src-meta/haskell-src-meta-"
5349 "1mzbfrfvl6pj8068w3m6alzry1403ir1gmz3czg66n5z198l4dql"))))
5350 (build-system haskell-build-system)
5352 `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
5353 ("ghc-syb" ,ghc-syb)
5354 ("ghc-th-orphans" ,ghc-th-orphans)))
5355 (home-page "http://hackage.haskell.org/package/haskell-src-meta")
5356 (synopsis "Parse source to template-haskell abstract syntax")
5358 "This package provides tools to parse Haskell sources to the
5359 template-haskell abstract syntax.")
5362 (define-public ghc-aeson-qq
5364 (name "ghc-aeson-qq")
5368 (uri (string-append "http://hackage.haskell.org/package/"
5369 "aeson-qq/aeson-qq-" version ".tar.gz"))
5372 "1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
5373 (build-system haskell-build-system)
5375 `(("ghc-base-compat" ,ghc-base-compat)
5376 ("ghc-text" ,ghc-text)
5377 ("ghc-attoparsec" ,ghc-attoparsec)
5378 ("ghc-scientific" ,ghc-scientific)
5379 ("ghc-vector" ,ghc-vector)
5380 ("ghc-aeson" ,ghc-aeson)
5381 ("ghc-parsec" ,ghc-parsec)
5382 ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
5384 `(("ghc-hspec" ,ghc-hspec)))
5385 (home-page "http://github.com/zalora/aeson-qq")
5386 (synopsis "JSON quasiquoter for Haskell")
5388 "aeson-qq provides a JSON quasiquoter for Haskell. This package exposes
5389 the function @code{aesonQQ} that compile-time converts a string representation
5390 of a JSON value into a @code{Data.Aeson.Value}.")
5393 (define-public ghc-conduit
5395 (name "ghc-conduit")
5399 (uri (string-append "http://hackage.haskell.org/package/"
5400 "conduit/conduit-" version ".tar.gz"))
5403 "0aq6wswd5dkhdmy7sjhd99mldpq33dqpgbdcwpm94ahvckqxs7v5"))))
5404 (build-system haskell-build-system)
5406 `(("ghc-exceptions" ,ghc-exceptions)
5407 ("ghc-lifted-base" ,ghc-lifted-base)
5408 ("ghc-mmorph" ,ghc-mmorph)
5409 ("ghc-mtl" ,ghc-mtl)
5410 ("ghc-resourcet" ,ghc-resourcet)
5411 ("ghc-transformers-base" ,ghc-transformers-base)
5412 ("ghc-void" ,ghc-void)))
5414 `(("ghc-quickcheck" ,ghc-quickcheck)
5415 ("ghc-hspec" ,ghc-hspec)
5416 ("ghc-safe" ,ghc-safe)))
5417 (home-page "https://github.com/snoyberg/conduit")
5418 (synopsis "Streaming data library ")
5420 "conduit is a solution to the streaming data problem, allowing for
5421 production, transformation, and consumption of streams of data in constant
5422 memory. It is an alternative to lazy I/O which guarantees deterministic
5423 resource handling, and fits in the same general solution space as
5424 enumerator/iteratee and pipes." )
5427 (define-public ghc-logging-facade
5429 (name "ghc-logging-facade")
5433 (uri (string-append "http://hackage.haskell.org/package/"
5434 "logging-facade/logging-facade-"
5438 "0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y"))))
5439 (build-system haskell-build-system)
5441 `(("ghc-hspec" ,ghc-hspec)))
5442 (home-page "http://hackage.haskell.org/package/logging-facade")
5443 (synopsis "Simple logging abstraction that allows multiple back-ends")
5445 "This package provides a simple logging abstraction that allows multiple
5449 (define-public ghc-mockery
5451 (name "ghc-mockery")
5455 (uri (string-append "http://hackage.haskell.org/package/"
5456 "mockery/mockery-" version ".tar.gz"))
5459 "0m0lp2z63sgkylz5318j53r5hnrkp705qh7nqbb149ir4gy7g1bg"))))
5460 (build-system haskell-build-system)
5462 `(("ghc-temporary" ,ghc-temporary)
5463 ("ghc-logging-facade" ,ghc-logging-facade)))
5465 `(("ghc-hspec" ,ghc-hspec)))
5466 (home-page "http://hackage.haskell.org/package/mockery")
5467 (synopsis "Support functions for automated testing")
5469 "The mockery package provides support functions for automated testing.")
5472 (define-public ghc-yaml
5475 (version "0.8.15.1")
5478 (uri (string-append "http://hackage.haskell.org/package/"
5479 "yaml/yaml-" version ".tar.gz"))
5482 "0v6c435xmgm99zxb30pqr7lhkb2a56wxqp70g4hjz8p7rj0vichx"))))
5483 (build-system haskell-build-system)
5485 `(("ghc-conduit" ,ghc-conduit)
5486 ("ghc-resourcet" ,ghc-resourcet)
5487 ("ghc-aeson" ,ghc-aeson)
5488 ("ghc-unordered-containers" ,ghc-unordered-containers)
5489 ("ghc-vector" ,ghc-vector)
5490 ("ghc-text" ,ghc-text)
5491 ("ghc-attoparsec" ,ghc-attoparsec)
5492 ("ghc-scientific" ,ghc-scientific)
5493 ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
5494 ("ghc-aeson-qq" ,ghc-aeson-qq)
5495 ("ghc-base-compat" ,ghc-base-compat)))
5497 `(("ghc-hspec" ,ghc-hspec)
5498 ("ghc-hunit" ,ghc-hunit)
5499 ("ghc-mockery" ,ghc-mockery)))
5500 (home-page "http://github.com/snoyberg/yaml/")
5501 (synopsis "Parsing and rendering YAML documents")
5503 "This package provides a library to parse and render YAML documents.")
5506 (define-public idris
5509 (version "0.9.19.1")
5513 (uri (string-append "https://hackage.haskell.org/package/idris-"
5514 version "/idris-" version ".tar.gz"))
5517 "10641svdsjlxbxmbvylpia04cz5nn9486lpiay8ibqcrc1792qgc"))
5518 (modules '((guix build utils)))
5520 '(substitute* "idris.cabal"
5521 ;; Package description file has a too-tight version restriction,
5522 ;; rendering it incompatible with GHC 7.10.2. This is fixed
5524 ;; <https://github.com/idris-lang/Idris-dev/issues/2734>.
5525 (("vector < 0.11") "vector < 0.12")))))
5526 (build-system haskell-build-system)
5528 `(#:phases (modify-phases %standard-phases
5529 (add-before 'configure 'patch-cc-command
5531 (setenv "CC" "gcc"))))))
5534 ("ncurses" ,ncurses)
5535 ("ghc-annotated-wl-pprint" ,ghc-annotated-wl-pprint)
5536 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
5537 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
5538 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
5539 ("ghc-blaze-html" ,ghc-blaze-html)
5540 ("ghc-blaze-markup" ,ghc-blaze-markup)
5541 ("ghc-cheapskate" ,ghc-cheapskate)
5542 ("ghc-fingertree" ,ghc-fingertree)
5543 ("ghc-mtl" ,ghc-mtl)
5544 ("ghc-network" ,ghc-network)
5545 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
5546 ("ghc-parsers" ,ghc-parsers)
5547 ("ghc-safe" ,ghc-safe)
5548 ("ghc-split" ,ghc-split)
5549 ("ghc-text" ,ghc-text)
5550 ("ghc-trifecta" ,ghc-trifecta)
5551 ("ghc-uniplate" ,ghc-uniplate)
5552 ("ghc-unordered-containers" ,ghc-unordered-containers)
5553 ("ghc-utf8-string" ,ghc-utf8-string)
5554 ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)
5555 ("ghc-vector" ,ghc-vector)
5556 ("ghc-zip-archive" ,ghc-zip-archive)
5557 ("ghc-zlib" ,ghc-zlib)))
5558 (home-page "http://www.idris-lang.org")
5559 (synopsis "General purpose language with full dependent types")
5560 (description "Idris is a general purpose language with full dependent
5561 types. It is compiled, with eager evaluation. Dependent types allow types to
5562 be predicated on values, meaning that some aspects of a program's behaviour
5563 can be specified precisely in the type. The language is closely related to
5567 ;;; haskell.scm ends here