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 lua)
46 #:use-module (gnu packages multiprecision)
47 #:use-module (gnu packages ncurses)
48 #:use-module (gnu packages python)
49 #:use-module (gnu packages pcre)
50 #:use-module ((gnu packages xml) #:select (libxml2))
51 #:use-module (gnu packages xorg))
53 (define ghc-bootstrap-x86_64-7.8.4
57 "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-x86_64-unknown-linux-deb7.tar.xz")
60 "13azsl53xgj20mi1hj9x0xb32vvcvs6cpmvwx6znxhas7blh0bpn"))))
62 (define ghc-bootstrap-i686-7.8.4
66 "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-i386-unknown-linux-deb7.tar.xz")
69 "0wj5s435j0zgww70bj1d3f6wvnnpzlxwvwcyh2qv4qjq5z8j64kg"))))
71 ;; 43 tests out of 3965 fail.
73 ;; Most of them do not appear to be serious:
75 ;; - some tests generate files referring to "/bin/sh" and "/bin/ls". I've not
76 ;; figured out how these references are generated.
78 ;; - Some tests allocate more memory than expected (ca. 3% above upper limit)
80 ;; - Some tests try to load unavailable libriries: Control.Concurrent.STM,
81 ;; Data.Vector, Control.Monad.State.
83 ;; - Test posix010 tries to check the existence of a user on the system:
84 ;; getUserEntryForName: does not exist (no such user)
92 (uri (string-append "https://www.haskell.org/ghc/dist/"
93 version "/" name "-" version "-src.tar.xz"))
96 "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal"))))
97 (build-system gnu-build-system)
98 (supported-systems '("i686-linux" "x86_64-linux"))
99 (outputs '("out" "doc"))
109 "https://www.haskell.org/ghc/dist/"
110 version "/" name "-" version "-testsuite.tar.xz"))
113 "0qp9da9ar87zbyn6wjgacd2ic1vgzbi3cklxnhsmjqyafv9qaj4b"))))))
116 ("python" ,python-2) ; for tests (fails with python-3)
117 ("ghostscript" ,ghostscript) ; for tests
118 ("patchelf" ,patchelf)
119 ;; GHC is built with GHC. Therefore we need bootstrap binaries.
121 ,(if (string-match "x86_64" (or (%current-target-system) (%current-system)))
122 ghc-bootstrap-x86_64-7.8.4
123 ghc-bootstrap-i686-7.8.4))))
125 `(#:test-target "test"
126 ;; We get a smaller number of test failures by disabling parallel test
130 ;; The DSOs use $ORIGIN to refer to each other, but (guix build
131 ;; gremlin) doesn't support it yet, so skip this phase.
132 #:validate-runpath? #f
134 ;; Don't pass --build=<triplet>, because the configure script
135 ;; auto-detects slightly different triplets for --host and --target and
136 ;; then complains that they don't match.
139 #:modules ((guix build gnu-build-system)
144 #:imported-modules (,@%gnu-build-system-modules
148 (string-append "--with-gmp-libraries="
149 (assoc-ref %build-inputs "gmp") "/lib")
150 (string-append "--with-gmp-includes="
151 (assoc-ref %build-inputs "gmp") "/include")
152 "--with-system-libffi"
153 (string-append "--with-ffi-libraries="
154 (assoc-ref %build-inputs "libffi") "/lib")
155 (string-append "--with-ffi-includes="
156 (assoc-ref %build-inputs "libffi") "/include"))
157 ;; FIXME: The user-guide needs dblatex, docbook-xsl and docbook-utils.
158 ;; Currently we do not have the last one.
160 ;; (list "BUILD_DOCBOOK_HTML = YES")
162 (let* ((ghc-bootstrap-path
163 (string-append (getcwd) "/" ,name "-" ,version "/ghc-bin"))
164 (ghc-bootstrap-prefix
165 (string-append ghc-bootstrap-path "/usr" )))
167 'unpack-bin 'unpack-testsuite-and-fix-bins
168 (lambda* (#:key inputs outputs #:allow-other-keys)
169 (with-directory-excursion ".."
170 (copy-file (assoc-ref inputs "ghc-testsuite")
171 "ghc-testsuite.tar.xz")
172 (system* "tar" "xvf" "ghc-testsuite.tar.xz"))
174 (list "testsuite/timeout/Makefile"
175 "testsuite/timeout/timeout.py"
176 "testsuite/timeout/timeout.hs"
177 "testsuite/tests/rename/prog006/Setup.lhs"
178 "testsuite/tests/programs/life_space_leak/life.test"
179 "libraries/process/System/Process/Internals.hs"
180 "libraries/unix/cbits/execvpe.c")
181 (("/bin/sh") (which "sh"))
186 (lambda* (#:key inputs outputs #:allow-other-keys)
187 (mkdir-p ghc-bootstrap-prefix)
188 (with-directory-excursion ghc-bootstrap-path
189 (copy-file (assoc-ref inputs "ghc-binary")
191 (zero? (system* "tar" "xvf" "ghc-bin.tar.xz"))))
193 'install-bin 'configure-bin
194 (lambda* (#:key inputs outputs #:allow-other-keys)
197 "./utils/ghc-pwd/dist-install/build/tmp/ghc-pwd"
198 "./utils/hpc/dist-install/build/tmp/hpc"
199 "./utils/haddock/dist/build/tmp/haddock"
200 "./utils/hsc2hs/dist-install/build/tmp/hsc2hs"
201 "./utils/runghc/dist-install/build/tmp/runghc"
202 "./utils/ghc-cabal/dist-install/build/tmp/ghc-cabal"
203 "./utils/hp2ps/dist/build/tmp/hp2ps"
204 "./utils/ghc-pkg/dist-install/build/tmp/ghc-pkg"
205 "./utils/unlit/dist/build/tmp/unlit"
206 "./ghc/stage2/build/tmp/ghc-stage2"))
207 (gmp (assoc-ref inputs "gmp"))
208 (gmp-lib (string-append gmp "/lib"))
209 (gmp-include (string-append gmp "/include"))
211 (string-append (assoc-ref inputs "ncurses") "/lib"))
212 (ld-so (string-append (assoc-ref inputs "libc")
213 ,(glibc-dynamic-linker)))
215 (string-append ghc-bootstrap-prefix
216 "/lib/ghc-7.8.4/terminfo-0.4.0.0")))
217 (with-directory-excursion
218 (string-append ghc-bootstrap-path "/ghc-7.8.4")
219 (setenv "CONFIG_SHELL" (which "bash"))
220 (setenv "LD_LIBRARY_PATH" gmp-lib)
221 ;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded.
223 (cut system* "patchelf" "--set-interpreter" ld-so <>)
225 ;; The binaries include a reference to libtinfo.so.5 which
226 ;; is a subset of libncurses.so.5. We create a symlink in a
227 ;; directory included in the bootstrap binaries rpath.
228 (mkdir-p libtinfo-dir)
230 (string-append ncurses-lib "/libncursesw.so."
231 ,(version-major+minor
232 (package-version ncurses)))
233 (string-append libtinfo-dir "/libtinfo.so.5"))
235 (string-append (getenv "PATH") ":"
236 ghc-bootstrap-prefix "/bin"))
238 (string-append (getcwd) "/configure")
239 (string-append "--prefix=" ghc-bootstrap-prefix)
240 (string-append "--with-gmp-libraries=" gmp-lib)
241 (string-append "--with-gmp-includes=" gmp-include)))))
243 'configure 'install-bin
244 (lambda* (#:key inputs outputs #:allow-other-keys)
245 (with-directory-excursion
246 (string-append ghc-bootstrap-path "/ghc-7.8.4")
247 (zero? (system* "make" "install"))))
248 %standard-phases)))))))
249 (home-page "https://www.haskell.org/ghc")
250 (synopsis "The Glasgow Haskell Compiler")
252 "The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
253 interactive environment for the functional language Haskell.")
256 (define-public ghc-hostname
258 (name "ghc-hostname")
263 (uri (string-append "http://hackage.haskell.org/package/hostname/"
264 "hostname-" version ".tar.gz"))
267 "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
268 (build-system haskell-build-system)
269 (home-page "https://hackage.haskell.org/package/hostname")
270 (synopsis "Hostname in Haskell")
271 (description "Network.HostName is a simple package providing a means to
272 determine the hostname.")
275 (define-public ghc-libxml
282 (uri (string-append "http://hackage.haskell.org/package/libxml/"
283 "libxml-" version ".tar.gz"))
286 "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
287 (build-system haskell-build-system)
289 `(("ghc-mtl" ,ghc-mtl)
290 ("libxml2" ,libxml2)))
293 `(,(string-append "--extra-include-dirs="
294 (assoc-ref %build-inputs "libxml2")
295 "/include/libxml2"))))
296 (home-page "http://hackage.haskell.org/package/libxml")
297 (synopsis "Haskell bindings to libxml2")
299 "This library provides minimal Haskell binding to libxml2.")
302 (define-public ghc-prelude-extras
304 (name "ghc-prelude-extras")
310 "http://hackage.haskell.org/package/prelude-extras/prelude-extras-"
315 "1q7mj9hysy747vimnlyrwsk1wb2axymxixa76fwcbcnmz3fi4llp"))))
316 (build-system haskell-build-system)
317 (home-page "http://github.com/ekmett/prelude-extras")
318 (synopsis "Higher order versions of Prelude classes")
319 (description "This library provides higher order versions of
320 @code{Prelude} classes to ease programming with polymorphic recursion and
321 reduce @code{UndecidableInstances}.")
324 (define-public ghc-data-default
326 (name "ghc-data-default")
332 "http://hackage.haskell.org/package/data-default/data-default-"
336 (base32 "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c"))))
337 (build-system haskell-build-system)
339 `(("ghc-data-default-class"
340 ,ghc-data-default-class)
341 ("ghc-data-default-instances-base"
342 ,ghc-data-default-instances-base)
343 ("ghc-data-default-instances-containers"
344 ,ghc-data-default-instances-containers)
345 ("ghc-data-default-instances-dlist"
346 ,ghc-data-default-instances-dlist)
347 ("ghc-data-default-instances-old-locale"
348 ,ghc-data-default-instances-old-locale)))
349 (home-page "http://hackage.haskell.org/package/data-default")
350 (synopsis "Types with default values")
352 "This package defines a class for types with a default value, and
353 provides instances for types from the base, containers, dlist and old-locale
357 (define-public ghc-data-default-class
359 (name "ghc-data-default-class")
365 "http://hackage.haskell.org/package/data-default-class/"
366 "data-default-class-" version ".tar.gz"))
368 (base32 "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d"))))
369 (build-system haskell-build-system)
370 (home-page "http://hackage.haskell.org/package/data-default-class")
371 (synopsis "Types with default values")
373 "This package defines a class for types with default values.")
376 (define-public ghc-data-default-instances-base
378 (name "ghc-data-default-instances-base")
384 "http://hackage.haskell.org/package/"
385 "data-default-instances-base/"
386 "data-default-instances-base-" version ".tar.gz"))
388 (base32 "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb"))))
389 (build-system haskell-build-system)
391 `(("ghc-data-default-class" ,ghc-data-default-class)))
392 (home-page "http://hackage.haskell.org/package/data-default-instances-base")
393 (synopsis "Default instances for types in base")
395 "This package provides default instances for types from the base
399 (define-public ghc-data-default-instances-containers
401 (name "ghc-data-default-instances-containers")
407 "http://hackage.haskell.org/package/"
408 "data-default-instances-containers/"
409 "data-default-instances-containers-" version ".tar.gz"))
411 (base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
412 (build-system haskell-build-system)
414 `(("ghc-data-default-class" ,ghc-data-default-class)))
415 (home-page "http://hackage.haskell.org/package/data-default-instances-containers")
416 (synopsis "Default instances for types in containers")
417 (description "Provides default instances for types from the containers
421 (define-public ghc-data-default-instances-dlist
423 (name "ghc-data-default-instances-dlist")
429 "http://hackage.haskell.org/package/"
430 "data-default-instances-dlist/"
431 "data-default-instances-dlist-" version ".tar.gz"))
433 (base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
434 (build-system haskell-build-system)
436 `(("ghc-data-default-class" ,ghc-data-default-class)
437 ("ghc-dlist" ,ghc-dlist)))
438 (home-page "http://hackage.haskell.org/package/data-default-instances-dlist")
439 (synopsis "Default instances for types in dlist")
440 (description "Provides default instances for types from the dlist
444 (define-public ghc-haddock-library
446 (name "ghc-haddock-library")
452 "http://hackage.haskell.org/package/haddock-library/haddock-library-"
457 "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g"))))
458 (build-system haskell-build-system)
460 `(("ghc-base-compat" ,ghc-base-compat)
461 ("ghc-hspec" ,ghc-hspec)
462 ("ghc-quickcheck" ,ghc-quickcheck)))
463 (home-page "http://www.haskell.org/haddock/")
465 "Library exposing some functionality of Haddock")
467 "Haddock is a documentation-generation tool for Haskell libraries. These
468 modules expose some functionality of it without pulling in the GHC dependency.
469 Please note that the API is likely to change so specify upper bounds in your
470 project if you can't release often. For interacting with Haddock itself, see
471 the ‘haddock’ package.")
474 (define-public ghc-haddock-api
476 (name "ghc-haddock-api")
482 "http://hackage.haskell.org/package/haddock-api/haddock-api-"
487 "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2"))))
488 (build-system haskell-build-system)
490 `(("ghc-paths" ,ghc-paths)
491 ("ghc-haddock-library" ,ghc-haddock-library)))
492 (home-page "http://www.haskell.org/haddock/")
493 (synopsis "API for documentation-generation tool Haddock")
494 (description "This package provides an API to Haddock, the
495 documentation-generation tool for Haskell libraries.")
498 (define-public ghc-haddock
506 "http://hackage.haskell.org/package/haddock/haddock-"
511 "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26"))))
512 (build-system haskell-build-system)
513 (arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed
515 ; <https://github.com/haskell/haddock/issues/427>
516 (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
517 (home-page "http://www.haskell.org/haddock/")
519 "Documentation-generation tool for Haskell libraries")
521 "Haddock is a documentation-generation tool for Haskell libraries.")
524 (define-public ghc-simple-reflect
526 (name "ghc-simple-reflect")
532 "http://hackage.haskell.org/package/simple-reflect/simple-reflect-"
537 "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq"))))
538 (build-system haskell-build-system)
540 "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
542 "Simple reflection of expressions containing variables")
544 "This package allows simple reflection of expressions containing
545 variables. Reflection here means that a Haskell expression is turned into a
546 string. The primary aim of this package is teaching and understanding; there
547 are no options for manipulating the reflected expressions beyond showing
551 (define-public ghc-multipart
553 (name "ghc-multipart")
559 "http://hackage.haskell.org/package/multipart/multipart-"
564 "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
565 (build-system haskell-build-system)
566 (inputs `(("ghc-parsec" ,ghc-parsec)))
568 "http://www.github.com/silkapp/multipart")
570 "HTTP multipart library")
572 "HTTP multipart split out of the cgi package, for Haskell.")
575 (define-public ghc-html
583 "http://hackage.haskell.org/package/html/html-"
588 "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
589 (build-system haskell-build-system)
591 "http://hackage.haskell.org/package/html")
592 (synopsis "HTML combinator library")
594 "This package contains a combinator library for constructing HTML
598 (define-public ghc-xhtml
606 "http://hackage.haskell.org/package/xhtml/xhtml-"
611 "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
612 (build-system haskell-build-system)
613 (home-page "https://github.com/haskell/xhtml")
614 (synopsis "XHTML combinator library")
616 "This package provides combinators for producing XHTML 1.0, including the
617 Strict, Transitional and Frameset variants.")
620 (define-public ghc-haskell-src
622 (name "ghc-haskell-src")
628 "http://hackage.haskell.org/package/haskell-src/haskell-src-"
633 "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a"))))
634 (build-system haskell-build-system)
636 `(("ghc-happy" ,ghc-happy)
637 ("ghc-syb" ,ghc-syb)))
639 "http://hackage.haskell.org/package/haskell-src")
641 "Support for manipulating Haskell source code")
643 "The 'haskell-src' package provides support for manipulating Haskell
644 source code. The package provides a lexer, parser and pretty-printer, and a
645 definition of a Haskell abstract syntax tree (AST). Common uses of this
646 package are to parse or generate Haskell 98 code.")
649 (define-public ghc-alex
657 "http://hackage.haskell.org/package/alex/alex-"
662 "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn"))))
663 (build-system haskell-build-system)
664 (arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10. Fixed
666 ; <https://github.com/simonmar/alex/issues/62>
667 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
668 (home-page "http://www.haskell.org/alex/")
670 "Tool for generating lexical analysers in Haskell")
672 "Alex is a tool for generating lexical analysers in Haskell. It takes a
673 description of tokens based on regular expressions and generates a Haskell
674 module containing code for scanning text efficiently. It is similar to the
675 tool lex or flex for C/C++.")
678 (define-public ghc-cgi
681 (version "3001.2.2.2")
686 "http://hackage.haskell.org/package/cgi/cgi-"
691 "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193"))))
692 (build-system haskell-build-system)
694 `(("ghc-parsec" ,ghc-parsec)
695 ("ghc-old-locale" ,ghc-old-locale)
696 ("ghc-old-time" ,ghc-old-time)
697 ("ghc-exceptions" ,ghc-exceptions)
698 ("ghc-multipart" ,ghc-multipart)
699 ("ghc-network-uri" ,ghc-network-uri)
700 ("ghc-network" ,ghc-network)
701 ("ghc-mtl" ,ghc-mtl)))
703 "https://github.com/cheecheeo/haskell-cgi")
704 (synopsis "Library for writing CGI programs")
706 "This is a Haskell library for writing CGI programs.")
709 (define-public ghc-cmdargs
717 "http://hackage.haskell.org/package/cmdargs/cmdargs-"
722 "0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6"))))
723 (build-system haskell-build-system)
725 "http://community.haskell.org/~ndm/cmdargs/")
726 (synopsis "Command line argument processing")
728 "This library provides an easy way to define command line parsers.")
731 (define-public ghc-happy
739 "http://hackage.haskell.org/package/happy/happy-"
744 "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32"))))
745 (build-system haskell-build-system)
746 (arguments `(#:tests? #f)) ;; cannot satisfy -package mtl. Possible Cabal
749 `(("ghc-mtl" ,ghc-mtl)))
750 (home-page "https://hackage.haskell.org/package/happy")
751 (synopsis "Parser generator for Haskell")
752 (description "Happy is a parser generator for Haskell. Given a grammar
753 specification in BNF, Happy generates Haskell code to parse the grammar.
754 Happy works in a similar way to the yacc tool for C.")
757 (define-public ghc-haskell-src-exts
759 (name "ghc-haskell-src-exts")
765 "http://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
770 "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz"))))
771 (build-system haskell-build-system)
775 ("ghc-happy" ,ghc-happy)
776 ("ghc-syb" ,ghc-syb)))
778 `(("ghc-smallcheck" ,ghc-smallcheck)
779 ("ghc-tasty" ,ghc-tasty)
780 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
781 ("ghc-tasty-golden" ,ghc-tasty-golden)))
782 (home-page "https://github.com/haskell-suite/haskell-src-exts")
783 (synopsis "Library for manipulating Haskell source")
784 (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
785 extension of the standard @code{haskell-src} package, and handles most
786 registered syntactic extensions to Haskell. All extensions implemented in GHC
787 are supported. Apart from these standard extensions, it also handles regular
788 patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
799 "http://hackage.haskell.org/package/" name
800 "/" name "-" version ".tar.gz"))
803 "14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546"))))
804 (build-system haskell-build-system)
807 ("ghc-cmdargs" ,ghc-cmdargs)
808 ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
809 ("ghc-uniplate" ,ghc-uniplate)
810 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
811 ("ghc-extra" ,ghc-extra)
812 ("hscolour" ,hscolour)))
813 (home-page "http://community.haskell.org/~ndm/hlint/")
814 (synopsis "Suggest improvements for Haskell source code")
815 (description "HLint reads Haskell programs and suggests changes that
816 hopefully make them easier to read. HLint also makes it easy to disable
817 unwanted suggestions, and to add your own custom suggestions.")
820 (define-public ghc-resourcet
822 (name "ghc-resourcet")
828 "http://hackage.haskell.org/package/resourcet/resourcet-"
833 "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y"))))
834 (build-system haskell-build-system)
836 `(("ghc-transformers-base" ,ghc-transformers-base)
837 ("ghc-monad-control" ,ghc-monad-control)
838 ("ghc-transformers-compat" ,ghc-transformers-compat)
840 ("ghc-mmorph" ,ghc-mmorph)
841 ("ghc-exceptions" ,ghc-exceptions)))
843 `(("ghc-lifted-base" ,ghc-lifted-base)
844 ("ghc-hspec" ,ghc-hspec)))
845 (home-page "http://github.com/snoyberg/conduit")
846 (synopsis "Deterministic allocation and freeing of scarce resources")
847 (description "ResourceT is a monad transformer which creates a region of
848 code where you can safely allocate resources.")
851 (define-public ghc-xss-sanitize
853 (name "ghc-xss-sanitize")
859 "http://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
864 "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
865 (build-system haskell-build-system)
867 `(("ghc-tagsoup" ,ghc-tagsoup)
868 ("ghc-utf8-string" ,ghc-utf8-string)
869 ("ghc-css-text" ,ghc-css-text)
870 ("ghc-network-uri" ,ghc-network-uri)))
872 `(("ghc-text" ,ghc-text)
873 ("ghc-attoparsec" ,ghc-attoparsec)
874 ("ghc-hspec" ,ghc-hspec)
875 ("ghc-hunit" ,ghc-hunit)))
876 (home-page "http://github.com/yesodweb/haskell-xss-sanitize")
877 (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
878 (description "This library provides @code{sanitizeXSS}. Run untrusted
879 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
883 (define-public ghc-objectname
885 (name "ghc-objectname")
891 "http://hackage.haskell.org/package/ObjectName/ObjectName-"
896 "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg"))))
897 (build-system haskell-build-system)
898 (home-page "https://hackage.haskell.org/package/ObjectName")
899 (synopsis "Helper library for Haskell OpenGL")
900 (description "This tiny package contains the class ObjectName, which
901 corresponds to the general notion of explicitly handled identifiers for API
902 objects, e.g. a texture object name in OpenGL or a buffer object name in
906 (define-public ghc-sdl
914 "http://hackage.haskell.org/package/SDL/SDL-"
919 "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46"))))
920 (build-system haskell-build-system)
923 (home-page "https://hackage.haskell.org/package/SDL")
924 (synopsis "LibSDL for Haskell")
925 (description "Simple DirectMedia Layer (libSDL) is a cross-platform
926 multimedia library designed to provide low level access to audio, keyboard,
927 mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
928 by MPEG playback software, emulators, and many popular games, including the
929 award winning Linux port of \"Civilization: Call To Power.\"")
932 (define-public ghc-sdl-mixer
934 (name "ghc-sdl-mixer")
940 "http://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
945 "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z"))))
946 (build-system haskell-build-system)
949 (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
950 (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
951 (list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
953 `(("ghc-sdl" ,ghc-sdl)))
955 `(("sdl-mixer" ,sdl-mixer)))
956 (home-page "http://hackage.haskell.org/package/SDL-mixer")
957 (synopsis "Haskell bindings to libSDL_mixer")
958 (description "SDL_mixer is a sample multi-channel audio mixer library. It
959 supports any number of simultaneously playing channels of 16 bit stereo audio,
960 plus a single channel of music, mixed by the popular MikMod MOD, Timidity
961 MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
964 (define-public ghc-sdl-image
966 (name "ghc-sdl-image")
972 "http://hackage.haskell.org/package/SDL-image/SDL-image-"
977 "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq"))))
978 (build-system haskell-build-system)
981 (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
982 (sdl-image-include (string-append sdl-image "/include/SDL")))
983 (list (string-append "--extra-include-dirs=" sdl-image-include)))))
985 `(("ghc-sdl" ,ghc-sdl)))
987 `(("sdl-image" ,sdl-image)))
988 (home-page "http://hackage.haskell.org/package/SDL-image")
989 (synopsis "Haskell bindings to libSDL_image")
990 (description "SDL_image is an image file loading library. It loads images
991 as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
992 PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
995 (define-public ghc-half
1003 "http://hackage.haskell.org/package/half/half-"
1008 "0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1"))))
1009 (build-system haskell-build-system)
1010 (home-page "http://github.com/ekmett/half")
1011 (synopsis "Half-precision floating-point computations")
1012 (description "This library provides a half-precision floating-point
1013 computation library for Haskell.")
1016 (define-public ghc-openglraw
1018 (name "ghc-openglraw")
1024 "http://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
1029 "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k"))))
1030 (build-system haskell-build-system)
1032 `(("ghc-half" ,ghc-half)
1034 ("ghc-text" ,ghc-text)))
1035 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1036 (synopsis "Raw Haskell bindings for the OpenGL graphics system")
1037 (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
1038 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
1039 of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
1040 offers access to all necessary functions, tokens and types plus a general
1041 facility for loading extension entries. The module hierarchy closely mirrors
1042 the naming structure of the OpenGL extensions, making it easy to find the
1043 right module to import. All API entries are loaded dynamically, so no special
1044 C header files are needed for building this package. If an API entry is not
1045 found at runtime, a userError is thrown.")
1048 (define-public ghc-glut
1056 "http://hackage.haskell.org/package/GLUT/GLUT-"
1061 "1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2"))))
1062 (build-system haskell-build-system)
1064 `(("ghc-statevar" ,ghc-statevar)
1065 ("ghc-openglraw" ,ghc-openglraw)
1066 ("freeglut" ,freeglut)))
1068 `(("ghc-opengl" ,ghc-opengl)))
1069 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1070 (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
1071 (description "This library provides Haskell bindings for the OpenGL
1072 Utility Toolkit, a window system-independent toolkit for writing OpenGL
1076 (define-public ghc-gluraw
1084 "http://hackage.haskell.org/package/GLURaw/GLURaw-"
1089 "0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x"))))
1090 (build-system haskell-build-system)
1092 `(("ghc-openglraw" ,ghc-openglraw)))
1093 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1094 (synopsis "Raw Haskell bindings GLU")
1095 (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
1096 utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
1097 basis for a nicer interface.")
1100 (define-public ghc-opengl
1103 (version "2.12.0.1")
1108 "http://hackage.haskell.org/package/OpenGL/OpenGL-"
1113 "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b"))))
1114 (build-system haskell-build-system)
1116 `(("ghc-text" ,ghc-text)
1117 ("ghc-objectname" ,ghc-objectname)
1118 ("ghc-gluraw" ,ghc-gluraw)
1119 ("ghc-statevar" ,ghc-statevar)
1120 ("ghc-openglraw" ,ghc-openglraw)))
1121 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1122 (synopsis "Haskell bindings for the OpenGL graphics system")
1123 (description "This package provides Haskell bindings for the OpenGL
1124 graphics system (GL, version 4.5) and its accompanying utility library (GLU,
1128 (define-public ghc-streaming-commons
1130 (name "ghc-streaming-commons")
1131 (version "0.1.14.2")
1136 "http://hackage.haskell.org/package/streaming-commons/streaming-commons-"
1141 "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
1142 (build-system haskell-build-system)
1144 `(("ghc-random" ,ghc-random)))
1146 `(("ghc-quickcheck" ,ghc-quickcheck)
1147 ("ghc-async" ,ghc-async)
1148 ("ghc-blaze-builder" ,ghc-blaze-builder)
1149 ("ghc-hspec" ,ghc-hspec)
1150 ("ghc-stm" ,ghc-stm)
1151 ("ghc-text" ,ghc-text)
1152 ("ghc-network" ,ghc-network)
1153 ("ghc-zlib" ,ghc-zlib)))
1154 (home-page "https://hackage.haskell.org/package/streaming-commons")
1155 (synopsis "Conduit and pipes needed by some streaming data libraries")
1156 (description "Provides low-dependency functionality commonly needed by
1157 various Haskell streaming data libraries, such as @code{conduit} and
1161 (define-public cpphs
1169 "http://hackage.haskell.org/package/" name "/"
1170 name "-" version ".tar.gz"))
1173 "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
1174 (build-system haskell-build-system)
1176 `(("ghc-polyparse" ,ghc-polyparse)
1177 ("ghc-old-locale" ,ghc-old-locale)
1178 ("ghc-old-time" ,ghc-old-time)))
1179 (home-page "http://projects.haskell.org/cpphs/")
1180 (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
1181 (description "Cpphs is a re-implementation of the C pre-processor that is
1182 both more compatible with Haskell, and itself written in Haskell so that it
1183 can be distributed with compilers. This version of the C pre-processor is
1184 pretty-much feature-complete and compatible with traditional (K&R)
1185 pre-processors. Additional features include: a plain-text mode; an option to
1186 unlit literate code files; and an option to turn off macro-expansion.")
1187 (license (list lgpl2.1+ gpl3+))))
1189 (define-public ghc-reflection
1191 (name "ghc-reflection")
1197 "http://hackage.haskell.org/package/reflection/reflection-"
1202 "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
1203 (build-system haskell-build-system)
1204 (inputs `(("ghc-tagged" ,ghc-tagged)))
1205 (home-page "http://github.com/ekmett/reflection")
1206 (synopsis "Reify arbitrary terms into types that can be reflected back
1208 (description "This package addresses the 'configuration problem' which is
1209 propogating configurations that are available at run-time, allowing multiple
1210 configurations to coexist without resorting to mutable global variables or
1211 @code{System.IO.Unsafe.unsafePerformIO}.")
1214 (define-public ghc-old-locale
1216 (name "ghc-old-locale")
1222 "http://hackage.haskell.org/package/old-locale/old-locale-"
1226 (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
1227 (build-system haskell-build-system)
1228 (home-page "http://hackage.haskell.org/package/old-locale")
1229 (synopsis "Adapt to locale conventions")
1231 "This package provides the ability to adapt to locale conventions such as
1232 date and time formats.")
1235 (define-public ghc-old-time
1237 (name "ghc-old-time")
1243 "http://hackage.haskell.org/package/old-time/old-time-"
1248 "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
1249 (build-system haskell-build-system)
1251 `(("ghc-old-locale" ,ghc-old-locale)))
1252 (home-page "http://hackage.haskell.org/package/old-time")
1253 (synopsis "Time compatibility library for Haskell")
1254 (description "Old-time is a package for backwards compatibility with the
1255 old @code{time} library. For new projects, the newer
1256 @uref{http://hackage.haskell.org/package/time, time library} is recommended.")
1259 (define-public ghc-data-default-instances-old-locale
1261 (name "ghc-data-default-instances-old-locale")
1267 "http://hackage.haskell.org/package/"
1268 "data-default-instances-old-locale/"
1269 "data-default-instances-old-locale-" version ".tar.gz"))
1271 (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
1272 (build-system haskell-build-system)
1274 `(("ghc-data-default-class" ,ghc-data-default-class)
1275 ("ghc-old-locale" ,ghc-old-locale)))
1277 "http://hackage.haskell.org/package/data-default-instances-old-locale")
1278 (synopsis "Default instances for types in old-locale")
1279 (description "Provides Default instances for types from the old-locale
1283 (define-public ghc-dlist
1291 "http://hackage.haskell.org/package/dlist/dlist-"
1295 (base32 "10rp96rryij7d8gz5kv8ygc6chm1624ck5mbnqs2a3fkdzqj2b9k"))))
1296 (build-system haskell-build-system)
1298 `(("ghc-quickcheck" ,ghc-quickcheck)))
1299 (home-page "https://github.com/spl/dlist")
1300 (synopsis "Difference lists")
1302 "Difference lists are a list-like type supporting O(1) append. This is
1303 particularly useful for efficient logging and pretty printing (e.g. with the
1304 Writer monad), where list append quickly becomes too expensive.")
1307 (define-public ghc-extensible-exceptions
1309 (name "ghc-extensible-exceptions")
1314 (uri (string-append "http://hackage.haskell.org/package/"
1315 "extensible-exceptions/extensible-exceptions-"
1318 (base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
1319 (build-system haskell-build-system)
1320 (home-page "http://hackage.haskell.org/package/extensible-exceptions")
1321 (synopsis "Extensible exceptions for Haskell")
1323 "This package provides extensible exceptions for both new and old
1324 versions of GHC (i.e., < 6.10).")
1327 (define-public cabal-install
1329 (name "cabal-install")
1330 (version "1.22.6.0")
1335 "http://hackage.haskell.org/package/cabal-install/cabal-install-"
1339 (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx"))))
1340 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
1341 (build-system haskell-build-system)
1343 `(("ghc-http" ,ghc-http)
1344 ("ghc-mtl" ,ghc-mtl)
1345 ("ghc-network-uri" ,ghc-network-uri)
1346 ("ghc-network" ,ghc-network)
1347 ("ghc-random" ,ghc-random)
1348 ("ghc-stm" ,ghc-stm)
1349 ("ghc-zlib" ,ghc-zlib)))
1350 (home-page "http://www.haskell.org/cabal/")
1351 (synopsis "Command-line interface for Cabal and Hackage")
1353 "The cabal command-line program simplifies the process of managing
1354 Haskell software by automating the fetching, configuration, compilation and
1355 installation of Haskell libraries and programs.")
1358 (define-public ghc-mtl
1362 (outputs '("out" "doc"))
1367 "http://hackage.haskell.org/package/mtl/mtl-"
1372 "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
1373 (build-system haskell-build-system)
1374 (home-page "http://github.com/ekmett/mtl")
1376 "Monad classes, using functional dependencies")
1377 (description "Monad classes using functional dependencies, with instances
1378 for various monad transformers, inspired by the paper 'Functional Programming
1379 with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced
1380 School of Functional Programming', 1995. See
1381 @uref{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
1384 (define-public ghc-paths
1388 (outputs '("out" "doc"))
1393 "http://hackage.haskell.org/package/ghc-paths/ghc-paths-"
1398 "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
1399 (build-system haskell-build-system)
1400 (home-page "https://github.com/simonmar/ghc-paths")
1402 "Knowledge of GHC's installation directories")
1404 "Knowledge of GHC's installation directories.")
1407 (define-public ghc-utf8-string
1409 (name "ghc-utf8-string")
1415 "http://hackage.haskell.org/package/utf8-string/utf8-string-"
1419 (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
1420 (build-system haskell-build-system)
1421 (home-page "http://github.com/glguy/utf8-string/")
1422 (synopsis "Support for reading and writing UTF8 Strings")
1424 "A UTF8 layer for Strings. The utf8-string package provides operations
1425 for encoding UTF8 strings to Word8 lists and back, and for reading and writing
1426 UTF8 without truncation.")
1429 (define-public ghc-setenv
1437 "http://hackage.haskell.org/package/setenv/setenv-"
1442 "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
1443 (build-system haskell-build-system)
1444 (home-page "http://hackage.haskell.org/package/setenv")
1445 (synopsis "Library for setting environment variables")
1446 (description "This package provides a Haskell library for setting
1447 environment variables.")
1450 (define-public ghc-x11
1457 (uri (string-append "http://hackage.haskell.org/package/X11/"
1458 "X11-" version ".tar.gz"))
1460 (base32 "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj"))))
1461 (build-system haskell-build-system)
1463 `(("libx11" ,libx11)
1464 ("libxrandr" ,libxrandr)
1465 ("libxinerama" ,libxinerama)
1466 ("libxscrnsaver" ,libxscrnsaver)))
1468 `(("ghc-data-default" ,ghc-data-default)))
1469 (home-page "https://github.com/haskell-pkg-janitors/X11")
1470 (synopsis "Bindings to the X11 graphics library")
1472 "This package provides Haskell bindings to the X11 graphics library. The
1473 bindings are a direct translation of the C bindings.")
1476 (define-public ghc-x11-xft
1478 (name "ghc-x11-xft")
1483 (uri (string-append "http://hackage.haskell.org/package/X11-xft/"
1484 "X11-xft-" version ".tar.gz"))
1486 (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
1488 `(("ghc-x11" ,ghc-x11)
1489 ("ghc-utf8-string" ,ghc-utf8-string)))
1491 `(("libx11" ,libx11)
1493 ("xproto" ,xproto)))
1495 `(("pkg-config" ,pkg-config)))
1496 (build-system haskell-build-system)
1497 (home-page "http://hackage.haskell.org/package/X11-xft")
1498 (synopsis "Bindings to Xft")
1500 "Bindings to the Xft, X Free Type interface library, and some Xrender
1504 (define-public ghc-stringbuilder
1506 (name "ghc-stringbuilder")
1512 "http://hackage.haskell.org/package/stringbuilder/stringbuilder-"
1517 "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9"))))
1518 (build-system haskell-build-system)
1519 (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
1521 (home-page "http://hackage.haskell.org/package/stringbuilder")
1522 (synopsis "Writer monad for multi-line string literals")
1523 (description "This package provides a writer monad for multi-line string
1527 (define-public ghc-zlib
1531 (outputs '("out" "doc"))
1536 "http://hackage.haskell.org/package/zlib/zlib-"
1541 "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
1542 (build-system haskell-build-system)
1543 (inputs `(("zlib" ,zlib)))
1544 (home-page "http://hackage.haskell.org/package/zlib")
1546 "Compression and decompression in the gzip and zlib formats")
1548 "This package provides a pure interface for compressing and decompressing
1549 streams of data represented as lazy 'ByteString's. It uses the zlib C library
1550 so it has high performance. It supports the 'zlib', 'gzip' and 'raw'
1551 compression formats. It provides a convenient high level API suitable for
1552 most tasks and for the few cases where more control is needed it provides
1553 access to the full zlib feature set.")
1556 (define-public ghc-stm
1560 (outputs '("out" "doc"))
1565 "http://hackage.haskell.org/package/stm/stm-"
1570 "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
1571 (build-system haskell-build-system)
1572 (home-page "http://hackage.haskell.org/package/stm")
1573 (synopsis "Software Transactional Memory")
1575 "A modular composable concurrency abstraction.")
1578 (define-public ghc-parallel
1580 (name "ghc-parallel")
1582 (outputs '("out" "doc"))
1587 "http://hackage.haskell.org/package/parallel/parallel-"
1592 "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
1593 (build-system haskell-build-system)
1594 (home-page "http://hackage.haskell.org/package/parallel")
1595 (synopsis "Parallel programming library")
1597 "This package provides a library for parallel programming.")
1600 (define-public ghc-text
1604 (outputs '("out" "doc"))
1609 "http://hackage.haskell.org/package/text/text-"
1614 "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq"))))
1615 (build-system haskell-build-system)
1617 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
1618 (home-page "https://github.com/bos/text")
1619 (synopsis "Efficient packed Unicode text type library")
1621 "An efficient packed, immutable Unicode text type (both strict and
1622 lazy), with a powerful loop fusion optimization framework.
1624 The 'Text' type represents Unicode character strings, in a time and
1625 space-efficient manner. This package provides text processing
1626 capabilities that are optimized for performance critical use, both
1627 in terms of large data quantities and high speed.")
1630 (define-public ghc-hashable
1632 (name "ghc-hashable")
1634 (outputs '("out" "doc"))
1639 "http://hackage.haskell.org/package/hashable/hashable-"
1644 "0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw"))))
1645 (build-system haskell-build-system)
1647 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
1648 ;; these inputs are necessary to use this library
1650 `(("ghc-text" ,ghc-text)))
1651 (home-page "http://github.com/tibbe/hashable")
1653 "Class for types that can be converted to a hash value")
1655 "This package defines a class, 'Hashable', for types that can be
1656 converted to a hash value. This class exists for the benefit of hashing-based
1657 data structures. The package provides instances for basic types and a way to
1658 combine hash values.")
1661 (define-public ghc-hunit
1665 (outputs '("out" "doc"))
1670 "http://hackage.haskell.org/package/HUnit/HUnit-"
1675 "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
1676 (build-system haskell-build-system)
1677 (home-page "http://hunit.sourceforge.net/")
1678 (synopsis "Unit testing framework for Haskell")
1680 "HUnit is a unit testing framework for Haskell, inspired by the
1681 JUnit tool for Java.")
1684 (define-public ghc-random
1688 (outputs '("out" "doc"))
1693 "http://hackage.haskell.org/package/random/random-"
1697 (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
1698 (build-system haskell-build-system)
1699 (home-page "http://hackage.haskell.org/package/random")
1700 (synopsis "Random number library")
1701 (description "This package provides a basic random number generation
1702 library, including the ability to split random number generators.")
1705 (define-public ghc-primitive
1707 (name "ghc-primitive")
1709 (outputs '("out" "doc"))
1714 "http://hackage.haskell.org/package/primitive/primitive-"
1719 "1j1q7l21rdm8kfs93vibr3xwkkhqis181w2k6klfhx5g5skiywwk"))))
1720 (build-system haskell-build-system)
1722 "https://github.com/haskell/primitive")
1723 (synopsis "Primitive memory-related operations")
1725 "This package provides various primitive memory-related operations.")
1728 (define-public ghc-test-framework
1730 (name "ghc-test-framework")
1735 (uri (string-append "http://hackage.haskell.org/package/test-framework/"
1736 "test-framework-" version ".tar.gz"))
1739 "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
1740 (build-system haskell-build-system)
1742 `(("ghc-hunit" ,ghc-hunit)
1743 ("ghc-libxml" ,ghc-libxml)
1744 ("ghc-quickcheck" ,ghc-quickcheck)))
1746 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
1747 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
1748 ("ghc-hostname" ,ghc-hostname)
1749 ("ghc-old-locale" ,ghc-old-locale)
1750 ("ghc-random" ,ghc-random)
1751 ("ghc-regex-posix" ,ghc-regex-posix)
1752 ("ghc-xml" ,ghc-xml)))
1753 (home-page "https://batterseapower.github.io/test-framework/")
1754 (synopsis "Framework for running and organising tests")
1756 "This package allows tests such as QuickCheck properties and HUnit test
1757 cases to be assembled into test groups, run in parallel (but reported in
1758 deterministic order, to aid diff interpretation) and filtered and controlled
1759 by command line options. All of this comes with colored test output, progress
1760 reporting and test statistics output.")
1763 (define-public ghc-test-framework-hunit
1765 (name "ghc-test-framework-hunit")
1770 (uri (string-append "http://hackage.haskell.org/package/"
1771 "test-framework-hunit/test-framework-hunit-"
1775 "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
1776 (build-system haskell-build-system)
1778 `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
1779 ("ghc-hunit" ,ghc-hunit)
1780 ("ghc-test-framework" ,ghc-test-framework)))
1781 (home-page "https://batterseapower.github.io/test-framework/")
1782 (synopsis "HUnit support for test-framework")
1784 "This package provides HUnit support for the test-framework package.")
1787 (define-public ghc-test-framework-quickcheck2
1789 (name "ghc-test-framework-quickcheck2")
1794 (uri (string-append "http://hackage.haskell.org/package/"
1795 "test-framework-quickcheck2/"
1796 "test-framework-quickcheck2-" version ".tar.gz"))
1799 "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
1800 (modules '((guix build utils)))
1802 ;; The Hackage page and the cabal file linked there for this package
1803 ;; both list 2.9 as the upper version limit, but the source tarball
1804 ;; specifies 2.8. Assume the Hackage page is correct.
1805 '(substitute* "test-framework-quickcheck2.cabal"
1806 (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
1807 (build-system haskell-build-system)
1809 `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
1810 ("ghc-quickcheck" ,ghc-quickcheck)
1811 ("ghc-random" ,ghc-random)
1812 ("ghc-test-framework" ,ghc-test-framework)))
1813 (home-page "https://batterseapower.github.io/test-framework/")
1814 (synopsis "QuickCheck2 support for test-framework")
1816 "This packages provides QuickCheck2 support for the test-framework
1820 (define-public ghc-tf-random
1822 (name "ghc-tf-random")
1824 (outputs '("out" "doc"))
1829 "http://hackage.haskell.org/package/tf-random/tf-random-"
1833 (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
1834 (build-system haskell-build-system)
1835 ;; these inputs are necessary to use this package
1837 `(("ghc-primitive" ,ghc-primitive)
1838 ("ghc-random" ,ghc-random)))
1839 (home-page "http://hackage.haskell.org/package/tf-random")
1840 (synopsis "High-quality splittable pseudorandom number generator")
1841 (description "This package contains an implementation of a high-quality
1842 splittable pseudorandom number generator. The generator is based on a
1843 cryptographic hash function built on top of the ThreeFish block cipher. See
1844 the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
1845 Hashing\" by Claessen, Pałka for details and the rationale of the design.")
1848 (define-public ghc-transformers-base
1850 (name "ghc-transformers-base")
1856 "http://hackage.haskell.org/package/transformers-base/transformers-base-"
1861 "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va"))))
1862 (build-system haskell-build-system)
1864 `(("ghc-stm" ,ghc-stm)))
1866 `(("ghc-transformers-compat" ,ghc-transformers-compat)))
1868 "http://hackage.haskell.org/package/transformers-compat")
1870 "Backported transformer library")
1872 "Backported versions of types that were added to transformers in
1873 transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
1874 compatibility to run on old versions of the platform.")
1877 (define-public ghc-transformers-compat
1879 (name "ghc-transformers-compat")
1885 "http://hackage.haskell.org/package/transformers-compat"
1886 "/transformers-compat-" version ".tar.gz"))
1889 "0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym"))))
1890 (build-system haskell-build-system)
1891 (home-page "http://github.com/ekmett/transformers-compat/")
1892 (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
1893 (description "This package includes backported versions of types that were
1894 added to transformers in transformers 0.3 and 0.4 for users who need strict
1895 transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
1896 but also need those types.")
1899 (define-public ghc-unix-time
1901 (name "ghc-unix-time")
1907 "http://hackage.haskell.org/package/unix-time/unix-time-"
1912 "0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax"))))
1913 (build-system haskell-build-system)
1915 `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
1916 ; is weird, that should be provided by GHC 7.10.2.
1918 `(("ghc-old-time" ,ghc-old-time)
1919 ("ghc-old-locale" ,ghc-old-locale)))
1920 (home-page "http://hackage.haskell.org/package/unix-time")
1921 (synopsis "Unix time parser/formatter and utilities")
1922 (description "This library provides fast parsing and formatting utilities
1923 for Unix time in Haskell.")
1926 (define-public ghc-unix-compat
1928 (name "ghc-unix-compat")
1934 "http://hackage.haskell.org/package/unix-compat/unix-compat-"
1939 "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps"))))
1940 (build-system haskell-build-system)
1942 "http://github.com/jystic/unix-compat")
1943 (synopsis "Portable POSIX-compatibility layer")
1945 "This package provides portable implementations of parts of the unix
1946 package. This package re-exports the unix package when available. When it
1947 isn't available, portable implementations are used.")
1950 (define-public ghc-http-types
1952 (name "ghc-http-types")
1958 "http://hackage.haskell.org/package/http-types/http-types-"
1963 "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
1964 (build-system haskell-build-system)
1965 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find
1966 ; Blaze.Bytestring.Builder, which should be
1967 ; provided by ghc-blaze-builder.
1969 `(("ghc-case-insensitive" ,ghc-case-insensitive)
1970 ("ghc-blaze-builder" ,ghc-blaze-builder)))
1972 `(("ghc-text" ,ghc-text)))
1973 (home-page "https://github.com/aristidb/http-types")
1974 (synopsis "Generic HTTP types for Haskell")
1975 (description "This package provides generic HTTP types for Haskell (for
1976 both client and server code).")
1979 (define-public ghc-iproute
1981 (name "ghc-iproute")
1987 "http://hackage.haskell.org/package/iproute/iproute-"
1992 "1ply0i110c2sppjbfyysgw48jfjnsbam5zwil8xws0hp20rh1pb5"))))
1993 (build-system haskell-build-system)
1994 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
1995 ; exported by ghc-byteorder. Doctest issue.
1997 `(("ghc-appar" ,ghc-appar)
1998 ("ghc-byteorder" ,ghc-byteorder)))
2000 `(("ghc-network" ,ghc-network)
2001 ("ghc-safe" ,ghc-safe)))
2002 (home-page "http://www.mew.org/~kazu/proj/iproute/")
2003 (synopsis "IP routing table")
2004 (description "IP Routing Table is a tree of IP ranges to search one of
2005 them on the longest match base. It is a kind of TRIE with one way branching
2006 removed. Both IPv4 and IPv6 are supported.")
2009 (define-public ghc-regex-base
2011 (name "ghc-regex-base")
2017 "http://hackage.haskell.org/package/regex-base/regex-base-"
2022 "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
2023 (build-system haskell-build-system)
2025 `(("ghc-mtl" ,ghc-mtl)))
2027 "http://sourceforge.net/projects/lazy-regex")
2028 (synopsis "Replaces/Enhances Text.Regex")
2029 (description "@code{Text.Regex.Base} provides the interface API for
2030 regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
2033 (define-public ghc-regex-posix
2035 (name "ghc-regex-posix")
2041 "http://hackage.haskell.org/package/regex-posix/regex-posix-"
2046 "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
2047 (build-system haskell-build-system)
2049 `(("ghc-regex-base" ,ghc-regex-base)))
2050 (home-page "http://sourceforge.net/projects/lazy-regex")
2051 (synopsis "POSIX regular expressions for Haskell")
2052 (description "This library provides the POSIX regex backend used by the
2053 Haskell library @code{regex-base}.")
2056 (define-public ghc-regex-compat
2058 (name "ghc-regex-compat")
2064 "http://hackage.haskell.org/package/regex-compat/regex-compat-"
2069 "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
2070 (build-system haskell-build-system)
2072 `(("ghc-regex-base" ,ghc-regex-base)
2073 ("ghc-regex-posix" ,ghc-regex-posix)))
2074 (home-page "http://sourceforge.net/projects/lazy-regex")
2075 (synopsis "Replaces/Enhances Text.Regex")
2076 (description "This library provides one module layer over
2077 @code{regex-posix} to replace @code{Text.Regex}.")
2080 (define-public ghc-regex-tdfa-rc
2082 (name "ghc-regex-tdfa-rc")
2088 "http://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-"
2093 "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3"))))
2094 (build-system haskell-build-system)
2096 `(("ghc-regex-base" ,ghc-regex-base)
2097 ("ghc-parsec" ,ghc-parsec)))
2099 `(("ghc-mtl" ,ghc-mtl)))
2101 "http://hackage.haskell.org/package/regex-tdfa")
2102 (synopsis "Tagged DFA regex engine for Haskell")
2103 (description "A new all-Haskell \"tagged\" DFA regex engine, inspired by
2104 @code{libtre} (fork by Roman Cheplyaka).")
2107 (define-public ghc-parsers
2109 (name "ghc-parsers")
2115 "http://hackage.haskell.org/package/parsers/parsers-"
2120 "18wzmp8y3py4qa8hdsxqm0jfzmwy744dw7xa48r5s8ynhpimi462"))))
2121 (build-system haskell-build-system)
2122 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2123 ; -package attoparsec-0.13.0.1"
2125 `(("ghc-base-orphans" ,ghc-base-orphans)
2126 ("ghc-attoparsec" ,ghc-attoparsec)
2127 ("ghc-parsec" ,ghc-parsec)
2128 ("ghc-scientific" ,ghc-scientific)
2129 ("ghc-charset" ,ghc-charset)))
2131 `(("ghc-text" ,ghc-text)
2132 ("ghc-unordered-containers" ,ghc-unordered-containers)))
2133 (home-page "http://github.com/ekmett/parsers/")
2134 (synopsis "Parsing combinators")
2135 (description "This library provides convenient combinators for working
2136 with and building parsing combinator libraries. Given a few simple instances,
2137 you get access to a large number of canned definitions. Instances exist for
2138 the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
2142 (define-public ghc-trifecta
2144 (name "ghc-trifecta")
2150 "http://hackage.haskell.org/package/trifecta/trifecta-"
2155 "0fjhnsbafl3yw34pyhcsvrqy6a2mnhyqys6gna3rrlygs8ck7hpb"))))
2156 (build-system haskell-build-system)
2157 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2158 ; -package ansi-terminal-0.6.2.3"
2160 `(("ghc-charset" ,ghc-charset)
2161 ("ghc-comonad" ,ghc-comonad)
2162 ("ghc-lens" ,ghc-lens)
2163 ("ghc-profunctors" ,ghc-profunctors)
2164 ("ghc-reducers" ,ghc-reducers)
2165 ("ghc-semigroups" ,ghc-semigroups)))
2167 `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
2168 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
2169 ("ghc-blaze-builder" ,ghc-blaze-builder)
2170 ("ghc-blaze-html" ,ghc-blaze-html)
2171 ("ghc-blaze-markup" ,ghc-blaze-markup)
2172 ("ghc-fingertree" ,ghc-fingertree)
2173 ("ghc-hashable" ,ghc-hashable)
2174 ("ghc-mtl" ,ghc-mtl)
2175 ("ghc-parsers" ,ghc-parsers)
2176 ("ghc-unordered-containers" ,ghc-unordered-containers)
2177 ("ghc-utf8-string" ,ghc-utf8-string)))
2178 (home-page "http://github.com/ekmett/trifecta/")
2179 (synopsis "Parser combinator library with convenient diagnostics")
2180 (description "Trifecta is a modern parser combinator library for Haskell,
2181 with slicing and Clang-style colored diagnostics.")
2184 (define-public ghc-attoparsec
2186 (name "ghc-attoparsec")
2187 (version "0.13.0.1")
2192 "http://hackage.haskell.org/package/attoparsec/attoparsec-"
2197 "0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f"))))
2198 (build-system haskell-build-system)
2200 `(("ghc-scientific" ,ghc-scientific)))
2202 `(("ghc-quickcheck" ,ghc-quickcheck)
2203 ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
2204 ("ghc-test-framework" ,ghc-test-framework)
2205 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
2206 ("ghc-text" ,ghc-text)
2207 ("ghc-vector" ,ghc-vector)))
2208 (home-page "https://github.com/bos/attoparsec")
2209 (synopsis "Fast combinator parsing for bytestrings and text")
2210 (description "This library provides a fast parser combinator library,
2211 aimed particularly at dealing efficiently with network protocols and
2212 complicated text/binary file formats.")
2215 (define-public ghc-css-text
2217 (name "ghc-css-text")
2223 "http://hackage.haskell.org/package/css-text/css-text-"
2228 "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
2229 (build-system haskell-build-system)
2231 `(("ghc-text" ,ghc-text)
2232 ("ghc-attoparsec" ,ghc-attoparsec)
2233 ("ghc-hspec" ,ghc-hspec)
2234 ("ghc-quickcheck" ,ghc-quickcheck)))
2235 (home-page "http://www.yesodweb.com/")
2236 (synopsis "CSS parser and renderer")
2237 (description "This package provides a CSS parser and renderer for
2241 (define-public ghc-zip-archive
2243 (name "ghc-zip-archive")
2249 "http://hackage.haskell.org/package/zip-archive/zip-archive-"
2254 "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1"))))
2255 (build-system haskell-build-system)
2257 `(("ghc-old-time" ,ghc-old-time)
2258 ("ghc-digest" ,ghc-digest)))
2260 `(("ghc-hunit" ,ghc-hunit)
2261 ("ghc-mtl" ,ghc-mtl)
2263 ("ghc-text" ,ghc-text)
2264 ("ghc-zlib" ,ghc-zlib)))
2265 (home-page "https://hackage.haskell.org/package/zip-archive")
2266 (synopsis "Zip archive library for Haskell")
2267 (description "The zip-archive library provides functions for creating,
2268 modifying, and extracting files from zip archives in Haskell.")
2271 (define-public ghc-distributive
2273 (name "ghc-distributive")
2279 "http://hackage.haskell.org/package/distributive/distributive-"
2284 "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2"))))
2285 (build-system haskell-build-system)
2286 (arguments `(#:tests? #f)) ; FIXME: fails with "cannot satisfy -package
2287 ; tagged-0.8.1". Suspected Cabal issue.
2289 `(("ghc-tagged" ,ghc-tagged)
2290 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2291 (home-page "http://github.com/ekmett/distributive/")
2292 (synopsis "Distributive functors for Haskell")
2293 (description "This package provides distributive functors for Haskell.
2294 Dual to @code{Traversable}.")
2297 (define-public ghc-cereal
2305 "http://hackage.haskell.org/package/cereal/cereal-"
2310 "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z"))))
2311 (build-system haskell-build-system)
2312 (home-page "http://hackage.haskell.org/package/cereal")
2313 (synopsis "Binary serialization library")
2314 (description "This package provides a binary serialization library,
2315 similar to @code{binary}, that introduces an @code{isolate} primitive for
2316 parser isolation, and labeled blocks for better error messages.")
2319 (define-public ghc-comonad
2321 (name "ghc-comonad")
2327 "http://hackage.haskell.org/package/comonad/comonad-"
2332 "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp"))))
2333 (build-system haskell-build-system)
2335 `(("ghc-distributive" ,ghc-distributive)
2336 ("ghc-transformers-compat" ,ghc-transformers-compat)
2337 ("ghc-contravariant" ,ghc-contravariant)))
2338 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2339 ; -package contravariant-1.3.3"
2341 `(("ghc-semigroups" ,ghc-semigroups)
2342 ("ghc-tagged" ,ghc-tagged)
2343 ("ghc-contravariant" ,ghc-contravariant)))
2344 (home-page "http://github.com/ekmett/comonad/")
2345 (synopsis "Comonads for Haskell")
2346 (description "This library provides @code{Comonad}s for Haskell.")
2349 (define-public hscolour
2357 "http://hackage.haskell.org/package/hscolour/hscolour-"
2362 "1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp"))))
2363 (build-system haskell-build-system)
2364 (home-page "https://hackage.haskell.org/package/hscolour")
2365 (synopsis "Script to colourise Haskell code")
2366 (description "HSColour is a small Haskell script to colourise Haskell
2367 code. It currently has six output formats: ANSI terminal codes (optionally
2368 XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01
2369 with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX,
2370 and mIRC chat codes.")
2373 (define-public ghc-polyparse
2375 (name "ghc-polyparse")
2381 "http://hackage.haskell.org/package/polyparse/polyparse-"
2386 "1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh"))))
2387 (build-system haskell-build-system)
2389 `(("ghc-text" ,ghc-text)))
2391 "http://code.haskell.org/~malcolm/polyparse/")
2393 "Alternative parser combinator libraries")
2395 "This package provides a variety of alternative parser combinator
2396 libraries, including the original HuttonMeijer set. The Poly sets have
2397 features like good error reporting, arbitrary token type, running state, lazy
2398 parsing, and so on. Finally, Text.Parse is a proposed replacement for the
2399 standard Read class, for better deserialisation of Haskell values from
2403 (define-public ghc-extra
2411 "http://hackage.haskell.org/package/extra/extra-"
2416 "1h9hxkrqrqscx420yz1lmivbrhi6jc3a5ap61vkxd2mhdgark9hf"))))
2417 (build-system haskell-build-system)
2418 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
2419 (home-page "https://github.com/ndmitchell/extra")
2420 (synopsis "Extra Haskell functions")
2421 (description "This library provides extra functions for the standard
2422 Haskell libraries. Most functions are simple additions, filling out missing
2423 functionality. A few functions are available in later versions of GHC, but
2424 this package makes them available back to GHC 7.2.")
2427 (define-public ghc-profunctors
2429 (name "ghc-profunctors")
2435 "http://hackage.haskell.org/package/profunctors/profunctors-"
2440 "0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7"))))
2441 (build-system haskell-build-system)
2443 `(("ghc-distributive" ,ghc-distributive)))
2445 `(("ghc-comonad" ,ghc-comonad)
2446 ("ghc-tagged" ,ghc-tagged)))
2447 (home-page "http://github.com/ekmett/profunctors/")
2448 (synopsis "Profunctors for Haskell")
2449 (description "This library provides profunctors for Haskell.")
2452 (define-public ghc-reducers
2454 (name "ghc-reducers")
2460 "http://hackage.haskell.org/package/reducers/reducers-"
2465 "0pkddg0s3cn759miq0nfrq7lnp3imk5sx784ihsilsbjh9kvffz4"))))
2466 (build-system haskell-build-system)
2468 `(("ghc-semigroupoids" ,ghc-semigroupoids)))
2470 `(("ghc-fingertree" ,ghc-fingertree)
2471 ("ghc-hashable" ,ghc-hashable)
2472 ("ghc-text" ,ghc-text)
2473 ("ghc-unordered-containers" ,ghc-unordered-containers)
2474 ("ghc-semigroups" ,ghc-semigroups)))
2475 (home-page "http://github.com/ekmett/reducers/")
2476 (synopsis "Semigroups, specialized containers and a general map/reduce framework")
2477 (description "This library provides various semigroups, specialized
2478 containers and a general map/reduce framework for Haskell.")
2481 (define-public ghc-appar
2489 "http://hackage.haskell.org/package/appar/appar-"
2494 "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
2495 (build-system haskell-build-system)
2497 "http://hackage.haskell.org/package/appar")
2498 (synopsis "Simple applicative parser")
2499 (description "This package provides a simple applicative parser in Parsec
2503 (define-public ghc-safe
2511 "http://hackage.haskell.org/package/safe/safe-"
2516 "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh"))))
2517 (build-system haskell-build-system)
2518 (home-page "https://github.com/ndmitchell/safe#readme")
2519 (synopsis "Library of safe (exception free) functions")
2520 (description "This library provides wrappers around @code{Prelude} and
2521 @code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
2525 (define-public ghc-generic-deriving
2527 (name "ghc-generic-deriving")
2533 "http://hackage.haskell.org/package/generic-deriving/generic-deriving-"
2538 "1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6"))))
2539 (build-system haskell-build-system)
2540 (home-page "https://hackage.haskell.org/package/generic-deriving")
2541 (synopsis "Generalise the deriving mechanism to arbitrary classes")
2542 (description "This package provides functionality for generalising the
2543 deriving mechanism in Haskell to arbitrary classes.")
2546 (define-public ghc-pcre-light
2548 (name "ghc-pcre-light")
2554 "http://hackage.haskell.org/package/pcre-light/pcre-light-"
2559 "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf"))))
2560 (build-system haskell-build-system)
2563 (home-page "https://github.com/Daniel-Diaz/pcre-light")
2564 (synopsis "Haskell library for Perl 5 compatible regular expressions")
2565 (description "This package provides a small, efficient, and portable regex
2566 library for Perl 5 compatible regular expressions. The PCRE library is a set
2567 of functions that implement regular expression pattern matching using the same
2568 syntax and semantics as Perl 5.")
2571 (define-public ghc-logict
2579 "http://hackage.haskell.org/package/logict/logict-"
2584 "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
2585 (build-system haskell-build-system)
2586 (inputs `(("ghc-mtl" ,ghc-mtl)))
2587 (home-page "http://code.haskell.org/~dolio/")
2588 (synopsis "Backtracking logic-programming monad")
2589 (description "This library provides a continuation-based, backtracking,
2590 logic programming monad. An adaptation of the two-continuation implementation
2591 found in the paper \"Backtracking, Interleaving, and Terminating Monad
2592 Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
2596 (define-public ghc-xml
2604 "http://hackage.haskell.org/package/xml/xml-"
2609 "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
2610 (build-system haskell-build-system)
2612 `(("ghc-text" ,ghc-text)))
2613 (home-page "http://code.galois.com")
2614 (synopsis "Simple XML library for Haskell")
2615 (description "This package provides a simple XML library for Haskell.")
2618 (define-public ghc-exceptions
2620 (name "ghc-exceptions")
2626 "http://hackage.haskell.org/package/exceptions/exceptions-"
2631 "1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7"))))
2632 (build-system haskell-build-system)
2633 (arguments `(#:tests? #f)) ; FIXME: Missing test-framework package.
2635 `(("ghc-stm" ,ghc-stm)
2636 ("ghc-mtl" ,ghc-mtl)
2637 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2638 (home-page "http://github.com/ekmett/exceptions/")
2639 (synopsis "Extensible optionally-pure exceptions")
2640 (description "This library provides extensible optionally-pure exceptions
2644 (define-public ghc-temporary
2646 (name "ghc-temporary")
2652 "http://hackage.haskell.org/package/temporary/temporary-"
2657 "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a"))))
2658 (build-system haskell-build-system)
2659 (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions)))
2660 (home-page "http://www.github.com/batterseapower/temporary")
2661 (synopsis "Temporary file and directory support")
2662 (description "The functions for creating temporary files and directories
2663 in the Haskelll base library are quite limited. This library just repackages
2664 the Cabal implementations of its own temporary file and folder functions so
2665 that you can use them without linking against Cabal or depending on it being
2669 (define-public ghc-temporary-rc
2671 (name "ghc-temporary-rc")
2677 "http://hackage.haskell.org/package/temporary-rc/temporary-rc-"
2682 "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
2683 (build-system haskell-build-system)
2684 (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions)))
2686 "http://www.github.com/feuerbach/temporary")
2688 "Portable temporary file and directory support")
2690 "The functions for creating temporary files and directories in the base
2691 library are quite limited. The unixutils package contains some good ones, but
2692 they aren't portable to Windows. This library just repackages the Cabal
2693 implementations of its own temporary file and folder functions so that you can
2694 use them without linking against Cabal or depending on it being installed.
2695 This is a better maintained fork of the \"temporary\" package.")
2698 (define-public ghc-smallcheck
2700 (name "ghc-smallcheck")
2706 "http://hackage.haskell.org/package/smallcheck/smallcheck-"
2711 "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
2712 (build-system haskell-build-system)
2714 `(("ghc-logict" ,ghc-logict)))
2716 `(("ghc-mtl" ,ghc-mtl)))
2718 "https://github.com/feuerbach/smallcheck")
2719 (synopsis "Property-based testing library")
2720 (description "SmallCheck is a testing library that allows to verify
2721 properties for all test cases up to some depth. The test cases are generated
2722 automatically by SmallCheck.")
2725 (define-public ghc-tasty-ant-xml
2727 (name "ghc-tasty-ant-xml")
2733 "http://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
2738 "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
2739 (build-system haskell-build-system)
2741 `(("ghc-generic-deriving" ,ghc-generic-deriving)
2742 ("ghc-xml" ,ghc-xml)))
2744 `(("ghc-mtl" ,ghc-mtl)
2745 ("ghc-stm" ,ghc-stm)
2746 ("ghc-tagged" ,ghc-tagged)
2747 ("ghc-tasty" ,ghc-tasty)))
2749 "http://github.com/ocharles/tasty-ant-xml")
2751 "Render tasty output to XML for Jenkins")
2753 "A tasty ingredient to output test results in XML, using the Ant
2754 schema. This XML can be consumed by the Jenkins continuous integration
2758 (define-public ghc-tasty-smallcheck
2760 (name "ghc-tasty-smallcheck")
2766 "http://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
2771 "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
2772 (build-system haskell-build-system)
2774 `(("ghc-tasty" ,ghc-tasty)
2775 ("ghc-smallcheck" ,ghc-smallcheck)
2776 ("ghc-async" ,ghc-async)
2777 ("ghc-tagged" ,ghc-tagged)))
2778 (home-page "http://documentup.com/feuerbach/tasty")
2779 (synopsis "SmallCheck support for the Tasty test framework")
2780 (description "This package provides SmallCheck support for the Tasty
2781 Haskell test framework.")
2784 (define-public ghc-silently
2786 (name "ghc-silently")
2792 "http://hackage.haskell.org/package/silently/silently-"
2797 "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
2798 (build-system haskell-build-system)
2799 (arguments `(#:tests? #f)) ;; circular dependency with nanospec
2801 ;; `(("ghc-temporary" ,ghc-temporary)))
2802 (home-page "https://github.com/hspec/silently")
2803 (synopsis "Prevent writing to stdout")
2804 (description "This package provides functions to prevent or capture
2805 writing to stdout and other handles.")
2808 (define-public ghc-quickcheck-instances
2810 (name "ghc-quickcheck-instances")
2816 "http://hackage.haskell.org/package/"
2817 "quickcheck-instances/quickcheck-instances-"
2821 "041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2"))))
2822 (build-system haskell-build-system)
2824 `(("ghc-old-time" ,ghc-old-time)
2825 ("ghc-unordered-containers" ,ghc-unordered-containers)))
2827 `(("ghc-hashable" ,ghc-hashable)
2828 ("ghc-quickcheck" ,ghc-quickcheck)
2829 ("ghc-text" ,ghc-text)))
2831 "https://github.com/aslatter/qc-instances")
2832 (synopsis "Common quickcheck instances")
2833 (description "This package provides QuickCheck instances for types
2834 provided by the Haskell Platform.")
2837 (define-public ghc-quickcheck-unicode
2839 (name "ghc-quickcheck-unicode")
2845 "http://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
2850 "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
2851 (build-system haskell-build-system)
2852 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
2854 "https://github.com/bos/quickcheck-unicode")
2855 (synopsis "Generator functions Unicode-related tests")
2856 (description "This package provides generator and shrink functions for
2857 testing Unicode-related software.")
2860 (define-public ghc-quickcheck-io
2862 (name "ghc-quickcheck-io")
2868 "http://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
2873 "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
2874 (build-system haskell-build-system)
2876 `(("ghc-quickcheck" ,ghc-quickcheck)
2877 ("ghc-hunit" ,ghc-hunit)))
2879 "https://github.com/hspec/quickcheck-io#readme")
2880 (synopsis "Use HUnit assertions as QuickCheck properties")
2881 (description "This package provides an orphan instance that allows you to
2882 use HUnit assertions as QuickCheck properties.")
2885 (define-public ghc-quickcheck
2887 (name "ghc-quickcheck")
2889 (outputs '("out" "doc"))
2894 "http://hackage.haskell.org/package/QuickCheck/QuickCheck-"
2899 "0fvnfl30fxmj5q920l13641ar896d53z0z6z66m7c1366lvalwvh"))))
2900 (build-system haskell-build-system)
2902 `(#:tests? #f ; FIXME: currently missing libraries used for tests.
2903 #:configure-flags '("-f base4")))
2904 ;; these inputs are necessary to use this package
2906 `(("ghc-tf-random" ,ghc-tf-random)))
2908 "https://github.com/nick8325/quickcheck")
2910 "Automatic testing of Haskell programs")
2912 "QuickCheck is a library for random testing of program properties.")
2915 (define-public ghc-case-insensitive
2917 (name "ghc-case-insensitive")
2919 (outputs '("out" "doc"))
2924 "http://hackage.haskell.org/package/case-insensitive/case-insensitive-"
2929 "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
2930 (build-system haskell-build-system)
2932 `(("ghc-hunit" ,ghc-hunit)))
2933 ;; these inputs are necessary to use this library
2935 `(("ghc-text" ,ghc-text)
2936 ("ghc-hashable" ,ghc-hashable)))
2938 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
2940 "https://github.com/basvandijk/case-insensitive")
2941 (synopsis "Case insensitive string comparison")
2943 "The module 'Data.CaseInsensitive' provides the 'CI' type constructor
2944 which can be parameterised by a string-like type like: 'String', 'ByteString',
2945 'Text', etc.. Comparisons of values of the resulting type will be insensitive
2949 (define-public ghc-syb
2953 (outputs '("out" "doc"))
2958 "http://hackage.haskell.org/package/syb/syb-"
2963 "1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3"))))
2964 (build-system haskell-build-system)
2966 `(("ghc-hunit" ,ghc-hunit)
2967 ("ghc-mtl" ,ghc-mtl)))
2969 "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
2970 (synopsis "Scrap Your Boilerplate")
2971 (description "This package contains the generics system described in the
2972 /Scrap Your Boilerplate/ papers (see
2973 @uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It
2974 defines the 'Data' class of types permitting folding and unfolding of
2975 constructor applications, instances of this class for primitive types, and a
2976 variety of traversals.")
2979 (define-public ghc-fgl
2983 (outputs '("out" "doc"))
2988 "http://hackage.haskell.org/package/fgl/fgl-"
2993 "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga"))))
2994 (build-system haskell-build-system)
2995 (inputs `(("ghc-mtl" ,ghc-mtl)))
2996 (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
2998 "Martin Erwig's Functional Graph Library")
2999 (description "The functional graph library, FGL, is a collection of type
3000 and function definitions to address graph problems. The basis of the library
3001 is an inductive definition of graphs in the style of algebraic data types that
3002 encourages inductive, recursive definitions of graph algorithms.")
3005 (define-public ghc-chasingbottoms
3007 (name "ghc-chasingbottoms")
3008 (version "1.3.0.13")
3012 (uri (string-append "http://hackage.haskell.org/package/ChasingBottoms/"
3013 "ChasingBottoms-" version ".tar.gz"))
3016 "1fb86jd6cdz4rx3fj3r9n8d60kx824ywwy7dw4qnrdran46ja3pl"))
3017 (modules '((guix build utils)))
3019 ;; The Hackage page and the cabal file linked there for this package
3020 ;; both list 0.7 as the upper version limit, but the source tarball
3021 ;; specifies 0.6. Assume the Hackage page is correct.
3022 '(substitute* "ChasingBottoms.cabal"
3023 (("syb >= 0.1.0.2 && < 0.6") "syb >= 0.1.0.2 && < 0.7")))))
3024 (build-system haskell-build-system)
3026 `(("ghc-mtl" ,ghc-mtl)
3027 ("ghc-quickcheck" ,ghc-quickcheck)
3028 ("ghc-random" ,ghc-random)
3029 ("ghc-syb" ,ghc-syb)))
3030 (home-page "http://hackage.haskell.org/package/ChasingBottoms")
3031 (synopsis "Testing of partial and infinite values in Haskell")
3033 ;; FIXME: There should be a @comma{} in the uref text, but it is not
3034 ;; rendered properly.
3035 "This is a library for testing code involving bottoms or infinite values.
3036 For the underlying theory and a larger example involving use of QuickCheck,
3038 @uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
3039 \"Chasing Bottoms A Case Study in Program Verification in the Presence of
3040 Partial and Infinite Values\"}.")
3043 (define-public ghc-unordered-containers
3045 (name "ghc-unordered-containers")
3047 (outputs '("out" "doc"))
3052 "http://hackage.haskell.org/package/unordered-containers"
3053 "/unordered-containers-" version ".tar.gz"))
3056 "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
3057 (build-system haskell-build-system)
3059 `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
3060 ("ghc-hunit" ,ghc-hunit)
3061 ("ghc-quickcheck" ,ghc-quickcheck)
3062 ("ghc-test-framework" ,ghc-test-framework)
3063 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
3064 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
3065 ;; these inputs are necessary to use this library
3066 (propagated-inputs `(("ghc-hashable" ,ghc-hashable)))
3068 "https://github.com/tibbe/unordered-containers")
3070 "Efficient hashing-based container types")
3072 "Efficient hashing-based container types. The containers have been
3073 optimized for performance critical use, both in terms of large data quantities
3077 (define-public ghc-uniplate
3079 (name "ghc-uniplate")
3085 "http://hackage.haskell.org/package/uniplate/uniplate-"
3090 "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
3091 (build-system haskell-build-system)
3093 `(("ghc-syb" ,ghc-syb)
3094 ("ghc-hashable" ,ghc-hashable)
3095 ("ghc-unordered-containers" ,ghc-unordered-containers)))
3096 (home-page "http://community.haskell.org/~ndm/uniplate/")
3097 (synopsis "Simple, concise and fast generic operations")
3098 (description "Uniplate is a library for writing simple and concise generic
3099 operations. Uniplate has similar goals to the original Scrap Your Boilerplate
3100 work, but is substantially simpler and faster.")
3103 (define-public ghc-base64-bytestring
3105 (name "ghc-base64-bytestring")
3111 "http://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
3116 "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db"))))
3117 (build-system haskell-build-system)
3118 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3119 (home-page "https://github.com/bos/base64-bytestring")
3120 (synopsis "Base64 encoding and decoding for ByteStrings")
3121 (description "This library provides fast base64 encoding and decoding for
3122 Haskell @code{ByteString}s.")
3125 (define-public ghc-annotated-wl-pprint
3127 (name "ghc-annotated-wl-pprint")
3133 "http://hackage.haskell.org/package/annotated-wl-pprint"
3134 "/annotated-wl-pprint-" version
3138 "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
3139 (build-system haskell-build-system)
3141 "https://github.com/david-christiansen/annotated-wl-pprint")
3143 "The Wadler/Leijen Pretty Printer, with annotation support")
3144 (description "This is a modified version of wl-pprint, which was based on
3145 Wadler's paper \"A Prettier Printer\". This version allows the library user
3146 to annotate the text with semantic information, which can later be rendered in
3147 a variety of ways.")
3150 (define-public ghc-ansi-wl-pprint
3152 (name "ghc-ansi-wl-pprint")
3158 "http://hackage.haskell.org/package/ansi-wl-pprint/ansi-wl-pprint-"
3163 "025pyphsjf0dnbrmj5nscbi6gzyigwgp3ifxb3psn7kji6mfr29p"))))
3164 (build-system haskell-build-system)
3166 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
3167 (home-page "http://github.com/ekmett/ansi-wl-pprint")
3168 (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
3169 (description "This is a pretty printing library based on Wadler's paper
3170 \"A Prettier Printer\". It has been enhanced with support for ANSI terminal
3171 colored output using the ansi-terminal package.")
3174 (define-public ghc-split
3178 (outputs '("out" "doc"))
3183 "http://hackage.haskell.org/package/split/split-"
3188 "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))
3189 (modules '((guix build utils)))
3191 ;; The Cabal file on Hackage is updated, but the tar.gz does not
3193 ;; <https://hackage.haskell.org/package/split-0.2.2/revisions/>.
3194 '(substitute* "split.cabal"
3195 (("base <4.8") "base <4.9")))))
3196 (build-system haskell-build-system)
3198 `(("ghc-quickcheck" ,ghc-quickcheck)))
3199 (home-page "http://hackage.haskell.org/package/split")
3200 (synopsis "Combinator library for splitting lists")
3201 (description "This package provides a collection of Haskell functions for
3202 splitting lists into parts, akin to the @code{split} function found in several
3203 mainstream languages.")
3206 (define-public ghc-parsec
3210 (outputs '("out" "doc"))
3215 "http://hackage.haskell.org/package/parsec/parsec-"
3219 (base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
3220 (build-system haskell-build-system)
3222 `(("ghc-hunit" ,ghc-hunit)))
3223 ;; these inputs are necessary to use this library
3225 `(("ghc-text" ,ghc-text)
3226 ("ghc-mtl" ,ghc-mtl)))
3228 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3230 "https://github.com/aslatter/parsec")
3231 (synopsis "Monadic parser combinators")
3232 (description "Parsec is a parser library. It is simple, safe, well
3233 documented, has extensive libraries, good error messages, and is fast. It is
3234 defined as a monad transformer that can be stacked on arbitrary monads, and it
3235 is also parametric in the input stream type.")
3238 (define-public ghc-vector
3241 (version "0.11.0.0")
3242 (outputs '("out" "doc"))
3247 "http://hackage.haskell.org/package/vector/vector-"
3252 "1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa"))))
3253 (build-system haskell-build-system)
3255 `(("ghc-quickcheck" ,ghc-quickcheck)))
3256 ;; these inputs are necessary to use this library
3258 `(("ghc-primitive" ,ghc-primitive)))
3260 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3261 (home-page "https://github.com/haskell/vector")
3262 (synopsis "Efficient Arrays")
3263 (description "This library provides an efficient implementation of
3264 Int-indexed arrays (both mutable and immutable), with a powerful loop
3265 optimisation framework.")
3268 (define-public ghc-vector-binary-instances
3270 (name "ghc-vector-binary-instances")
3276 "http://hackage.haskell.org/package/"
3277 "vector-binary-instances/vector-binary-instances-"
3281 "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l"))))
3282 (build-system haskell-build-system)
3284 `(("ghc-cereal" ,ghc-cereal)))
3286 `(("ghc-vector" ,ghc-vector)))
3287 (home-page "https://github.com/bos/vector-binary-instances")
3288 (synopsis "Instances of Data.Binary and Data.Serialize for vector")
3289 (description "This library provides instances of @code{Binary} for the
3290 types defined in the @code{vector} package, making it easy to serialize
3291 vectors to and from disk. We use the generic interface to vectors, so all
3292 vector types are supported. Specific instances are provided for unboxed,
3293 boxed and storable vectors.")
3296 (define-public ghc-network
3298 (name "ghc-network")
3300 (outputs '("out" "doc"))
3305 "http://hackage.haskell.org/package/network/network-"
3310 "1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3"))))
3311 (build-system haskell-build-system)
3313 `(("ghc-hunit" ,ghc-hunit)))
3315 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3316 (home-page "https://github.com/haskell/network")
3317 (synopsis "Low-level networking interface")
3319 "This package provides a low-level networking interface.")
3322 (define-public ghc-network-uri
3324 (name "ghc-network-uri")
3326 (outputs '("out" "doc"))
3331 "http://hackage.haskell.org/package/network-uri/network-uri-"
3336 "1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg"))))
3337 (build-system haskell-build-system)
3339 `(("ghc-hunit" ,ghc-hunit)
3340 ("ghc-network" ,ghc-network)))
3342 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3344 `(("ghc-parsec" ,ghc-parsec)))
3346 "https://github.com/haskell/network-uri")
3347 (synopsis "Library for URI manipulation")
3348 (description "This package provides an URI manipulation interface. In
3349 'network-2.6' the 'Network.URI' module was split off from the 'network'
3350 package into this package.")
3353 (define-public ghc-ansi-terminal
3355 (name "ghc-ansi-terminal")
3361 "http://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
3366 "0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d"))))
3367 (build-system haskell-build-system)
3368 (home-page "https://github.com/feuerbach/ansi-terminal")
3369 (synopsis "ANSI terminal support for Haskell")
3370 (description "This package provides ANSI terminal support for Haskell. It
3371 allows cursor movement, screen clearing, color output showing or hiding the
3372 cursor, and changing the title.")
3375 (define-public ghc-http
3378 (version "4000.2.20")
3379 (outputs '("out" "doc"))
3384 "http://hackage.haskell.org/package/HTTP/HTTP-"
3389 "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
3390 (build-system haskell-build-system)
3392 `(("ghc-hunit" ,ghc-hunit)))
3394 `(("ghc-old-time" ,ghc-old-time)
3395 ("ghc-parsec" ,ghc-parsec)
3396 ("ghc-mtl" ,ghc-mtl)
3397 ("ghc-network" ,ghc-network)
3398 ("ghc-network-uri" ,ghc-network-uri)))
3400 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3401 (home-page "https://github.com/haskell/HTTP")
3402 (synopsis "Library for client-side HTTP")
3404 "The HTTP package supports client-side web programming in Haskell. It
3405 lets you set up HTTP connections, transmitting requests and processing the
3406 responses coming back.")
3409 (define-public ghc-hspec
3417 "http://hackage.haskell.org/package/hspec/hspec-"
3422 "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
3423 (build-system haskell-build-system)
3425 `(("ghc-hspec-core" ,ghc-hspec-core)
3426 ("hspec-discover" ,hspec-discover)
3427 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3428 ("ghc-quickcheck" ,ghc-quickcheck)
3429 ("ghc-hunit" ,ghc-hunit)))
3431 `(("ghc-stringbuilder" ,ghc-stringbuilder)
3432 ("ghc-hspec-meta" ,ghc-hspec-meta)))
3433 (home-page "http://hspec.github.io/")
3434 (synopsis "Testing Framework for Haskell")
3435 (description "This library provides the Hspec testing framework for
3436 Haskell, inspired by the Ruby library RSpec.")
3439 (define-public ghc-hspec-contrib
3441 (name "ghc-hspec-contrib")
3445 (uri (string-append "http://hackage.haskell.org/package/"
3446 "hspec-contrib/hspec-contrib-"
3450 "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
3451 (build-system haskell-build-system)
3453 `(("ghc-hspec-core" ,ghc-hspec-core)
3454 ("ghc-hunit" ,ghc-hunit)
3455 ("ghc-hspec" ,ghc-hspec)
3456 ("ghc-quickcheck" ,ghc-quickcheck)))
3457 (home-page "http://hspec.github.io/")
3458 (synopsis "Contributed functionality for Hspec")
3460 "This package provides contributed Hspec extensions.")
3463 (define-public ghc-hspec-expectations
3465 (name "ghc-hspec-expectations")
3471 "http://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
3476 "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
3477 (build-system haskell-build-system)
3478 (inputs `(("ghc-hunit" ,ghc-hunit)))
3479 (home-page "https://github.com/sol/hspec-expectations")
3480 (synopsis "Catchy combinators for HUnit")
3481 (description "This library provides catchy combinators for HUnit, see
3482 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
3485 (define-public hspec-discover
3487 (name "hspec-discover")
3493 "http://hackage.haskell.org/package/hspec-discover/hspec-discover-"
3498 "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
3499 (build-system haskell-build-system)
3500 (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
3501 ; documentation files.
3502 (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
3503 (home-page "http://hspec.github.io/")
3504 (synopsis "Automatically discover and run Hspec tests")
3505 (description "hspec-discover is a tool which automatically discovers and
3509 (define-public ghc-hspec-core
3511 (name "ghc-hspec-core")
3517 "http://hackage.haskell.org/package/hspec-core/hspec-core-"
3522 "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
3523 (build-system haskell-build-system)
3524 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3526 `(("ghc-setenv" ,ghc-setenv)
3527 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
3528 ("ghc-async" ,ghc-async)
3529 ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
3531 `(("ghc-hunit" ,ghc-hunit)
3532 ("ghc-quickcheck" ,ghc-quickcheck)
3533 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3534 ("ghc-silently" ,ghc-silently)))
3535 (home-page "http://hspec.github.io/")
3536 (synopsis "Testing framework for Haskell")
3537 (description "This library exposes internal types and functions that can
3538 be used to extend Hspec's functionality.")
3541 (define-public ghc-hspec-meta
3543 (name "ghc-hspec-meta")
3549 "http://hackage.haskell.org/package/hspec-meta/hspec-meta-"
3554 "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
3555 (build-system haskell-build-system)
3557 `(("ghc-quickcheck" ,ghc-quickcheck)
3558 ("ghc-hunit" ,ghc-hunit)
3559 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
3560 ("ghc-async" ,ghc-async)
3561 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3562 ("ghc-setenv" ,ghc-setenv)
3563 ("ghc-random" ,ghc-random)
3564 ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
3565 (home-page "http://hspec.github.io/")
3566 (synopsis "Version of Hspec to test Hspec itself")
3567 (description "This library provides a stable version of Hspec which is
3568 used to test the in-development version of Hspec.")
3571 (define-public ghc-vault
3579 "http://hackage.haskell.org/package/vault/vault-"
3584 "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn"))))
3585 (build-system haskell-build-system)
3587 `(("ghc-unordered-containers" ,ghc-unordered-containers)
3588 ("ghc-hashable" ,ghc-hashable)))
3590 "https://github.com/HeinrichApfelmus/vault")
3591 (synopsis "Persistent store for arbitrary values")
3592 (description "This package provides vaults for Haskell. A vault is a
3593 persistent store for values of arbitrary types. It's like having first-class
3594 access to the storage space behind @code{IORefs}. The data structure is
3595 analogous to a bank vault, where you can access different bank boxes with
3596 different keys; hence the name. Also provided is a @code{locker} type,
3597 representing a store for a single element.")
3600 (define-public ghc-mmorph
3608 "http://hackage.haskell.org/package/mmorph/mmorph-"
3613 "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2"))))
3614 (build-system haskell-build-system)
3616 "http://hackage.haskell.org/package/mmorph")
3617 (synopsis "Monad morphisms")
3619 "This library provides monad morphism utilities, most commonly used for
3620 manipulating monad transformer stacks.")
3623 (define-public ghc-monad-control
3625 (name "ghc-monad-control")
3631 "http://hackage.haskell.org/package/monad-control"
3632 "/monad-control-" version ".tar.gz"))
3635 "07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179"))))
3636 (build-system haskell-build-system)
3638 `(("ghc-stm" ,ghc-stm)
3639 ("ghc-transformers-base" ,ghc-transformers-base)
3640 ("ghc-transformers-compat" ,ghc-transformers-compat)))
3641 (home-page "https://github.com/basvandijk/monad-control")
3642 (synopsis "Monad transformers to lift control operations like exception
3644 (description "This package defines the type class @code{MonadBaseControl},
3645 a subset of @code{MonadBase} into which generic control operations such as
3646 @code{catch} can be lifted from @code{IO} or any other base monad.")
3649 (define-public ghc-byteorder
3651 (name "ghc-byteorder")
3657 "http://hackage.haskell.org/package/byteorder/byteorder-"
3662 "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
3663 (build-system haskell-build-system)
3665 "http://community.haskell.org/~aslatter/code/byteorder")
3667 "Exposes the native endianness of the system")
3669 "This package is for working with the native byte-ordering of the
3673 (define-public ghc-base-compat
3675 (name "ghc-base-compat")
3681 "http://hackage.haskell.org/package/base-compat/base-compat-"
3686 "02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q"))))
3687 (build-system haskell-build-system)
3689 `(("ghc-quickcheck" ,ghc-quickcheck)
3690 ("ghc-hspec" ,ghc-hspec)))
3691 (home-page "https://hackage.haskell.org/package/base-compat")
3692 (synopsis "Haskell compiler compatibility library")
3693 (description "This library provides functions available in later versions
3694 of base to a wider range of compilers, without requiring the use of CPP
3695 pragmas in your code.")
3698 (define-public ghc-blaze-builder
3700 (name "ghc-blaze-builder")
3706 "http://hackage.haskell.org/package/blaze-builder/blaze-builder-"
3711 "1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1"))))
3712 (build-system haskell-build-system)
3713 (arguments `(#:tests? #f)) ; FIXME: Missing test libraries.
3715 `(("ghc-text" ,ghc-text)
3716 ("ghc-utf8-string" ,ghc-utf8-string)))
3717 (home-page "http://github.com/lpsmith/blaze-builder")
3718 (synopsis "Efficient buffered output")
3719 (description "This library provides an implementation of the older
3720 @code{blaze-builder} interface in terms of the new builder that shipped with
3721 @code{bytestring-0.10.4.0}. This implementation is mostly intended as a
3722 bridge to the new builder, so that code that uses the old interface can
3723 interoperate with code that uses the new implementation.")
3726 (define-public ghc-blaze-markup
3728 (name "ghc-blaze-markup")
3734 "http://hackage.haskell.org/package/blaze-markup/blaze-markup-"
3739 "080vlhd8dwjxrma4bb524lh8gxs5lm3xh122icy6lnnyipla0s9y"))))
3740 (build-system haskell-build-system)
3741 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3743 `(("ghc-blaze-builder" ,ghc-blaze-builder)
3744 ("ghc-text" ,ghc-text)))
3745 (home-page "http://jaspervdj.be/blaze")
3746 (synopsis "Fast markup combinator library for Haskell")
3747 (description "This library provides core modules of a markup combinator
3748 library for Haskell.")
3751 (define-public ghc-blaze-html
3753 (name "ghc-blaze-html")
3759 "http://hackage.haskell.org/package/blaze-html/blaze-html-"
3764 "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
3765 (build-system haskell-build-system)
3766 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3768 `(("ghc-blaze-builder" ,ghc-blaze-builder)
3769 ("ghc-text" ,ghc-text)
3770 ("ghc-blaze-markup" ,ghc-blaze-markup)))
3771 (home-page "http://jaspervdj.be/blaze")
3772 (synopsis "Fast HTML combinator library")
3773 (description "This library provides HTML combinators for Haskell.")
3776 (define-public ghc-easy-file
3778 (name "ghc-easy-file")
3784 "http://hackage.haskell.org/package/easy-file/easy-file-"
3789 "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz"))))
3790 (build-system haskell-build-system)
3792 "http://github.com/kazu-yamamoto/easy-file")
3793 (synopsis "File handling library for Haskell")
3794 (description "This library provides file handling utilities for Haskell.")
3797 (define-public ghc-async
3805 "http://hackage.haskell.org/package/async/async-"
3810 "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v"))))
3811 (build-system haskell-build-system)
3813 `(("ghc-hunit" ,ghc-hunit)
3814 ("ghc-test-framework" ,ghc-test-framework)
3815 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
3817 `(("ghc-stm" ,ghc-stm)))
3818 (home-page "https://github.com/simonmar/async")
3819 (synopsis "Library to run IO operations asynchronously")
3820 (description "Async provides a library to run IO operations
3821 asynchronously, and wait for their results. It is a higher-level interface
3822 over threads in Haskell, in which @code{Async a} is a concurrent thread that
3823 will eventually deliver a value of type @code{a}.")
3826 (define-public ghc-fingertree
3828 (name "ghc-fingertree")
3834 "http://hackage.haskell.org/package/fingertree/fingertree-"
3839 "1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n"))))
3840 (build-system haskell-build-system)
3841 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3842 (home-page "http://hackage.haskell.org/package/fingertree")
3843 (synopsis "Generic finger-tree structure")
3844 (description "This library provides finger trees, a general sequence
3845 representation with arbitrary annotations, for use as a base for
3846 implementations of various collection types. It includes examples, as
3847 described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
3848 simple general-purpose data structure\".")
3851 (define-public ghc-optparse-applicative
3853 (name "ghc-optparse-applicative")
3854 (version "0.11.0.2")
3859 "http://hackage.haskell.org/package/optparse-applicative"
3860 "/optparse-applicative-" version ".tar.gz"))
3863 "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii"))))
3864 (build-system haskell-build-system)
3866 `(("ghc-transformers-compat" ,ghc-transformers-compat)
3867 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
3868 (home-page "https://github.com/pcapriotti/optparse-applicative")
3869 (synopsis "Utilities and combinators for parsing command line options")
3870 (description "This package provides utilities and combinators for parsing
3871 command line options in Haskell.")
3874 (define-public ghc-base-orphans
3876 (name "ghc-base-orphans")
3882 "http://hackage.haskell.org/package/base-orphans/base-orphans-"
3887 "0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl"))))
3888 (build-system haskell-build-system)
3890 `(("ghc-quickcheck" ,ghc-quickcheck)
3891 ("ghc-hspec" ,ghc-hspec)))
3892 (home-page "https://hackage.haskell.org/package/base-orphans")
3893 (synopsis "Orphan instances for backwards compatibility")
3894 (description "This package defines orphan instances that mimic instances
3895 available in later versions of base to a wider (older) range of compilers.")
3898 (define-public ghc-auto-update
3900 (name "ghc-auto-update")
3906 "http://hackage.haskell.org/package/auto-update/auto-update-"
3911 "1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v"))))
3912 (build-system haskell-build-system)
3913 (home-page "https://github.com/yesodweb/wai")
3914 (synopsis "Efficiently run periodic, on-demand actions")
3915 (description "This library provides mechanisms to efficiently run
3916 periodic, on-demand actions in Haskell.")
3919 (define-public ghc-tagged
3927 "http://hackage.haskell.org/package/tagged/tagged-"
3932 "1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav"))))
3933 (build-system haskell-build-system)
3934 (home-page "https://hackage.haskell.org/package/tagged")
3935 (synopsis "Haskell phantom types to avoid passing dummy arguments")
3936 (description "This library provides phantom types for Haskell 98, to avoid
3937 having to unsafely pass dummy arguments.")
3940 (define-public ghc-unbounded-delays
3942 (name "ghc-unbounded-delays")
3948 "http://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
3953 "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420"))))
3954 (build-system haskell-build-system)
3955 (home-page "https://github.com/basvandijk/unbounded-delays")
3956 (synopsis "Unbounded thread delays and timeouts")
3957 (description "The @code{threadDelay} and @code{timeout} functions from the
3958 Haskell base library use the bounded @code{Int} type for specifying the delay
3959 or timeout period. This package provides alternative functions which use the
3960 unbounded @code{Integer} type.")
3963 ;; This package builds `clock` without tests, since the tests rely on tasty
3964 ;; and tasty-quickcheck, which in turn require clock to build. When tasty and
3965 ;; tasty-quickcheck are added, we will add ghc-clock with tests enabled.
3966 (define ghc-clock-bootstrap
3968 (name "ghc-clock-bootstrap")
3974 "http://hackage.haskell.org/package/"
3976 "clock-" version ".tar.gz"))
3978 (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
3979 (build-system haskell-build-system)
3980 (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
3981 ;; tasty-quickcheck, which need clock to build.
3982 (home-page "https://hackage.haskell.org/package/clock")
3983 (synopsis "High-resolution clock for Haskell")
3984 (description "A package for convenient access to high-resolution clock and
3985 timer functions of different operating systems via a unified API.")
3988 (define-public ghc-clock
3996 "http://hackage.haskell.org/package/"
3998 "clock-" version ".tar.gz"))
4000 (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
4001 (build-system haskell-build-system)
4003 `(("ghc-tasty" ,ghc-tasty)
4004 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
4005 (home-page "https://hackage.haskell.org/package/clock")
4006 (synopsis "High-resolution clock for Haskell")
4007 (description "A package for convenient access to high-resolution clock and
4008 timer functions of different operating systems via a unified API.")
4011 (define-public ghc-charset
4013 (name "ghc-charset")
4019 "http://hackage.haskell.org/package/charset/charset-"
4024 "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
4025 (build-system haskell-build-system)
4027 `(("ghc-semigroups" ,ghc-semigroups)))
4029 `(("ghc-unordered-containers" ,ghc-unordered-containers)))
4030 (home-page "http://github.com/ekmett/charset")
4031 (synopsis "Fast unicode character sets for Haskell")
4032 (description "This package provides fast unicode character sets for
4033 Haskell, based on complemented PATRICIA tries.")
4036 (define-public ghc-bytestring-builder
4038 (name "ghc-bytestring-builder")
4039 (version "0.10.6.0.0")
4044 "http://hackage.haskell.org/package/bytestring-builder"
4045 "/bytestring-builder-" version ".tar.gz"))
4048 "1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww"))))
4049 (build-system haskell-build-system)
4050 (arguments `(#:haddock? #f)) ; Package contains no documentation.
4051 (home-page "http://hackage.haskell.org/package/bytestring-builder")
4052 (synopsis "The new bytestring builder, packaged outside of GHC")
4053 (description "This package provides the bytestring builder that is
4054 debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
4055 Compatibility package for older packages.")
4058 (define-public ghc-nats
4066 "http://hackage.haskell.org/package/nats/nats-"
4071 "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0"))))
4072 (build-system haskell-build-system)
4073 (arguments `(#:haddock? #f))
4075 `(("ghc-hashable" ,ghc-hashable)))
4076 (home-page "https://hackage.haskell.org/package/nats")
4077 (synopsis "Natural numbers")
4078 (description "This library provides the natural numbers for Haskell.")
4081 (define-public ghc-void
4089 "http://hackage.haskell.org/package/void/void-"
4094 "1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69"))))
4095 (build-system haskell-build-system)
4097 `(("ghc-semigroups" ,ghc-semigroups)))
4099 `(("ghc-hashable" ,ghc-hashable)))
4100 (home-page "http://github.com/ekmett/void")
4102 "Logically uninhabited data type")
4104 "A Haskell 98 logically uninhabited data type, used to indicate that a
4105 given term should not exist.")
4108 (define-public ghc-kan-extensions
4110 (name "ghc-kan-extensions")
4116 "http://hackage.haskell.org/package/kan-extensions/kan-extensions-"
4121 "0iywbadpy8s3isfzlx9dlz3apaywhqq4gdbxkwygksq8pzdhwkrk"))))
4122 (build-system haskell-build-system)
4124 `(("ghc-adjunctions" ,ghc-adjunctions)))
4126 `(("ghc-comonad" ,ghc-comonad)
4127 ("ghc-contravariant" ,ghc-contravariant)
4128 ("ghc-distributive" ,ghc-distributive)
4129 ("ghc-free" ,ghc-free)
4130 ("ghc-mtl" ,ghc-mtl)
4131 ("ghc-semigroupoids" ,ghc-semigroupoids)
4132 ("ghc-tagged" ,ghc-tagged)))
4133 (home-page "http://github.com/ekmett/kan-extensions/")
4134 (synopsis "Kan extensions library")
4135 (description "This library provides Kan extensions, Kan lifts, various
4136 forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
4139 (define-public ghc-statevar
4141 (name "ghc-statevar")
4147 "http://hackage.haskell.org/package/StateVar/StateVar-"
4152 "1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf"))))
4153 (build-system haskell-build-system)
4155 `(("ghc-stm" ,ghc-stm)))
4156 (home-page "http://hackage.haskell.org/package/StateVar")
4157 (synopsis "State variables for Haskell")
4158 (description "This package provides state variables, which are references
4159 in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
4162 (define-public ghc-lens
4170 "http://hackage.haskell.org/package/lens/lens-"
4175 "0g4g0xksrb2m8wgsmraaq8qnk1sssb42kr65fc7clgyid6zyfmim"))))
4176 (build-system haskell-build-system)
4177 (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
4179 `(("ghc-base-orphans" ,ghc-base-orphans)
4180 ("ghc-bifunctors" ,ghc-bifunctors)
4181 ("ghc-distributive" ,ghc-distributive)
4182 ("ghc-exceptions" ,ghc-exceptions)
4183 ("ghc-free" ,ghc-free)
4184 ("ghc-kan-extensions" ,ghc-kan-extensions)
4185 ("ghc-parallel" ,ghc-parallel)
4186 ("ghc-reflection" ,ghc-reflection)
4187 ("ghc-semigroupoids" ,ghc-semigroupoids)
4188 ("ghc-vector" ,ghc-vector)))
4190 `(("ghc-comonad" ,ghc-comonad)
4191 ("ghc-contravariant" ,ghc-contravariant)
4192 ("ghc-hashable" ,ghc-hashable)
4193 ("ghc-mtl" ,ghc-mtl)
4194 ("ghc-profunctors" ,ghc-profunctors)
4195 ("ghc-semigroups" ,ghc-semigroups)
4196 ("ghc-tagged" ,ghc-tagged)
4197 ("ghc-text" ,ghc-text)
4198 ("ghc-transformers-compat" ,ghc-transformers-compat)
4199 ("ghc-unordered-containers" ,ghc-unordered-containers)
4200 ("ghc-void" ,ghc-void)
4201 ("ghc-generic-deriving" ,ghc-generic-deriving)
4202 ("ghc-nats" ,ghc-nats)
4203 ("ghc-simple-reflect" ,ghc-simple-reflect)
4205 (home-page "http://github.com/ekmett/lens/")
4206 (synopsis "Lenses, Folds and Traversals")
4207 (description "This library provides @code{Control.Lens}. The combinators
4208 in @code{Control.Lens} provide a highly generic toolbox for composing families
4209 of getters, folds, isomorphisms, traversals, setters and lenses and their
4213 (define-public ghc-tagsoup
4215 (name "ghc-tagsoup")
4221 "http://hackage.haskell.org/package/tagsoup/tagsoup-"
4226 "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j"))))
4227 (build-system haskell-build-system)
4228 (inputs `(("ghc-text" ,ghc-text)))
4230 "http://community.haskell.org/~ndm/tagsoup/")
4232 "Parsing and extracting information from (possibly malformed) HTML/XML
4235 "TagSoup is a library for parsing HTML/XML. It supports the HTML 5
4236 specification, and can be used to parse either well-formed XML, or
4237 unstructured and malformed HTML from the web. The library also provides
4238 useful functions to extract information from an HTML document, making it ideal
4239 for screen-scraping.")
4242 (define-public ghc-digest
4250 "http://hackage.haskell.org/package/digest/digest-"
4255 "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4"))))
4256 (build-system haskell-build-system)
4260 "http://hackage.haskell.org/package/digest")
4262 "Various cryptographic hashes for bytestrings")
4264 "This package provides efficient cryptographic hash implementations for
4265 strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they
4266 are implemented as FFI bindings to efficient code from zlib.")
4269 (define-public ghc-cheapskate
4271 (name "ghc-cheapskate")
4277 "http://hackage.haskell.org/package/cheapskate/cheapskate-"
4282 "0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2"))))
4283 (build-system haskell-build-system)
4285 `(("ghc-xss-sanitize" ,ghc-xss-sanitize)
4286 ("ghc-data-default" ,ghc-data-default)))
4288 `(("ghc-mtl" ,ghc-mtl)
4289 ("ghc-text" ,ghc-text)
4290 ("ghc-blaze-html" ,ghc-blaze-html)
4291 ("ghc-syb" ,ghc-syb)
4292 ("ghc-uniplate" ,ghc-uniplate)
4293 ("ghc-aeson" ,ghc-aeson)
4294 ("ghc-wai-extra" ,ghc-wai-extra)
4295 ("ghc-wai" ,ghc-wai)
4296 ("ghc-http-types" ,ghc-http-types)))
4297 (home-page "http://github.com/jgm/cheapskate")
4298 (synopsis "Experimental markdown processor")
4299 (description "Cheapskate is an experimental Markdown processor in pure
4300 Haskell. It aims to process Markdown efficiently and in the most forgiving
4301 possible way. It is designed to deal with any input, including garbage, with
4302 linear performance. Output is sanitized by default for protection against XSS
4306 (define-public ghc-bifunctors
4308 (name "ghc-bifunctors")
4314 "http://hackage.haskell.org/package/bifunctors/bifunctors-"
4319 "13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1"))))
4320 (build-system haskell-build-system)
4322 `(("ghc-tagged" ,ghc-tagged)
4323 ("ghc-semigroups" ,ghc-semigroups)))
4324 (home-page "http://github.com/ekmett/bifunctors/")
4325 (synopsis "Bifunctors for Haskell")
4326 (description "This package provides bifunctors for Haskell.")
4329 (define-public ghc-semigroupoids
4331 (name "ghc-semigroupoids")
4337 "http://hackage.haskell.org/package/semigroupoids/semigroupoids-"
4342 "1jf7jnfhdvl6p18wdr21yi2fim1xb8alcn6szhrdswj0dkilgq6d"))))
4343 (build-system haskell-build-system)
4345 `(("ghc-base-orphans" ,ghc-base-orphans)
4346 ("ghc-transformers-compat" ,ghc-transformers-compat)
4347 ("ghc-bifunctors" ,ghc-bifunctors)
4348 ("ghc-comonad" ,ghc-comonad)
4349 ("ghc-contravariant" ,ghc-contravariant)
4350 ("ghc-distributive" ,ghc-distributive)))
4351 (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
4353 `(("ghc-semigroups" ,ghc-semigroups)
4354 ("ghc-tagged" ,ghc-tagged)))
4355 (home-page "http://github.com/ekmett/semigroupoids")
4356 (synopsis "Semigroupoids operations for Haskell")
4357 (description "This library provides a wide array of (semi)groupoids and
4358 operations for working with them. A @code{Semigroupoid} is a @code{Category}
4359 without the requirement of identity arrows for every object in the category.
4360 A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
4361 Finally, to work with these weaker structures it is beneficial to have
4362 containers that can provide stronger guarantees about their contents, so
4363 versions of @code{Traversable} and @code{Foldable} that can be folded with
4364 just a @code{Semigroup} are added.")
4367 (define-public ghc-contravariant
4369 (name "ghc-contravariant")
4375 "http://hackage.haskell.org/package/contravariant/contravariant-"
4380 "184hcmhsznqrkmqlc1kza9pb5p591anva574ry8wrh81vqmhwfb5"))))
4381 (build-system haskell-build-system)
4383 `(("ghc-void" ,ghc-void)
4384 ("ghc-transformers-compat" ,ghc-transformers-compat)
4385 ("ghc-statevar" ,ghc-statevar)))
4387 `(("ghc-semigroups" ,ghc-semigroups)))
4389 "http://github.com/ekmett/contravariant/")
4390 (synopsis "Contravariant functors")
4391 (description "Contravariant functors for Haskell.")
4394 (define-public ghc-semigroups
4396 (name "ghc-semigroups")
4397 (version "0.17.0.1")
4402 "http://hackage.haskell.org/package/semigroups/semigroups-"
4407 "0gvpfi7s6ys4qha3y9a1zl1a15gf9cgg33wjb94ghg82ivcxnc3r"))))
4408 (build-system haskell-build-system)
4410 `(("ghc-nats" ,ghc-nats)
4411 ("ghc-tagged" ,ghc-tagged)
4412 ("ghc-unordered-containers" ,ghc-unordered-containers)))
4414 `(("ghc-text" ,ghc-text)
4415 ("ghc-hashable" ,ghc-hashable)))
4416 (home-page "http://github.com/ekmett/semigroups/")
4417 (synopsis "Semigroup operations for Haskell")
4418 (description "This package provides semigroups for Haskell. In
4419 mathematics, a semigroup is an algebraic structure consisting of a set
4420 together with an associative binary operation. A semigroup generalizes a
4421 monoid in that there might not exist an identity element. It
4422 also (originally) generalized a group (a monoid with all inverses) to a type
4423 where every element did not have to have an inverse, thus the name
4427 (define-public ghc-free
4435 "http://hackage.haskell.org/package/free/free-"
4440 "0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p"))))
4441 (build-system haskell-build-system)
4443 `(("ghc-prelude-extras" ,ghc-prelude-extras)
4444 ("ghc-profunctors" ,ghc-profunctors)
4445 ("ghc-exceptions" ,ghc-exceptions)))
4447 `(("ghc-bifunctors" ,ghc-bifunctors)
4448 ("ghc-comonad" ,ghc-comonad)
4449 ("ghc-distributive" ,ghc-distributive)
4450 ("ghc-mtl" ,ghc-mtl)
4451 ("ghc-semigroupoids" ,ghc-semigroupoids)
4452 ("ghc-semigroups" ,ghc-semigroups)))
4453 (home-page "http://github.com/ekmett/free/")
4454 (synopsis "Unrestricted monads for Haskell")
4455 (description "This library provides free monads, which are useful for many
4456 tree-like structures and domain specific languages. If @code{f} is a
4457 @code{Functor} then the free @code{Monad} on @code{f} is the type of trees
4458 whose nodes are labeled with the constructors of @code{f}. The word \"free\"
4459 is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
4460 f} makes no constraining assumptions beyond those given by @code{f} and the
4461 definition of @code{Monad}.")
4464 (define-public ghc-adjunctions
4466 (name "ghc-adjunctions")
4472 "http://hackage.haskell.org/package/adjunctions/adjunctions-"
4477 "00p030iypjzjib8pxz1x6mxfi59wvyrwjj11zv9bh766dgkdbwjq"))))
4478 (build-system haskell-build-system)
4480 `(("ghc-profunctors" ,ghc-profunctors)))
4482 `(("ghc-comonad" ,ghc-comonad)
4483 ("ghc-contravariant" ,ghc-contravariant)
4484 ("ghc-distributive" ,ghc-distributive)
4485 ("ghc-free" ,ghc-free)
4486 ("ghc-mtl" ,ghc-mtl)
4487 ("ghc-tagged" ,ghc-tagged)
4488 ("ghc-semigroupoids" ,ghc-semigroupoids)
4489 ("ghc-semigroups" ,ghc-semigroups)
4490 ("ghc-void" ,ghc-void)))
4491 (home-page "http://github.com/ekmett/adjunctions/")
4492 (synopsis "Adjunctions and representable functors")
4493 (description "This library provides adjunctions and representable functors
4497 (define-public ghc-fast-logger
4499 (name "ghc-fast-logger")
4505 "http://hackage.haskell.org/package/fast-logger/fast-logger-"
4510 "0kjk1861qcls8m8y7i55msfpprws5wk6c5mxzi35g2qbl2sih4p5"))))
4511 (build-system haskell-build-system)
4513 `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
4514 ("ghc-auto-update" ,ghc-auto-update)))
4516 `(("ghc-hspec" ,ghc-hspec)
4517 ("ghc-text" ,ghc-text)))
4518 (home-page "https://hackage.haskell.org/package/fast-logger")
4519 (synopsis "Fast logging system")
4520 (description "This library provides a fast logging system for Haskell.")
4523 (define-public ghc-doctest
4525 (name "ghc-doctest")
4531 "http://hackage.haskell.org/package/doctest/doctest-"
4536 "1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm"))))
4537 (build-system haskell-build-system)
4538 (arguments `(#:tests? #f)) ; FIXME: missing test framework
4540 `(("ghc-syb" ,ghc-syb)
4541 ("ghc-paths" ,ghc-paths)))
4543 `(("ghc-base-compat" ,ghc-base-compat)
4544 ("ghc-hunit" ,ghc-hunit)
4545 ("ghc-hspec" ,ghc-hspec)
4546 ("ghc-quickcheck" ,ghc-quickcheck)
4547 ("ghc-stringbuilder" ,ghc-stringbuilder)
4548 ("ghc-silently" ,ghc-silently)
4549 ("ghc-setenv" ,ghc-setenv)))
4551 "https://github.com/sol/doctest#readme")
4552 (synopsis "Test interactive Haskell examples")
4553 (description "The doctest program checks examples in source code comments.
4554 It is modeled after doctest for Python, see
4555 @uref{http://docs.python.org/library/doctest.html, the Doctest website}.")
4558 (define-public ghc-lifted-base
4560 (name "ghc-lifted-base")
4566 "http://hackage.haskell.org/package/lifted-base/lifted-base-"
4571 "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap"))))
4572 (build-system haskell-build-system)
4573 (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
4575 `(("ghc-transformers-base" ,ghc-transformers-base)
4576 ("ghc-monad-control" ,ghc-monad-control)))
4578 `(("ghc-transformers-compat" ,ghc-transformers-compat)
4579 ("ghc-hunit" ,ghc-hunit)))
4580 (home-page "https://github.com/basvandijk/lifted-base")
4581 (synopsis "Lifted IO operations from the base library")
4582 (description "Lifted-base exports IO operations from the @code{base}
4583 library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
4584 Note that not all modules from @code{base} are converted yet. The package
4585 includes a copy of the @code{monad-peel} test suite written by Anders
4589 (define-public ghc-word8
4597 "http://hackage.haskell.org/package/word8/word8-"
4602 "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw"))))
4603 (build-system haskell-build-system)
4605 `(("ghc-hspec" ,ghc-hspec)))
4606 (home-page "http://hackage.haskell.org/package/word8")
4607 (synopsis "Word8 library for Haskell")
4608 (description "Word8 library to be used with @code{Data.ByteString}.")
4611 (define-public ghc-stringsearch
4613 (name "ghc-stringsearch")
4619 "http://hackage.haskell.org/package/stringsearch/stringsearch-"
4624 "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
4625 (build-system haskell-build-system)
4626 (home-page "https://bitbucket.org/dafis/stringsearch")
4627 (synopsis "Fast searching, splitting and replacing of ByteStrings")
4628 (description "This package provides several functions to quickly search
4629 for substrings in strict or lazy @code{ByteStrings}. It also provides
4630 functions for breaking or splitting on substrings and replacing all
4631 occurrences of a substring (the first in case of overlaps) with another.")
4634 (define-public ghc-tasty-quickcheck
4636 (name "ghc-tasty-quickcheck")
4642 "http://hackage.haskell.org/package/tasty-quickcheck/"
4643 "tasty-quickcheck-" version ".tar.gz"))
4646 "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
4647 (build-system haskell-build-system)
4649 `(("ghc-quickcheck" ,ghc-quickcheck)))
4651 `(("ghc-tagged" ,ghc-tagged)
4652 ("ghc-tasty" ,ghc-tasty)
4653 ("ghc-random" ,ghc-random)
4654 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
4655 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4656 ("ghc-pcre-light" ,ghc-pcre-light)))
4657 (home-page "http://documentup.com/feuerbach/tasty")
4658 (synopsis "QuickCheck support for the Tasty test framework")
4659 (description "This package provides QuickCheck support for the Tasty
4660 Haskell test framework.")
4663 (define-public ghc-tasty-golden
4665 (name "ghc-tasty-golden")
4671 "http://hackage.haskell.org/package/tasty-golden/tasty-golden-"
4676 "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
4677 (build-system haskell-build-system)
4679 `(("ghc-temporary" ,ghc-temporary)))
4681 `(("ghc-tasty" ,ghc-tasty)
4682 ("ghc-mtl" ,ghc-mtl)
4683 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
4684 ("ghc-tagged" ,ghc-tagged)
4685 ("ghc-async" ,ghc-async)
4686 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4687 ("ghc-temporary-rc" ,ghc-temporary-rc)))
4689 "https://github.com/feuerbach/tasty-golden")
4690 (synopsis "Golden tests support for tasty")
4692 "This package provides support for 'golden testing'. A golden test is an
4693 IO action that writes its result to a file. To pass the test, this output
4694 file should be identical to the corresponding 'golden' file, which contains
4695 the correct result for the test.")
4698 (define-public ghc-tasty
4701 (version "0.11.0.1")
4706 "http://hackage.haskell.org/package/tasty/tasty-"
4711 "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
4712 (build-system haskell-build-system)
4714 `(("ghc-stm" ,ghc-stm)
4715 ("ghc-mtl" ,ghc-mtl)
4716 ("ghc-tagged" ,ghc-tagged)
4717 ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
4718 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
4719 ("ghc-unbounded-delays" ,ghc-unbounded-delays)
4720 ("ghc-async" ,ghc-async)
4721 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
4722 ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
4723 (home-page "http://documentup.com/feuerbach/tasty")
4724 (synopsis "Modern and extensible testing framework")
4725 (description "Tasty is a modern testing framework for Haskell. It lets
4726 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
4727 and any other types of tests into a single test suite.")
4730 (define-public ghc-tasty-hunit
4732 (name "ghc-tasty-hunit")
4738 "http://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
4743 "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
4744 (build-system haskell-build-system)
4746 `(("ghc-tasty" ,ghc-tasty)))
4747 (home-page "http://documentup.com/feuerbach/tasty")
4748 (synopsis "HUnit support for the Tasty test framework")
4749 (description "This package provides HUnit support for the Tasty Haskell
4753 (define-public ghc-cookie
4761 "http://hackage.haskell.org/package/cookie/cookie-"
4766 "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
4767 (build-system haskell-build-system)
4769 `(("ghc-old-locale" ,ghc-old-locale)))
4771 `(("ghc-blaze-builder" ,ghc-blaze-builder)
4772 ("ghc-text" ,ghc-text)
4773 ("ghc-data-default-class" ,ghc-data-default-class)
4774 ("ghc-hunit" ,ghc-hunit)
4775 ("ghc-quickcheck" ,ghc-quickcheck)
4776 ("ghc-tasty" ,ghc-tasty)
4777 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4778 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
4779 (home-page "http://github.com/snoyberg/cookie")
4780 (synopsis "HTTP cookie parsing and rendering")
4781 (description "HTTP cookie parsing and rendering library for Haskell.")
4784 (define-public ghc-scientific
4786 (name "ghc-scientific")
4792 "http://hackage.haskell.org/package/scientific/scientific-"
4797 "0mimdkva0cgzaychr6whv9if29z0r5wwhkss9bmd4rz8kq1kgngn"))))
4798 (build-system haskell-build-system)
4800 `(("ghc-hashable" ,ghc-hashable)
4801 ("ghc-vector" ,ghc-vector)))
4803 `(("ghc-text" ,ghc-text)
4804 ("ghc-tasty" ,ghc-tasty)
4805 ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
4806 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4807 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
4808 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
4809 ("ghc-smallcheck" ,ghc-smallcheck)
4810 ("ghc-quickcheck" ,ghc-quickcheck)))
4811 (home-page "https://github.com/basvandijk/scientific")
4812 (synopsis "Numbers represented using scientific notation")
4813 (description "This package provides @code{Data.Scientific}, which provides
4814 the number type @code{Scientific}. Scientific numbers are arbitrary precision
4815 and space efficient. They are represented using
4816 @uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific
4820 (define-public ghc-aeson
4823 (version "0.10.0.0")
4828 "http://hackage.haskell.org/package/aeson/aeson-"
4833 "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
4834 (build-system haskell-build-system)
4835 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
4837 `(("ghc-attoparsec" ,ghc-attoparsec)
4838 ("ghc-dlist" ,ghc-dlist)
4839 ("ghc-mtl" ,ghc-mtl)
4840 ("ghc-scientific" ,ghc-scientific)
4841 ("ghc-syb" ,ghc-syb)
4842 ("ghc-unordered-containers" ,ghc-unordered-containers)
4843 ("ghc-vector" ,ghc-vector)))
4845 `(("ghc-hashable" ,ghc-hashable)
4846 ("ghc-text" ,ghc-text)
4847 ("ghc-hunit" ,ghc-hunit)
4848 ("ghc-quickcheck" ,ghc-quickcheck)))
4849 (home-page "https://github.com/bos/aeson")
4850 (synopsis "Fast JSON parsing and encoding")
4851 (description "This package provides a JSON parsing and encoding library
4852 for Haskell, optimized for ease of use and high performance. (A note on
4853 naming: in Greek mythology, Aeson was the father of Jason.)")
4856 (define-public ghc-wai
4864 "http://hackage.haskell.org/package/wai/wai-"
4869 "1551n0g0n22vml33v0jz5xgjcy6j79algvsdqg11a1z5ljjrjlqf"))))
4870 (build-system haskell-build-system)
4872 `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
4873 ("ghc-unix-compat" ,ghc-unix-compat)
4874 ("ghc-vault" ,ghc-vault)
4875 ("ghc-blaze-builder" ,ghc-blaze-builder)
4876 ("ghc-network" ,ghc-network)))
4878 `(("ghc-quickcheck" ,ghc-quickcheck)
4879 ("ghc-hunit" ,ghc-hunit)
4880 ("ghc-hspec" ,ghc-hspec)
4881 ("ghc-text" ,ghc-text)
4882 ("ghc-http-types" ,ghc-http-types)))
4883 (home-page "https://hackage.haskell.org/package/wai")
4884 (synopsis "Web application interface for Haskell")
4885 (description "This package provides a Web Application Interface (WAI)
4886 library for the Haskell language. It defines a common protocol for
4887 communication between web applications and web servers.")
4890 (define-public ghc-wai-logger
4892 (name "ghc-wai-logger")
4898 "http://hackage.haskell.org/package/wai-logger/wai-logger-"
4903 "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
4904 (build-system haskell-build-system)
4905 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
4906 ; by propagated-inputs.
4908 `(("ghc-auto-update" ,ghc-auto-update)
4909 ("ghc-byteorder" ,ghc-byteorder)
4910 ("ghc-easy-file" ,ghc-easy-file)
4911 ("ghc-unix-time" ,ghc-unix-time)))
4913 `(("ghc-blaze-builder" ,ghc-blaze-builder)
4914 ("ghc-case-insensitive" ,ghc-case-insensitive)
4915 ("ghc-fast-logger" ,ghc-fast-logger)
4916 ("ghc-http-types" ,ghc-http-types)
4917 ("ghc-network" ,ghc-network)
4918 ("ghc-wai" ,ghc-wai)))
4919 (home-page "http://hackage.haskell.org/package/wai-logger")
4920 (synopsis "Logging system for WAI")
4921 (description "This package provides the logging system for WAI.")
4924 (define-public ghc-wai-extra
4926 (name "ghc-wai-extra")
4927 (version "3.0.11.1")
4932 "http://hackage.haskell.org/package/wai-extra/wai-extra-"
4937 "1kr2s5qyx1dvnwr372h7pca4sgxjv0pdx96xkgsfi180h3mb0vq8"))))
4938 (build-system haskell-build-system)
4940 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
4941 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
4942 ("ghc-cookie" ,ghc-cookie)
4943 ("ghc-blaze-builder" ,ghc-blaze-builder)
4944 ("ghc-network" ,ghc-network)
4945 ("ghc-lifted-base" ,ghc-lifted-base)
4946 ("ghc-streaming-commons" ,ghc-streaming-commons)
4947 ("ghc-stringsearch" ,ghc-stringsearch)
4948 ("ghc-resourcet" ,ghc-resourcet)
4949 ("ghc-fast-logger" ,ghc-fast-logger)
4950 ("ghc-wai-logger" ,ghc-wai-logger)
4951 ("ghc-zlib" ,ghc-zlib)
4952 ("ghc-word8" ,ghc-word8)
4953 ("ghc-iproute" ,ghc-iproute)
4954 ("ghc-void" ,ghc-void)))
4956 `(("ghc-wai" ,ghc-wai)
4957 ("ghc-http-types" ,ghc-http-types)
4958 ("ghc-text" ,ghc-text)
4959 ("ghc-case-insensitive" ,ghc-case-insensitive)
4960 ("ghc-data-default-class" ,ghc-data-default-class)
4961 ("ghc-unix-compat" ,ghc-unix-compat)
4962 ("ghc-vault" ,ghc-vault)
4963 ("ghc-aeson" ,ghc-aeson)
4964 ("ghc-hspec" ,ghc-hspec)
4965 ("ghc-hunit" ,ghc-hunit)))
4966 (home-page "http://github.com/yesodweb/wai")
4967 (synopsis "Some basic WAI handlers and middleware")
4968 (description "This library provides basic WAI handlers and middleware
4972 (define-public ghc-deepseq-generics
4974 (name "ghc-deepseq-generics")
4978 (uri (string-append "http://hackage.haskell.org/package/"
4979 "deepseq-generics/deepseq-generics-"
4983 "01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3"))))
4984 (build-system haskell-build-system)
4987 (modify-phases %standard-phases
4988 (add-after 'unpack 'relax-ghc-prim-dependency
4990 (substitute* "deepseq-generics.cabal"
4991 (("< 0.4") "< 0.5"))
4994 `(("ghc-hunit" ,ghc-hunit)
4995 ("ghc-test-framework" ,ghc-test-framework)
4996 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
4997 (home-page "https://github.com/hvr/deepseq-generics")
4998 (synopsis "Generic RNF implementation")
5000 "This package provides a @code{GHC.Generics}-based
5001 @code{Control.DeepSeq.Generics.genericRnf} function which can be used for
5002 providing an 'rnf' implementation.")
5005 (define-public ghc-pandoc-types
5007 (name "ghc-pandoc-types")
5008 (version "1.12.4.7")
5011 (uri (string-append "http://hackage.haskell.org/package/"
5012 "pandoc-types/pandoc-types-"
5016 "108n11kbdaj2ii3cyf0xczhsx90p1gjbxwqp1f0wyn2m3cls632n"))))
5017 (build-system haskell-build-system)
5019 `(("ghc-syb" ,ghc-syb)
5020 ("ghc-aeson" ,ghc-aeson)
5021 ("ghc-deepseq-generics" ,ghc-deepseq-generics)))
5022 (home-page "http://johnmacfarlane.net/pandoc")
5023 (synopsis "Types for representing a structured document")
5025 "This module defines the @code{Pandoc} data structure, which is used by
5026 pandoc to represent structured documents. It also provides functions for
5027 building up, manipulating and serialising @code{Pandoc} structures.")
5030 (define-public ghc-texmath
5032 (name "ghc-texmath")
5036 (uri (string-append "http://hackage.haskell.org/package/"
5037 "texmath/texmath-" version ".tar.gz"))
5040 "15821jg64fbr4rwaglp5ksah6q8qqz1vkjxlqp6d3bbb1rj8v2ri"))))
5041 (build-system haskell-build-system)
5043 `(("ghc-syb" ,ghc-syb)
5044 ("ghc-network-uri" ,ghc-network-uri)
5045 ("ghc-split" ,ghc-split)
5046 ("ghc-temporary" ,ghc-temporary)
5047 ("ghc-utf8-string" ,ghc-utf8-string)
5048 ("ghc-xml" ,ghc-xml)
5049 ("ghc-parsec" ,ghc-parsec)
5050 ("ghc-mtl" ,ghc-mtl)
5051 ("ghc-pandoc-types" ,ghc-pandoc-types)))
5052 (home-page "http://github.com/jgm/texmath")
5053 (synopsis "Conversion between formats used to represent mathematics")
5055 "The texmath library provides functions to read and write TeX math,
5056 presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
5057 Office). Support is also included for converting math formats to pandoc's
5058 native format (allowing conversion, via pandoc, to a variety of different
5059 markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
5060 it can parse and apply LaTeX macros.")
5063 (define-public ghc-regex-pcre-builtin
5065 (name "ghc-regex-pcre-builtin")
5066 (version "0.94.4.8.8.35")
5069 (uri (string-append "http://hackage.haskell.org/package/"
5070 "regex-pcre-builtin/regex-pcre-builtin-"
5074 "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
5075 (build-system haskell-build-system)
5077 `(("ghc-regex-base" ,ghc-regex-base)))
5078 (home-page "http://hackage.haskell.org/package/regex-pcre")
5079 (synopsis "Enhancement of the builtin Text.Regex library")
5081 "This package is an enhancement of the @code{Text.Regex} library,
5082 providing the PCRE backend to accompany regex-base, with bundled code from
5083 @url{http://www.pcre.org}.")
5086 (define-public ghc-diff
5092 (uri (string-append "http://hackage.haskell.org/package/"
5093 "Diff/Diff-" version ".tar.gz"))
5096 "13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz"))))
5097 (build-system haskell-build-system)
5098 (home-page "http://hub.darcs.net/sterlingclover/Diff")
5099 (synopsis "O(ND) diff algorithm in Haskell")
5101 "This package provides an implementation of the standard diff algorithm,
5102 and utilities for pretty printing.")
5105 (define-public ghc-highlighting-kate
5107 (name "ghc-highlighting-kate")
5111 (uri (string-append "http://hackage.haskell.org/package/"
5112 "highlighting-kate/highlighting-kate-"
5116 "16334fbiyq6017zbgc59qc00h0bk24xh4dcrbqx63dvf72ac37dk"))))
5117 (build-system haskell-build-system)
5119 `(("ghc-diff" ,ghc-diff)
5120 ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
5122 `(("ghc-parsec" ,ghc-parsec)
5123 ("ghc-blaze-html" ,ghc-blaze-html)
5124 ("ghc-utf8-string" ,ghc-utf8-string)
5125 ("ghc-mtl" ,ghc-mtl)))
5126 (home-page "http://github.com/jgm/highlighting-kate")
5127 (synopsis "Syntax highlighting library")
5129 "Highlighting-kate is a syntax highlighting library with support for
5130 nearly one hundred languages. The syntax parsers are automatically generated
5131 from @uref{http://kate-editor.org/, Kate syntax descriptions}, so any syntax
5132 supported by Kate can be added. An (optional) command-line program is
5133 provided, along with a utility for generating new parsers from Kate XML syntax
5137 (define-public ghc-cmark
5143 (uri (string-append "http://hackage.haskell.org/package/"
5144 "cmark/cmark-" version ".tar.gz"))
5147 "0c134qh65viaq4q6pv7bnnr5wchzivg94nv0dj8pc1326sx0dw12"))))
5148 (build-system haskell-build-system)
5150 `(("ghc-text" ,ghc-text)))
5152 `(("ghc-hunit" ,ghc-hunit)))
5153 (home-page "https://github.com/jgm/commonmark-hs")
5154 (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
5156 "This package provides Haskell bindings for
5157 @uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
5158 CommonMark, a fully specified variant of Markdown. It includes sources for
5159 libcmark (0.21.0) and does not require prior installation of the C library.")
5162 (define-public ghc-executable-path
5164 (name "ghc-executable-path")
5168 (uri (string-append "http://hackage.haskell.org/package/"
5169 "executable-path/executable-path-"
5173 "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc"))))
5174 (build-system haskell-build-system)
5175 (home-page "http://hackage.haskell.org/package/executable-path")
5176 (synopsis "Find out the full path of the executable")
5178 "The documentation of @code{System.Environment.getProgName} says that
5179 \"However, this is hard-to-impossible to implement on some non-Unix OSes, so
5180 instead, for maximum portability, we just return the leafname of the program
5181 as invoked.\" This library tries to provide the missing path.")
5182 (license public-domain)))
5184 (define-public ghc-enclosed-exceptions
5186 (name "ghc-enclosed-exceptions")
5190 (uri (string-append "http://hackage.haskell.org/package/"
5191 "enclosed-exceptions/enclosed-exceptions-"
5195 "16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5"))))
5196 (build-system haskell-build-system)
5198 `(("ghc-lifted-base" ,ghc-lifted-base)
5199 ("ghc-monad-control" ,ghc-monad-control)
5200 ("ghc-async" ,ghc-async)
5201 ("ghc-transformers-base" ,ghc-transformers-base)))
5203 `(("ghc-hspec" ,ghc-hspec)
5204 ("ghc-quickcheck" ,ghc-quickcheck)))
5205 (home-page "https://github.com/jcristovao/enclosed-exceptions")
5206 (synopsis "Catch all exceptions from within an enclosed computation")
5208 "This library implements a technique to catch all exceptions raised
5209 within an enclosed computation, while remaining responsive to (external)
5210 asynchronous exceptions.")
5213 (define-public ghc-packedstring
5215 (name "ghc-packedstring")
5219 (uri (string-append "http://hackage.haskell.org/package/"
5220 "packedstring/packedstring-"
5224 "1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8"))))
5225 (build-system haskell-build-system)
5228 (modify-phases %standard-phases
5229 (add-after 'unpack 'enable-extension
5231 ;; This package won't compile without the StandaloneDeriving
5233 (substitute* "packedstring.cabal"
5234 (("CPP") "CPP, StandaloneDeriving"))
5236 (home-page "http://hackage.haskell.org/package/packedstring")
5237 (synopsis "Library for packed strings")
5239 "This deprecated library provides an implementation of packed strings.")
5242 (define-public ghc-th-lift
5244 (name "ghc-th-lift")
5248 (uri (string-append "http://hackage.haskell.org/package/"
5249 "th-lift/th-lift-" version ".tar.gz"))
5252 "13xdkk1chdghf059sfx8d3d8r0mj1dbzdi5kf2zf0mjmz3qq7m7k"))))
5253 (build-system haskell-build-system)
5255 `(("ghc-packedstring" ,ghc-packedstring)))
5256 (home-page "http://github.com/mboes/th-lift")
5257 (synopsis "Derive Template Haskell's Lift class for datatypes")
5259 "This is a Haskell library to derive Template Haskell's Lift class for
5263 (define-public ghc-th-expand-syns
5265 (name "ghc-th-expand-syns")
5269 (uri (string-append "http://hackage.haskell.org/package/"
5270 "th-expand-syns/th-expand-syns-"
5274 "03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j"))))
5275 (build-system haskell-build-system)
5277 `(("ghc-syb" ,ghc-syb)))
5278 (home-page "http://hackage.haskell.org/package/th-expand-syns")
5279 (synopsis "Expands type synonyms in Template Haskell ASTs")
5281 "This package enables users to expand type synonyms in Template Haskell
5282 @dfn{abstract syntax trees} (ASTs).")
5285 (define-public ghc-th-reify-many
5287 (name "ghc-th-reify-many")
5291 (uri (string-append "http://hackage.haskell.org/package/"
5292 "th-reify-many/th-reify-many-"
5296 "00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx"))))
5297 (build-system haskell-build-system)
5299 `(("ghc-mtl" ,ghc-mtl)
5300 ("ghc-safe" ,ghc-safe)
5301 ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
5302 (home-page "http://github.com/mgsloan/th-reify-many")
5303 (synopsis "Recurseively reify template haskell datatype info")
5305 "th-reify-many provides functions for recursively reifying top level
5306 declarations. The main intended use case is for enumerating the names of
5307 datatypes reachable from an initial datatype, and passing these names to some
5308 function which generates instances.")
5311 (define-public ghc-th-orphans
5313 (name "ghc-th-orphans")
5317 (uri (string-append "http://hackage.haskell.org/package/"
5318 "th-orphans/th-orphans-" version ".tar.gz"))
5321 "105y03bxh0a2r69l603i7md17gg1vxs1jj1n40pn5q486lmfxbmx"))))
5322 (build-system haskell-build-system)
5324 `(("ghc-th-lift" ,ghc-th-lift)
5325 ("ghc-th-reify-many" ,ghc-th-reify-many)
5326 ("ghc-mtl" ,ghc-mtl)
5327 ("ghc-generic-deriving" ,ghc-generic-deriving)))
5329 `(("ghc-hspec" ,ghc-hspec)))
5330 (home-page "http://hackage.haskell.org/package/th-orphans")
5331 (synopsis "Orphan instances for TH datatypes")
5333 "This package provides orphan instances for Template Haskell datatypes. In particular,
5334 instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
5335 and @code{Eq} instances. These instances used to live in the haskell-src-meta
5336 package, and that's where the version number started.")
5339 (define-public ghc-haskell-src-meta
5341 (name "ghc-haskell-src-meta")
5342 (version "0.6.0.12")
5345 (uri (string-append "http://hackage.haskell.org/package/"
5346 "haskell-src-meta/haskell-src-meta-"
5350 "1mzbfrfvl6pj8068w3m6alzry1403ir1gmz3czg66n5z198l4dql"))))
5351 (build-system haskell-build-system)
5353 `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
5354 ("ghc-syb" ,ghc-syb)
5355 ("ghc-th-orphans" ,ghc-th-orphans)))
5356 (home-page "http://hackage.haskell.org/package/haskell-src-meta")
5357 (synopsis "Parse source to template-haskell abstract syntax")
5359 "This package provides tools to parse Haskell sources to the
5360 template-haskell abstract syntax.")
5363 (define-public ghc-aeson-qq
5365 (name "ghc-aeson-qq")
5369 (uri (string-append "http://hackage.haskell.org/package/"
5370 "aeson-qq/aeson-qq-" version ".tar.gz"))
5373 "1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
5374 (build-system haskell-build-system)
5376 `(("ghc-base-compat" ,ghc-base-compat)
5377 ("ghc-text" ,ghc-text)
5378 ("ghc-attoparsec" ,ghc-attoparsec)
5379 ("ghc-scientific" ,ghc-scientific)
5380 ("ghc-vector" ,ghc-vector)
5381 ("ghc-aeson" ,ghc-aeson)
5382 ("ghc-parsec" ,ghc-parsec)
5383 ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
5385 `(("ghc-hspec" ,ghc-hspec)))
5386 (home-page "http://github.com/zalora/aeson-qq")
5387 (synopsis "JSON quasiquoter for Haskell")
5389 "aeson-qq provides a JSON quasiquoter for Haskell. This package exposes
5390 the function @code{aesonQQ} that compile-time converts a string representation
5391 of a JSON value into a @code{Data.Aeson.Value}.")
5394 (define-public ghc-conduit
5396 (name "ghc-conduit")
5400 (uri (string-append "http://hackage.haskell.org/package/"
5401 "conduit/conduit-" version ".tar.gz"))
5404 "0aq6wswd5dkhdmy7sjhd99mldpq33dqpgbdcwpm94ahvckqxs7v5"))))
5405 (build-system haskell-build-system)
5407 `(("ghc-exceptions" ,ghc-exceptions)
5408 ("ghc-lifted-base" ,ghc-lifted-base)
5409 ("ghc-mmorph" ,ghc-mmorph)
5410 ("ghc-mtl" ,ghc-mtl)
5411 ("ghc-resourcet" ,ghc-resourcet)
5412 ("ghc-transformers-base" ,ghc-transformers-base)
5413 ("ghc-void" ,ghc-void)))
5415 `(("ghc-quickcheck" ,ghc-quickcheck)
5416 ("ghc-hspec" ,ghc-hspec)
5417 ("ghc-safe" ,ghc-safe)))
5418 (home-page "https://github.com/snoyberg/conduit")
5419 (synopsis "Streaming data library ")
5421 "conduit is a solution to the streaming data problem, allowing for
5422 production, transformation, and consumption of streams of data in constant
5423 memory. It is an alternative to lazy I/O which guarantees deterministic
5424 resource handling, and fits in the same general solution space as
5425 enumerator/iteratee and pipes." )
5428 (define-public ghc-logging-facade
5430 (name "ghc-logging-facade")
5434 (uri (string-append "http://hackage.haskell.org/package/"
5435 "logging-facade/logging-facade-"
5439 "0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y"))))
5440 (build-system haskell-build-system)
5442 `(("ghc-hspec" ,ghc-hspec)))
5443 (home-page "http://hackage.haskell.org/package/logging-facade")
5444 (synopsis "Simple logging abstraction that allows multiple back-ends")
5446 "This package provides a simple logging abstraction that allows multiple
5450 (define-public ghc-mockery
5452 (name "ghc-mockery")
5456 (uri (string-append "http://hackage.haskell.org/package/"
5457 "mockery/mockery-" version ".tar.gz"))
5460 "0m0lp2z63sgkylz5318j53r5hnrkp705qh7nqbb149ir4gy7g1bg"))))
5461 (build-system haskell-build-system)
5463 `(("ghc-temporary" ,ghc-temporary)
5464 ("ghc-logging-facade" ,ghc-logging-facade)))
5466 `(("ghc-hspec" ,ghc-hspec)))
5467 (home-page "http://hackage.haskell.org/package/mockery")
5468 (synopsis "Support functions for automated testing")
5470 "The mockery package provides support functions for automated testing.")
5473 (define-public ghc-yaml
5476 (version "0.8.15.1")
5479 (uri (string-append "http://hackage.haskell.org/package/"
5480 "yaml/yaml-" version ".tar.gz"))
5483 "0v6c435xmgm99zxb30pqr7lhkb2a56wxqp70g4hjz8p7rj0vichx"))))
5484 (build-system haskell-build-system)
5486 `(("ghc-conduit" ,ghc-conduit)
5487 ("ghc-resourcet" ,ghc-resourcet)
5488 ("ghc-aeson" ,ghc-aeson)
5489 ("ghc-unordered-containers" ,ghc-unordered-containers)
5490 ("ghc-vector" ,ghc-vector)
5491 ("ghc-text" ,ghc-text)
5492 ("ghc-attoparsec" ,ghc-attoparsec)
5493 ("ghc-scientific" ,ghc-scientific)
5494 ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
5495 ("ghc-aeson-qq" ,ghc-aeson-qq)
5496 ("ghc-base-compat" ,ghc-base-compat)))
5498 `(("ghc-hspec" ,ghc-hspec)
5499 ("ghc-hunit" ,ghc-hunit)
5500 ("ghc-mockery" ,ghc-mockery)))
5501 (home-page "http://github.com/snoyberg/yaml/")
5502 (synopsis "Parsing and rendering YAML documents")
5504 "This package provides a library to parse and render YAML documents.")
5507 (define-public ghc-filemanip
5509 (name "ghc-filemanip")
5513 (uri (string-append "http://hackage.haskell.org/package/"
5514 "filemanip/filemanip-" version ".tar.gz"))
5517 "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
5518 (build-system haskell-build-system)
5520 `(("ghc-mtl" ,ghc-mtl)
5521 ("ghc-unix-compat" ,ghc-unix-compat)))
5522 (home-page "https://github.com/bos/filemanip")
5523 (synopsis "File and directory manipulation for Haskell")
5525 "This package provides a Haskell library for working with files and
5526 directories. It includes code for pattern matching, finding files, modifying
5527 file contents, and more.")
5530 (define-public ghc-mmap
5536 (uri (string-append "http://hackage.haskell.org/package/"
5537 "mmap/mmap-" version ".tar.gz"))
5540 "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
5541 (build-system haskell-build-system)
5542 (home-page "http://hackage.haskell.org/package/mmap")
5543 (synopsis "Memory mapped files for Haskell")
5545 "This library provides a wrapper to @code{mmap}, allowing files or
5546 devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
5547 @code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
5548 do on-demand loading.")
5551 (define-public ghc-juicypixels
5553 (name "ghc-juicypixels")
5557 (uri (string-append "http://hackage.haskell.org/package/"
5558 "JuicyPixels/JuicyPixels-"
5562 "0hxa57cdknz86zywpjwfbdhac5lmk7j0wd5hy4mcnb8mw6r2m592"))))
5563 (build-system haskell-build-system)
5565 `(("ghc-mtl" ,ghc-mtl)
5566 ("ghc-zlib" ,ghc-zlib)
5567 ("ghc-vector" ,ghc-vector)
5568 ("ghc-primitive" ,ghc-primitive)
5569 ("ghc-mmap" ,ghc-mmap)))
5570 (home-page "https://github.com/Twinside/Juicy.Pixels")
5571 (synopsis "Picture loading and serialization library")
5573 "This library can load and store images in PNG, Bitmap, JPEG, Radiance,
5574 TIFF and GIF formats.")
5577 (define-public ghc-sha
5583 (uri (string-append "http://hackage.haskell.org/package/"
5584 "SHA/SHA-" version ".tar.gz"))
5587 "134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64"))))
5588 (build-system haskell-build-system)
5590 `(("ghc-quickcheck" ,ghc-quickcheck)
5591 ("ghc-test-framework" ,ghc-test-framework)
5592 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
5593 (home-page "http://hackage.haskell.org/package/SHA")
5594 (synopsis "SHA suite of message digest functions")
5596 "This library implements the SHA suite of message digest functions,
5597 according to NIST FIPS 180-2 (with the SHA-224 addendum), as well as the
5598 SHA-based HMAC routines. The functions have been tested against most of the
5599 NIST and RFC test vectors for the various functions. While some attention has
5600 been paid to performance, these do not presently reach the speed of well-tuned
5601 libraries, like OpenSSL.")
5604 (define-public ghc-hslua
5610 (uri (string-append "http://hackage.haskell.org/package/"
5611 "hslua/hslua-" version ".tar.gz"))
5614 "0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid"))))
5615 (build-system haskell-build-system)
5617 `(#:configure-flags '("-fsystem-lua")))
5619 `(("lua" ,lua-5.1)))
5621 `(("ghc-text" ,ghc-text)))
5623 `(("ghc-hspec" ,ghc-hspec)
5624 ("ghc-hspec-contrib" ,ghc-hspec-contrib)
5625 ("ghc-hunit" ,ghc-hunit)
5626 ("ghc-quickcheck" ,ghc-quickcheck)
5627 ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
5628 (home-page "http://hackage.haskell.org/package/hslua")
5629 (synopsis "Lua language interpreter embedding in Haskell")
5631 "The Scripting.Lua module is a wrapper of the Lua language interpreter as
5632 described in @url{http://www.lua.org/}.")
5635 (define-public ghc-mime-types
5637 (name "ghc-mime-types")
5641 (uri (string-append "http://hackage.haskell.org/package/"
5642 "mime-types/mime-types-"
5646 "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw"))))
5647 (build-system haskell-build-system)
5649 `(("ghc-text" ,ghc-text)))
5650 (home-page "https://github.com/yesodweb/wai")
5651 (synopsis "Basic MIME type handling types and functions")
5653 "This library provides basic MIME type handling types and functions.")
5656 (define-public idris
5659 (version "0.9.19.1")
5663 (uri (string-append "https://hackage.haskell.org/package/idris-"
5664 version "/idris-" version ".tar.gz"))
5667 "10641svdsjlxbxmbvylpia04cz5nn9486lpiay8ibqcrc1792qgc"))
5668 (modules '((guix build utils)))
5670 '(substitute* "idris.cabal"
5671 ;; Package description file has a too-tight version restriction,
5672 ;; rendering it incompatible with GHC 7.10.2. This is fixed
5674 ;; <https://github.com/idris-lang/Idris-dev/issues/2734>.
5675 (("vector < 0.11") "vector < 0.12")))))
5676 (build-system haskell-build-system)
5678 `(#:phases (modify-phases %standard-phases
5679 (add-before 'configure 'patch-cc-command
5681 (setenv "CC" "gcc"))))))
5684 ("ncurses" ,ncurses)
5685 ("ghc-annotated-wl-pprint" ,ghc-annotated-wl-pprint)
5686 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
5687 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
5688 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
5689 ("ghc-blaze-html" ,ghc-blaze-html)
5690 ("ghc-blaze-markup" ,ghc-blaze-markup)
5691 ("ghc-cheapskate" ,ghc-cheapskate)
5692 ("ghc-fingertree" ,ghc-fingertree)
5693 ("ghc-mtl" ,ghc-mtl)
5694 ("ghc-network" ,ghc-network)
5695 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
5696 ("ghc-parsers" ,ghc-parsers)
5697 ("ghc-safe" ,ghc-safe)
5698 ("ghc-split" ,ghc-split)
5699 ("ghc-text" ,ghc-text)
5700 ("ghc-trifecta" ,ghc-trifecta)
5701 ("ghc-uniplate" ,ghc-uniplate)
5702 ("ghc-unordered-containers" ,ghc-unordered-containers)
5703 ("ghc-utf8-string" ,ghc-utf8-string)
5704 ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)
5705 ("ghc-vector" ,ghc-vector)
5706 ("ghc-zip-archive" ,ghc-zip-archive)
5707 ("ghc-zlib" ,ghc-zlib)))
5708 (home-page "http://www.idris-lang.org")
5709 (synopsis "General purpose language with full dependent types")
5710 (description "Idris is a general purpose language with full dependent
5711 types. It is compiled, with eager evaluation. Dependent types allow types to
5712 be predicated on values, meaning that some aspects of a program's behaviour
5713 can be specified precisely in the type. The language is closely related to
5717 ;;; haskell.scm ends here