gnu: python-pandas: Fix build on 32-bit.
[jackhill/guix/guix.git] / gnu / packages / haskell.scm
1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2015, 2016 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>
6 ;;; Copyright © 2016 Ludovic Courtès <ludo@gnu.org>
7 ;;; Copyright © 2016 ng0 <ng0@we.make.ritual.n0.is>
8 ;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
9 ;;; Copyright © 2015, 2016, 2017 Ricardo Wurmus <rekado@elephly.net>
10 ;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
11 ;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
12 ;;;
13 ;;; This file is part of GNU Guix.
14 ;;;
15 ;;; GNU Guix is free software; you can redistribute it and/or modify it
16 ;;; under the terms of the GNU General Public License as published by
17 ;;; the Free Software Foundation; either version 3 of the License, or (at
18 ;;; your option) any later version.
19 ;;;
20 ;;; GNU Guix is distributed in the hope that it will be useful, but
21 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
22 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 ;;; GNU General Public License for more details.
24 ;;;
25 ;;; You should have received a copy of the GNU General Public License
26 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
27
28 (define-module (gnu packages haskell)
29 #:use-module (gnu packages)
30 #:use-module (gnu packages bootstrap)
31 #:use-module (gnu packages compression)
32 #:use-module (gnu packages elf)
33 #:use-module (gnu packages gcc)
34 #:use-module (gnu packages ghostscript)
35 #:use-module (gnu packages gl)
36 #:use-module (gnu packages libffi)
37 #:use-module (gnu packages lua)
38 #:use-module (gnu packages maths)
39 #:use-module (gnu packages multiprecision)
40 #:use-module (gnu packages ncurses)
41 #:use-module (gnu packages pcre)
42 #:use-module (gnu packages perl)
43 #:use-module (gnu packages pkg-config)
44 #:use-module (gnu packages python)
45 #:use-module (gnu packages sdl)
46 #:use-module (gnu packages xml)
47 #:use-module (gnu packages xorg)
48 #:use-module (gnu packages zip)
49 #:use-module (guix build-system gnu)
50 #:use-module (guix build-system haskell)
51 #:use-module (guix download)
52 #:use-module (guix git-download)
53 #:use-module ((guix licenses) #:prefix license:)
54 #:use-module (guix packages)
55 #:use-module (guix utils)
56 #:use-module (ice-9 regex))
57
58 (define ghc-bootstrap-x86_64-7.8.4
59 (origin
60 (method url-fetch)
61 (uri
62 "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-x86_64-unknown-linux-deb7.tar.xz")
63 (sha256
64 (base32
65 "13azsl53xgj20mi1hj9x0xb32vvcvs6cpmvwx6znxhas7blh0bpn"))))
66
67 (define ghc-bootstrap-i686-7.8.4
68 (origin
69 (method url-fetch)
70 (uri
71 "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-i386-unknown-linux-deb7.tar.xz")
72 (sha256
73 (base32
74 "0wj5s435j0zgww70bj1d3f6wvnnpzlxwvwcyh2qv4qjq5z8j64kg"))))
75
76 ;; 43 tests out of 3965 fail.
77 ;;
78 ;; Most of them do not appear to be serious:
79 ;;
80 ;; - some tests generate files referring to "/bin/sh" and "/bin/ls". I've not
81 ;; figured out how these references are generated.
82 ;;
83 ;; - Some tests allocate more memory than expected (ca. 3% above upper limit)
84 ;;
85 ;; - Some tests try to load unavailable libriries: Control.Concurrent.STM,
86 ;; Data.Vector, Control.Monad.State.
87 ;;
88 ;; - Test posix010 tries to check the existence of a user on the system:
89 ;; getUserEntryForName: does not exist (no such user)
90 (define-public ghc
91 (package
92 (name "ghc")
93 (version "7.10.2")
94 (source
95 (origin
96 (method url-fetch)
97 (uri (string-append "https://www.haskell.org/ghc/dist/"
98 version "/" name "-" version "-src.tar.xz"))
99 (sha256
100 (base32
101 "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal"))))
102 (build-system gnu-build-system)
103 (supported-systems '("i686-linux" "x86_64-linux"))
104 (outputs '("out" "doc"))
105 (inputs
106 `(("gmp" ,gmp)
107 ("ncurses" ,ncurses)
108 ("libffi" ,libffi)
109 ("ghc-testsuite"
110 ,(origin
111 (method url-fetch)
112 (uri (string-append
113 "https://www.haskell.org/ghc/dist/"
114 version "/" name "-" version "-testsuite.tar.xz"))
115 (sha256
116 (base32
117 "0qp9da9ar87zbyn6wjgacd2ic1vgzbi3cklxnhsmjqyafv9qaj4b"))))))
118 (native-inputs
119 `(("perl" ,perl)
120 ("python" ,python-2) ; for tests (fails with python-3)
121 ("ghostscript" ,ghostscript) ; for tests
122 ("patchelf" ,patchelf)
123 ;; GHC is built with GHC. Therefore we need bootstrap binaries.
124 ("ghc-binary"
125 ,(if (string-match "x86_64" (or (%current-target-system) (%current-system)))
126 ghc-bootstrap-x86_64-7.8.4
127 ghc-bootstrap-i686-7.8.4))))
128 (arguments
129 `(#:test-target "test"
130 ;; We get a smaller number of test failures by disabling parallel test
131 ;; execution.
132 #:parallel-tests? #f
133
134 ;; The DSOs use $ORIGIN to refer to each other, but (guix build
135 ;; gremlin) doesn't support it yet, so skip this phase.
136 #:validate-runpath? #f
137
138 ;; Don't pass --build=<triplet>, because the configure script
139 ;; auto-detects slightly different triplets for --host and --target and
140 ;; then complains that they don't match.
141 #:build #f
142
143 #:modules ((guix build gnu-build-system)
144 (guix build utils)
145 (guix build rpath)
146 (srfi srfi-26)
147 (srfi srfi-1))
148 #:imported-modules (,@%gnu-build-system-modules
149 (guix build rpath))
150 #:configure-flags
151 (list
152 (string-append "--with-gmp-libraries="
153 (assoc-ref %build-inputs "gmp") "/lib")
154 (string-append "--with-gmp-includes="
155 (assoc-ref %build-inputs "gmp") "/include")
156 "--with-system-libffi"
157 (string-append "--with-ffi-libraries="
158 (assoc-ref %build-inputs "libffi") "/lib")
159 (string-append "--with-ffi-includes="
160 (assoc-ref %build-inputs "libffi") "/include"))
161 ;; FIXME: The user-guide needs dblatex, docbook-xsl and docbook-utils.
162 ;; Currently we do not have the last one.
163 ;; #:make-flags
164 ;; (list "BUILD_DOCBOOK_HTML = YES")
165 #:phases
166 (let* ((ghc-bootstrap-path
167 (string-append (getcwd) "/" ,name "-" ,version "/ghc-bin"))
168 (ghc-bootstrap-prefix
169 (string-append ghc-bootstrap-path "/usr" )))
170 (alist-cons-after
171 'unpack-bin 'unpack-testsuite-and-fix-bins
172 (lambda* (#:key inputs outputs #:allow-other-keys)
173 (with-directory-excursion ".."
174 (copy-file (assoc-ref inputs "ghc-testsuite")
175 "ghc-testsuite.tar.xz")
176 (system* "tar" "xvf" "ghc-testsuite.tar.xz"))
177 (substitute*
178 (list "testsuite/timeout/Makefile"
179 "testsuite/timeout/timeout.py"
180 "testsuite/timeout/timeout.hs"
181 "testsuite/tests/rename/prog006/Setup.lhs"
182 "testsuite/tests/programs/life_space_leak/life.test"
183 "libraries/process/System/Process/Internals.hs"
184 "libraries/unix/cbits/execvpe.c")
185 (("/bin/sh") (which "sh"))
186 (("/bin/rm") "rm"))
187 #t)
188 (alist-cons-after
189 'unpack 'unpack-bin
190 (lambda* (#:key inputs outputs #:allow-other-keys)
191 (mkdir-p ghc-bootstrap-prefix)
192 (with-directory-excursion ghc-bootstrap-path
193 (copy-file (assoc-ref inputs "ghc-binary")
194 "ghc-bin.tar.xz")
195 (zero? (system* "tar" "xvf" "ghc-bin.tar.xz"))))
196 (alist-cons-before
197 'install-bin 'configure-bin
198 (lambda* (#:key inputs outputs #:allow-other-keys)
199 (let* ((binaries
200 (list
201 "./utils/ghc-pwd/dist-install/build/tmp/ghc-pwd"
202 "./utils/hpc/dist-install/build/tmp/hpc"
203 "./utils/haddock/dist/build/tmp/haddock"
204 "./utils/hsc2hs/dist-install/build/tmp/hsc2hs"
205 "./utils/runghc/dist-install/build/tmp/runghc"
206 "./utils/ghc-cabal/dist-install/build/tmp/ghc-cabal"
207 "./utils/hp2ps/dist/build/tmp/hp2ps"
208 "./utils/ghc-pkg/dist-install/build/tmp/ghc-pkg"
209 "./utils/unlit/dist/build/tmp/unlit"
210 "./ghc/stage2/build/tmp/ghc-stage2"))
211 (gmp (assoc-ref inputs "gmp"))
212 (gmp-lib (string-append gmp "/lib"))
213 (gmp-include (string-append gmp "/include"))
214 (ncurses-lib
215 (string-append (assoc-ref inputs "ncurses") "/lib"))
216 (ld-so (string-append (assoc-ref inputs "libc")
217 ,(glibc-dynamic-linker)))
218 (libtinfo-dir
219 (string-append ghc-bootstrap-prefix
220 "/lib/ghc-7.8.4/terminfo-0.4.0.0")))
221 (with-directory-excursion
222 (string-append ghc-bootstrap-path "/ghc-7.8.4")
223 (setenv "CONFIG_SHELL" (which "bash"))
224 (setenv "LD_LIBRARY_PATH" gmp-lib)
225 ;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded.
226 (for-each
227 (cut system* "patchelf" "--set-interpreter" ld-so <>)
228 binaries)
229 ;; The binaries include a reference to libtinfo.so.5 which
230 ;; is a subset of libncurses.so.5. We create a symlink in a
231 ;; directory included in the bootstrap binaries rpath.
232 (mkdir-p libtinfo-dir)
233 (symlink
234 (string-append ncurses-lib "/libncursesw.so."
235 ,(version-major+minor
236 (package-version ncurses)))
237 (string-append libtinfo-dir "/libtinfo.so.5"))
238 (setenv "PATH"
239 (string-append (getenv "PATH") ":"
240 ghc-bootstrap-prefix "/bin"))
241 (system*
242 (string-append (getcwd) "/configure")
243 (string-append "--prefix=" ghc-bootstrap-prefix)
244 (string-append "--with-gmp-libraries=" gmp-lib)
245 (string-append "--with-gmp-includes=" gmp-include)))))
246 (alist-cons-before
247 'configure 'install-bin
248 (lambda* (#:key inputs outputs #:allow-other-keys)
249 (with-directory-excursion
250 (string-append ghc-bootstrap-path "/ghc-7.8.4")
251 (zero? (system* "make" "install"))))
252 %standard-phases)))))))
253 (native-search-paths (list (search-path-specification
254 (variable "GHC_PACKAGE_PATH")
255 (files (list
256 (string-append "lib/ghc-" version)))
257 (file-pattern ".*\\.conf\\.d$")
258 (file-type 'directory))))
259 (home-page "https://www.haskell.org/ghc")
260 (synopsis "The Glasgow Haskell Compiler")
261 (description
262 "The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
263 interactive environment for the functional language Haskell.")
264 (license license:bsd-3)))
265
266 (define-public ghc-8
267 (package
268 (name "ghc")
269 (version "8.0.2")
270 (source
271 (origin
272 (method url-fetch)
273 (uri (string-append "https://www.haskell.org/ghc/dist/"
274 version "/" name "-" version "-src.tar.xz"))
275 (sha256
276 (base32 "1c8qc4fhkycynk4g1f9hvk53dj6a1vvqi6bklqznns6hw59m8qhi"))
277 (patches
278 (search-patches
279 "ghc-dont-pass-linker-flags-via-response-files.patch"))))
280 (build-system gnu-build-system)
281 (supported-systems '("i686-linux" "x86_64-linux"))
282 (outputs '("out" "doc"))
283 (inputs
284 `(("gmp" ,gmp)
285 ("ncurses" ,ncurses)
286 ("libffi" ,libffi)
287 ("ghc-testsuite"
288 ,(origin
289 (method url-fetch)
290 (uri (string-append
291 "https://www.haskell.org/ghc/dist/"
292 version "/" name "-" version "-testsuite.tar.xz"))
293 (sha256
294 (base32 "1wjc3x68l305bl1h1ijd3yhqp2vqj83lkp3kqbr94qmmkqlms8sj"))))))
295 (native-inputs
296 `(("perl" ,perl)
297 ("python" ,python-2) ; for tests
298 ("ghostscript" ,ghostscript) ; for tests
299 ;; GHC is built with GHC.
300 ("ghc-bootstrap" ,ghc)))
301 (arguments
302 `(#:test-target "test"
303 ;; We get a smaller number of test failures by disabling parallel test
304 ;; execution.
305 #:parallel-tests? #f
306
307 ;; The DSOs use $ORIGIN to refer to each other, but (guix build
308 ;; gremlin) doesn't support it yet, so skip this phase.
309 #:validate-runpath? #f
310
311 ;; Don't pass --build=<triplet>, because the configure script
312 ;; auto-detects slightly different triplets for --host and --target and
313 ;; then complains that they don't match.
314 #:build #f
315
316 #:configure-flags
317 (list
318 (string-append "--with-gmp-libraries="
319 (assoc-ref %build-inputs "gmp") "/lib")
320 (string-append "--with-gmp-includes="
321 (assoc-ref %build-inputs "gmp") "/include")
322 "--with-system-libffi"
323 (string-append "--with-ffi-libraries="
324 (assoc-ref %build-inputs "libffi") "/lib")
325 (string-append "--with-ffi-includes="
326 (assoc-ref %build-inputs "libffi") "/include")
327 (string-append "--with-curses-libraries="
328 (assoc-ref %build-inputs "ncurses") "/lib")
329 (string-append "--with-curses-includes="
330 (assoc-ref %build-inputs "ncurses") "/include"))
331 #:phases
332 (modify-phases %standard-phases
333 (add-after 'unpack 'unpack-testsuite
334 (lambda* (#:key inputs #:allow-other-keys)
335 (with-directory-excursion ".."
336 (copy-file (assoc-ref inputs "ghc-testsuite")
337 "ghc-testsuite.tar.xz")
338 (zero? (system* "tar" "xvf" "ghc-testsuite.tar.xz")))))
339 (add-before 'build 'fix-lib-paths
340 (lambda _
341 (substitute*
342 (list "libraries/process/System/Process/Posix.hs"
343 "libraries/process/tests/process001.hs"
344 "libraries/process/tests/process002.hs"
345 "libraries/unix/cbits/execvpe.c")
346 (("/bin/sh") (which "sh"))
347 (("/bin/ls") (which "ls")))
348 #t))
349 (add-before 'build 'fix-environment
350 (lambda _
351 (unsetenv "GHC_PACKAGE_PATH")
352 (setenv "CONFIG_SHELL" (which "bash"))
353 #t))
354 (add-before 'check 'fix-testsuite
355 (lambda _
356 (substitute*
357 (list "testsuite/timeout/Makefile"
358 "testsuite/timeout/timeout.py"
359 "testsuite/timeout/timeout.hs"
360 "testsuite/tests/programs/life_space_leak/life.test")
361 (("/bin/sh") (which "sh"))
362 (("/bin/rm") "rm"))
363 #t)))))
364 (native-search-paths (list (search-path-specification
365 (variable "GHC_PACKAGE_PATH")
366 (files (list
367 (string-append "lib/ghc-" version)))
368 (file-pattern ".*\\.conf\\.d$")
369 (file-type 'directory))))
370 (home-page "https://www.haskell.org/ghc")
371 (synopsis "The Glasgow Haskell Compiler")
372 (description
373 "The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
374 interactive environment for the functional language Haskell.")
375 (license license:bsd-3)))
376
377 (define-public ghc-hostname
378 (package
379 (name "ghc-hostname")
380 (version "1.0")
381 (source
382 (origin
383 (method url-fetch)
384 (uri (string-append "https://hackage.haskell.org/package/hostname/"
385 "hostname-" version ".tar.gz"))
386 (sha256
387 (base32
388 "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
389 (build-system haskell-build-system)
390 (home-page "https://hackage.haskell.org/package/hostname")
391 (synopsis "Hostname in Haskell")
392 (description "Network.HostName is a simple package providing a means to
393 determine the hostname.")
394 (license license:bsd-3)))
395
396 (define-public ghc-libxml
397 (package
398 (name "ghc-libxml")
399 (version "0.1.1")
400 (source
401 (origin
402 (method url-fetch)
403 (uri (string-append "http://hackage.haskell.org/package/libxml/"
404 "libxml-" version ".tar.gz"))
405 (sha256
406 (base32
407 "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
408 (build-system haskell-build-system)
409 (inputs
410 `(("ghc-mtl" ,ghc-mtl)
411 ("libxml2" ,libxml2)))
412 (arguments
413 `(#:configure-flags
414 `(,(string-append "--extra-include-dirs="
415 (assoc-ref %build-inputs "libxml2")
416 "/include/libxml2"))))
417 (home-page "http://hackage.haskell.org/package/libxml")
418 (synopsis "Haskell bindings to libxml2")
419 (description
420 "This library provides minimal Haskell binding to libxml2.")
421 (license license:bsd-3)))
422
423 (define-public ghc-prelude-extras
424 (package
425 (name "ghc-prelude-extras")
426 (version "0.4.0.2")
427 (source
428 (origin
429 (method url-fetch)
430 (uri (string-append
431 "https://hackage.haskell.org/package/prelude-extras/prelude-extras-"
432 version
433 ".tar.gz"))
434 (sha256
435 (base32
436 "1q7mj9hysy747vimnlyrwsk1wb2axymxixa76fwcbcnmz3fi4llp"))))
437 (build-system haskell-build-system)
438 (home-page "https://github.com/ekmett/prelude-extras")
439 (synopsis "Higher order versions of Prelude classes")
440 (description "This library provides higher order versions of
441 @code{Prelude} classes to ease programming with polymorphic recursion and
442 reduce @code{UndecidableInstances}.")
443 (license license:bsd-3)))
444
445 (define-public ghc-data-default
446 (package
447 (name "ghc-data-default")
448 (version "0.5.3")
449 (source
450 (origin
451 (method url-fetch)
452 (uri (string-append
453 "https://hackage.haskell.org/package/data-default/data-default-"
454 version
455 ".tar.gz"))
456 (sha256
457 (base32 "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c"))))
458 (build-system haskell-build-system)
459 (inputs
460 `(("ghc-data-default-class"
461 ,ghc-data-default-class)
462 ("ghc-data-default-instances-base"
463 ,ghc-data-default-instances-base)
464 ("ghc-data-default-instances-containers"
465 ,ghc-data-default-instances-containers)
466 ("ghc-data-default-instances-dlist"
467 ,ghc-data-default-instances-dlist)
468 ("ghc-data-default-instances-old-locale"
469 ,ghc-data-default-instances-old-locale)))
470 (home-page "https://hackage.haskell.org/package/data-default")
471 (synopsis "Types with default values")
472 (description
473 "This package defines a class for types with a default value, and
474 provides instances for types from the base, containers, dlist and old-locale
475 packages.")
476 (license license:bsd-3)))
477
478 (define-public ghc-data-default-class
479 (package
480 (name "ghc-data-default-class")
481 (version "0.0.1")
482 (source
483 (origin
484 (method url-fetch)
485 (uri (string-append
486 "https://hackage.haskell.org/package/data-default-class/"
487 "data-default-class-" version ".tar.gz"))
488 (sha256
489 (base32 "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d"))))
490 (build-system haskell-build-system)
491 (home-page "https://hackage.haskell.org/package/data-default-class")
492 (synopsis "Types with default values")
493 (description
494 "This package defines a class for types with default values.")
495 (license license:bsd-3)))
496
497 (define-public ghc-data-default-instances-base
498 (package
499 (name "ghc-data-default-instances-base")
500 (version "0.0.1")
501 (source
502 (origin
503 (method url-fetch)
504 (uri (string-append
505 "https://hackage.haskell.org/package/"
506 "data-default-instances-base/"
507 "data-default-instances-base-" version ".tar.gz"))
508 (sha256
509 (base32 "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb"))))
510 (build-system haskell-build-system)
511 (inputs
512 `(("ghc-data-default-class" ,ghc-data-default-class)))
513 (home-page "https://hackage.haskell.org/package/data-default-instances-base")
514 (synopsis "Default instances for types in base")
515 (description
516 "This package provides default instances for types from the base
517 package.")
518 (license license:bsd-3)))
519
520 (define-public ghc-data-default-instances-containers
521 (package
522 (name "ghc-data-default-instances-containers")
523 (version "0.0.1")
524 (source
525 (origin
526 (method url-fetch)
527 (uri (string-append
528 "https://hackage.haskell.org/package/"
529 "data-default-instances-containers/"
530 "data-default-instances-containers-" version ".tar.gz"))
531 (sha256
532 (base32 "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5"))))
533 (build-system haskell-build-system)
534 (inputs
535 `(("ghc-data-default-class" ,ghc-data-default-class)))
536 (home-page "https://hackage.haskell.org/package/data-default-instances-containers")
537 (synopsis "Default instances for types in containers")
538 (description "Provides default instances for types from the containers
539 package.")
540 (license license:bsd-3)))
541
542 (define-public ghc-data-default-instances-dlist
543 (package
544 (name "ghc-data-default-instances-dlist")
545 (version "0.0.1")
546 (source
547 (origin
548 (method url-fetch)
549 (uri (string-append
550 "https://hackage.haskell.org/package/"
551 "data-default-instances-dlist/"
552 "data-default-instances-dlist-" version ".tar.gz"))
553 (sha256
554 (base32 "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x"))))
555 (build-system haskell-build-system)
556 (inputs
557 `(("ghc-data-default-class" ,ghc-data-default-class)
558 ("ghc-dlist" ,ghc-dlist)))
559 (home-page "https://hackage.haskell.org/package/data-default-instances-dlist")
560 (synopsis "Default instances for types in dlist")
561 (description "Provides default instances for types from the dlist
562 package.")
563 (license license:bsd-3)))
564
565 (define-public ghc-haddock-library
566 (package
567 (name "ghc-haddock-library")
568 (version "1.2.1")
569 (source
570 (origin
571 (method url-fetch)
572 (uri (string-append
573 "https://hackage.haskell.org/package/haddock-library/haddock-library-"
574 version
575 ".tar.gz"))
576 (sha256
577 (base32
578 "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g"))))
579 (build-system haskell-build-system)
580 (inputs
581 `(("ghc-base-compat" ,ghc-base-compat)
582 ("ghc-hspec" ,ghc-hspec)
583 ("ghc-quickcheck" ,ghc-quickcheck)))
584 (native-inputs
585 `(("hspec-discover" ,hspec-discover)))
586 (home-page "http://www.haskell.org/haddock/")
587 (synopsis
588 "Library exposing some functionality of Haddock")
589 (description
590 "Haddock is a documentation-generation tool for Haskell libraries. These
591 modules expose some functionality of it without pulling in the GHC dependency.
592 Please note that the API is likely to change so specify upper bounds in your
593 project if you can't release often. For interacting with Haddock itself, see
594 the ‘haddock’ package.")
595 (license license:bsd-3)))
596
597 (define-public ghc-haddock-api
598 (package
599 (name "ghc-haddock-api")
600 (version "2.16.1")
601 (source
602 (origin
603 (method url-fetch)
604 (uri (string-append
605 "https://hackage.haskell.org/package/haddock-api/haddock-api-"
606 version
607 ".tar.gz"))
608 (sha256
609 (base32
610 "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2"))))
611 (build-system haskell-build-system)
612 (inputs
613 `(("ghc-paths" ,ghc-paths)
614 ("ghc-haddock-library" ,ghc-haddock-library)))
615 (home-page "http://www.haskell.org/haddock/")
616 (synopsis "API for documentation-generation tool Haddock")
617 (description "This package provides an API to Haddock, the
618 documentation-generation tool for Haskell libraries.")
619 (license license:bsd-3)))
620
621 (define-public ghc-haddock
622 (package
623 (name "ghc-haddock")
624 (version "2.16.1")
625 (source
626 (origin
627 (method url-fetch)
628 (uri (string-append
629 "https://hackage.haskell.org/package/haddock/haddock-"
630 version
631 ".tar.gz"))
632 (sha256
633 (base32
634 "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26"))))
635 (build-system haskell-build-system)
636 (arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed
637 ; upstream. See
638 ; <https://github.com/haskell/haddock/issues/427>
639 (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
640 (home-page "http://www.haskell.org/haddock/")
641 (synopsis
642 "Documentation-generation tool for Haskell libraries")
643 (description
644 "Haddock is a documentation-generation tool for Haskell libraries.")
645 (license license:bsd-3)))
646
647 (define-public ghc-simple-reflect
648 (package
649 (name "ghc-simple-reflect")
650 (version "0.3.2")
651 (source
652 (origin
653 (method url-fetch)
654 (uri (string-append
655 "https://hackage.haskell.org/package/simple-reflect/simple-reflect-"
656 version
657 ".tar.gz"))
658 (sha256
659 (base32
660 "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq"))))
661 (build-system haskell-build-system)
662 (home-page
663 "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
664 (synopsis
665 "Simple reflection of expressions containing variables")
666 (description
667 "This package allows simple reflection of expressions containing
668 variables. Reflection here means that a Haskell expression is turned into a
669 string. The primary aim of this package is teaching and understanding; there
670 are no options for manipulating the reflected expressions beyond showing
671 them.")
672 (license license:bsd-3)))
673
674 (define-public ghc-multipart
675 (package
676 (name "ghc-multipart")
677 (version "0.1.2")
678 (source
679 (origin
680 (method url-fetch)
681 (uri (string-append
682 "https://hackage.haskell.org/package/multipart/multipart-"
683 version
684 ".tar.gz"))
685 (sha256
686 (base32
687 "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
688 (build-system haskell-build-system)
689 (inputs `(("ghc-parsec" ,ghc-parsec)))
690 (home-page
691 "http://www.github.com/silkapp/multipart")
692 (synopsis
693 "HTTP multipart library")
694 (description
695 "HTTP multipart split out of the cgi package, for Haskell.")
696 (license license:bsd-3)))
697
698 (define-public ghc-html
699 (package
700 (name "ghc-html")
701 (version "1.0.1.2")
702 (source
703 (origin
704 (method url-fetch)
705 (uri (string-append
706 "https://hackage.haskell.org/package/html/html-"
707 version
708 ".tar.gz"))
709 (sha256
710 (base32
711 "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
712 (build-system haskell-build-system)
713 (home-page
714 "https://hackage.haskell.org/package/html")
715 (synopsis "HTML combinator library")
716 (description
717 "This package contains a combinator library for constructing HTML
718 documents.")
719 (license license:bsd-3)))
720
721 (define-public ghc-xhtml
722 (package
723 (name "ghc-xhtml")
724 (version "3000.2.1")
725 (source
726 (origin
727 (method url-fetch)
728 (uri (string-append
729 "https://hackage.haskell.org/package/xhtml/xhtml-"
730 version
731 ".tar.gz"))
732 (sha256
733 (base32
734 "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
735 (build-system haskell-build-system)
736 (home-page "https://github.com/haskell/xhtml")
737 (synopsis "XHTML combinator library")
738 (description
739 "This package provides combinators for producing XHTML 1.0, including the
740 Strict, Transitional and Frameset variants.")
741 (license license:bsd-3)))
742
743 (define-public ghc-haskell-src
744 (package
745 (name "ghc-haskell-src")
746 (version "1.0.2.0")
747 (source
748 (origin
749 (method url-fetch)
750 (uri (string-append
751 "https://hackage.haskell.org/package/haskell-src/haskell-src-"
752 version
753 ".tar.gz"))
754 (sha256
755 (base32
756 "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a"))))
757 (build-system haskell-build-system)
758 (inputs
759 `(("ghc-happy" ,ghc-happy)
760 ("ghc-syb" ,ghc-syb)))
761 (home-page
762 "https://hackage.haskell.org/package/haskell-src")
763 (synopsis
764 "Support for manipulating Haskell source code")
765 (description
766 "The 'haskell-src' package provides support for manipulating Haskell
767 source code. The package provides a lexer, parser and pretty-printer, and a
768 definition of a Haskell abstract syntax tree (AST). Common uses of this
769 package are to parse or generate Haskell 98 code.")
770 (license license:bsd-3)))
771
772 (define-public ghc-alex
773 (package
774 (name "ghc-alex")
775 (version "3.1.4")
776 (source
777 (origin
778 (method url-fetch)
779 (uri (string-append
780 "https://hackage.haskell.org/package/alex/alex-"
781 version
782 ".tar.gz"))
783 (sha256
784 (base32
785 "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn"))))
786 (build-system haskell-build-system)
787 (arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10. Fixed
788 ; upstream, see
789 ; <https://github.com/simonmar/alex/issues/62>
790 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
791 (home-page "http://www.haskell.org/alex/")
792 (synopsis
793 "Tool for generating lexical analysers in Haskell")
794 (description
795 "Alex is a tool for generating lexical analysers in Haskell. It takes a
796 description of tokens based on regular expressions and generates a Haskell
797 module containing code for scanning text efficiently. It is similar to the
798 tool lex or flex for C/C++.")
799 (license license:bsd-3)))
800
801 (define-public ghc-cgi
802 (package
803 (name "ghc-cgi")
804 (version "3001.2.2.2")
805 (source
806 (origin
807 (method url-fetch)
808 (uri (string-append
809 "https://hackage.haskell.org/package/cgi/cgi-"
810 version
811 ".tar.gz"))
812 (sha256
813 (base32
814 "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193"))))
815 (build-system haskell-build-system)
816 (inputs
817 `(("ghc-parsec" ,ghc-parsec)
818 ("ghc-old-locale" ,ghc-old-locale)
819 ("ghc-old-time" ,ghc-old-time)
820 ("ghc-exceptions" ,ghc-exceptions)
821 ("ghc-multipart" ,ghc-multipart)
822 ("ghc-network-uri" ,ghc-network-uri)
823 ("ghc-network" ,ghc-network)
824 ("ghc-mtl" ,ghc-mtl)))
825 (home-page
826 "https://github.com/cheecheeo/haskell-cgi")
827 (synopsis "Library for writing CGI programs")
828 (description
829 "This is a Haskell library for writing CGI programs.")
830 (license license:bsd-3)))
831
832 (define-public ghc-cmdargs
833 (package
834 (name "ghc-cmdargs")
835 (version "0.10.13")
836 (source
837 (origin
838 (method url-fetch)
839 (uri (string-append
840 "https://hackage.haskell.org/package/cmdargs/cmdargs-"
841 version
842 ".tar.gz"))
843 (sha256
844 (base32
845 "0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6"))))
846 (build-system haskell-build-system)
847 (home-page
848 "http://community.haskell.org/~ndm/cmdargs/")
849 (synopsis "Command line argument processing")
850 (description
851 "This library provides an easy way to define command line parsers.")
852 (license license:bsd-3)))
853
854 (define-public ghc-concatenative
855 (package
856 (name "ghc-concatenative")
857 (version "1.0.1")
858 (source (origin
859 (method url-fetch)
860 (uri (string-append
861 "https://hackage.haskell.org/package/concatenative/concatenative-"
862 version ".tar.gz"))
863 (sha256
864 (base32
865 "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd"))))
866 (build-system haskell-build-system)
867 (home-page
868 "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty")
869 (synopsis "Library for postfix control flow")
870 (description
871 "Concatenative gives Haskell Factor-style combinators and arrows for
872 postfix notation. For more information on stack based languages, see
873 @uref{http://concatenative.org}.")
874 (license license:bsd-3)))
875
876 (define-public ghc-happy
877 (package
878 (name "ghc-happy")
879 (version "1.19.5")
880 (source
881 (origin
882 (method url-fetch)
883 (uri (string-append
884 "https://hackage.haskell.org/package/happy/happy-"
885 version
886 ".tar.gz"))
887 (sha256
888 (base32
889 "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32"))))
890 (build-system haskell-build-system)
891 (arguments `(#:tests? #f)) ;; cannot satisfy -package mtl. Possible Cabal
892 ;; issue.
893 (inputs
894 `(("ghc-mtl" ,ghc-mtl)))
895 (home-page "https://hackage.haskell.org/package/happy")
896 (synopsis "Parser generator for Haskell")
897 (description "Happy is a parser generator for Haskell. Given a grammar
898 specification in BNF, Happy generates Haskell code to parse the grammar.
899 Happy works in a similar way to the yacc tool for C.")
900 (license license:bsd-3)))
901
902 (define-public ghc-haskell-src-exts
903 (package
904 (name "ghc-haskell-src-exts")
905 (version "1.16.0.1")
906 (source
907 (origin
908 (method url-fetch)
909 (uri (string-append
910 "https://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-"
911 version
912 ".tar.gz"))
913 (sha256
914 (base32
915 "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz"))))
916 (build-system haskell-build-system)
917 (inputs
918 `(("cpphs" ,cpphs)
919 ("ghc-mtl" ,ghc-mtl)
920 ("ghc-happy" ,ghc-happy)
921 ("ghc-syb" ,ghc-syb)))
922 (native-inputs
923 `(("ghc-smallcheck" ,ghc-smallcheck)
924 ("ghc-tasty" ,ghc-tasty)
925 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
926 ("ghc-tasty-golden" ,ghc-tasty-golden)))
927 (home-page "https://github.com/haskell-suite/haskell-src-exts")
928 (synopsis "Library for manipulating Haskell source")
929 (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
930 extension of the standard @code{haskell-src} package, and handles most
931 registered syntactic extensions to Haskell. All extensions implemented in GHC
932 are supported. Apart from these standard extensions, it also handles regular
933 patterns as per the HaRP extension as well as HSX-style embedded XML syntax.")
934 (license license:bsd-3)))
935
936 (define-public hlint
937 (package
938 (name "hlint")
939 (version "1.9.21")
940 (source
941 (origin
942 (method url-fetch)
943 (uri (string-append
944 "https://hackage.haskell.org/package/" name
945 "/" name "-" version ".tar.gz"))
946 (sha256
947 (base32
948 "14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546"))))
949 (build-system haskell-build-system)
950 (inputs
951 `(("cpphs" ,cpphs)
952 ("ghc-cmdargs" ,ghc-cmdargs)
953 ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
954 ("ghc-uniplate" ,ghc-uniplate)
955 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
956 ("ghc-extra" ,ghc-extra)
957 ("hscolour" ,hscolour)))
958 (home-page "http://community.haskell.org/~ndm/hlint/")
959 (synopsis "Suggest improvements for Haskell source code")
960 (description "HLint reads Haskell programs and suggests changes that
961 hopefully make them easier to read. HLint also makes it easy to disable
962 unwanted suggestions, and to add your own custom suggestions.")
963 (license license:bsd-3)))
964
965 (define-public ghc-resourcet
966 (package
967 (name "ghc-resourcet")
968 (version "1.1.6")
969 (source
970 (origin
971 (method url-fetch)
972 (uri (string-append
973 "https://hackage.haskell.org/package/resourcet/resourcet-"
974 version
975 ".tar.gz"))
976 (sha256
977 (base32
978 "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y"))))
979 (build-system haskell-build-system)
980 (inputs
981 `(("ghc-transformers-base" ,ghc-transformers-base)
982 ("ghc-monad-control" ,ghc-monad-control)
983 ("ghc-transformers-compat" ,ghc-transformers-compat)
984 ("ghc-mtl" ,ghc-mtl)
985 ("ghc-mmorph" ,ghc-mmorph)
986 ("ghc-exceptions" ,ghc-exceptions)))
987 (native-inputs
988 `(("ghc-lifted-base" ,ghc-lifted-base)
989 ("ghc-hspec" ,ghc-hspec)))
990 (home-page "https://github.com/snoyberg/conduit")
991 (synopsis "Deterministic allocation and freeing of scarce resources")
992 (description "ResourceT is a monad transformer which creates a region of
993 code where you can safely allocate resources.")
994 (license license:bsd-3)))
995
996 (define-public ghc-xss-sanitize
997 (package
998 (name "ghc-xss-sanitize")
999 (version "0.3.5.6")
1000 (source
1001 (origin
1002 (method url-fetch)
1003 (uri (string-append
1004 "https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
1005 version
1006 ".tar.gz"))
1007 (sha256
1008 (base32
1009 "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0"))))
1010 (build-system haskell-build-system)
1011 (inputs
1012 `(("ghc-tagsoup" ,ghc-tagsoup)
1013 ("ghc-utf8-string" ,ghc-utf8-string)
1014 ("ghc-css-text" ,ghc-css-text)
1015 ("ghc-network-uri" ,ghc-network-uri)))
1016 (native-inputs
1017 `(("ghc-text" ,ghc-text)
1018 ("ghc-attoparsec" ,ghc-attoparsec)
1019 ("ghc-hspec" ,ghc-hspec)
1020 ("ghc-hunit" ,ghc-hunit)))
1021 (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
1022 (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
1023 (description "This library provides @code{sanitizeXSS}. Run untrusted
1024 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
1025 attacks.")
1026 (license license:bsd-3)))
1027
1028 (define-public ghc-objectname
1029 (package
1030 (name "ghc-objectname")
1031 (version "1.1.0.0")
1032 (source
1033 (origin
1034 (method url-fetch)
1035 (uri (string-append
1036 "https://hackage.haskell.org/package/ObjectName/ObjectName-"
1037 version
1038 ".tar.gz"))
1039 (sha256
1040 (base32
1041 "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg"))))
1042 (build-system haskell-build-system)
1043 (home-page "https://hackage.haskell.org/package/ObjectName")
1044 (synopsis "Helper library for Haskell OpenGL")
1045 (description "This tiny package contains the class ObjectName, which
1046 corresponds to the general notion of explicitly handled identifiers for API
1047 objects, e.g. a texture object name in OpenGL or a buffer object name in
1048 OpenAL.")
1049 (license license:bsd-3)))
1050
1051 (define-public ghc-sdl
1052 (package
1053 (name "ghc-sdl")
1054 (version "0.6.5.1")
1055 (source
1056 (origin
1057 (method url-fetch)
1058 (uri (string-append
1059 "https://hackage.haskell.org/package/SDL/SDL-"
1060 version
1061 ".tar.gz"))
1062 (sha256
1063 (base32
1064 "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46"))))
1065 (build-system haskell-build-system)
1066 (inputs
1067 `(("sdl" ,sdl)))
1068 (home-page "https://hackage.haskell.org/package/SDL")
1069 (synopsis "LibSDL for Haskell")
1070 (description "Simple DirectMedia Layer (libSDL) is a cross-platform
1071 multimedia library designed to provide low level access to audio, keyboard,
1072 mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
1073 by MPEG playback software, emulators, and many popular games, including the
1074 award winning Linux port of \"Civilization: Call To Power.\"")
1075 (license license:bsd-3)))
1076
1077 (define-public ghc-sdl-mixer
1078 (package
1079 (name "ghc-sdl-mixer")
1080 (version "0.6.1.1")
1081 (source
1082 (origin
1083 (method url-fetch)
1084 (uri (string-append
1085 "https://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
1086 version
1087 ".tar.gz"))
1088 (sha256
1089 (base32
1090 "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z"))))
1091 (build-system haskell-build-system)
1092 (arguments
1093 `(#:configure-flags
1094 (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
1095 (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
1096 (list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
1097 (inputs
1098 `(("ghc-sdl" ,ghc-sdl)
1099 ("sdl-mixer" ,sdl-mixer)))
1100 (home-page "https://hackage.haskell.org/package/SDL-mixer")
1101 (synopsis "Haskell bindings to libSDL_mixer")
1102 (description "SDL_mixer is a sample multi-channel audio mixer library. It
1103 supports any number of simultaneously playing channels of 16 bit stereo audio,
1104 plus a single channel of music, mixed by the popular MikMod MOD, Timidity
1105 MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
1106 (license license:bsd-3)))
1107
1108 (define-public ghc-sdl-image
1109 (package
1110 (name "ghc-sdl-image")
1111 (version "0.6.1.1")
1112 (source
1113 (origin
1114 (method url-fetch)
1115 (uri (string-append
1116 "https://hackage.haskell.org/package/SDL-image/SDL-image-"
1117 version
1118 ".tar.gz"))
1119 (sha256
1120 (base32
1121 "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq"))))
1122 (build-system haskell-build-system)
1123 (arguments
1124 `(#:configure-flags
1125 (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
1126 (sdl-image-include (string-append sdl-image "/include/SDL")))
1127 (list (string-append "--extra-include-dirs=" sdl-image-include)))))
1128 (inputs
1129 `(("ghc-sdl" ,ghc-sdl)
1130 ("sdl-image" ,sdl-image)))
1131 (home-page "https://hackage.haskell.org/package/SDL-image")
1132 (synopsis "Haskell bindings to libSDL_image")
1133 (description "SDL_image is an image file loading library. It loads images
1134 as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
1135 PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
1136 (license license:bsd-3)))
1137
1138 (define-public ghc-half
1139 (package
1140 (name "ghc-half")
1141 (version "0.2.2.1")
1142 (source
1143 (origin
1144 (method url-fetch)
1145 (uri (string-append
1146 "https://hackage.haskell.org/package/half/half-"
1147 version
1148 ".tar.gz"))
1149 (sha256
1150 (base32
1151 "0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1"))))
1152 (build-system haskell-build-system)
1153 (home-page "https://github.com/ekmett/half")
1154 (synopsis "Half-precision floating-point computations")
1155 (description "This library provides a half-precision floating-point
1156 computation library for Haskell.")
1157 (license license:bsd-3)))
1158
1159 (define-public ghc-openglraw
1160 (package
1161 (name "ghc-openglraw")
1162 (version "2.5.1.0")
1163 (source
1164 (origin
1165 (method url-fetch)
1166 (uri (string-append
1167 "https://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
1168 version
1169 ".tar.gz"))
1170 (sha256
1171 (base32
1172 "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k"))))
1173 (build-system haskell-build-system)
1174 (inputs
1175 `(("ghc-half" ,ghc-half)
1176 ("glu" ,glu)
1177 ("ghc-text" ,ghc-text)))
1178 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1179 (synopsis "Raw Haskell bindings for the OpenGL graphics system")
1180 (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
1181 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
1182 of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
1183 offers access to all necessary functions, tokens and types plus a general
1184 facility for loading extension entries. The module hierarchy closely mirrors
1185 the naming structure of the OpenGL extensions, making it easy to find the
1186 right module to import. All API entries are loaded dynamically, so no special
1187 C header files are needed for building this package. If an API entry is not
1188 found at runtime, a userError is thrown.")
1189 (license license:bsd-3)))
1190
1191 (define-public ghc-glut
1192 (package
1193 (name "ghc-glut")
1194 (version "2.7.0.3")
1195 (source
1196 (origin
1197 (method url-fetch)
1198 (uri (string-append
1199 "https://hackage.haskell.org/package/GLUT/GLUT-"
1200 version
1201 ".tar.gz"))
1202 (sha256
1203 (base32
1204 "1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2"))))
1205 (build-system haskell-build-system)
1206 (inputs
1207 `(("ghc-statevar" ,ghc-statevar)
1208 ("ghc-opengl" ,ghc-opengl)
1209 ("ghc-openglraw" ,ghc-openglraw)
1210 ("freeglut" ,freeglut)))
1211 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1212 (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
1213 (description "This library provides Haskell bindings for the OpenGL
1214 Utility Toolkit, a window system-independent toolkit for writing OpenGL
1215 programs.")
1216 (license license:bsd-3)))
1217
1218 (define-public ghc-gluraw
1219 (package
1220 (name "ghc-gluraw")
1221 (version "1.5.0.2")
1222 (source
1223 (origin
1224 (method url-fetch)
1225 (uri (string-append
1226 "https://hackage.haskell.org/package/GLURaw/GLURaw-"
1227 version
1228 ".tar.gz"))
1229 (sha256
1230 (base32
1231 "0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x"))))
1232 (build-system haskell-build-system)
1233 (inputs
1234 `(("ghc-openglraw" ,ghc-openglraw)))
1235 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1236 (synopsis "Raw Haskell bindings GLU")
1237 (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
1238 utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
1239 basis for a nicer interface.")
1240 (license license:bsd-3)))
1241
1242 (define-public ghc-opengl
1243 (package
1244 (name "ghc-opengl")
1245 (version "2.12.0.1")
1246 (source
1247 (origin
1248 (method url-fetch)
1249 (uri (string-append
1250 "https://hackage.haskell.org/package/OpenGL/OpenGL-"
1251 version
1252 ".tar.gz"))
1253 (sha256
1254 (base32
1255 "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b"))))
1256 (build-system haskell-build-system)
1257 (inputs
1258 `(("ghc-text" ,ghc-text)
1259 ("ghc-objectname" ,ghc-objectname)
1260 ("ghc-gluraw" ,ghc-gluraw)
1261 ("ghc-statevar" ,ghc-statevar)
1262 ("ghc-openglraw" ,ghc-openglraw)))
1263 (home-page "http://www.haskell.org/haskellwiki/Opengl")
1264 (synopsis "Haskell bindings for the OpenGL graphics system")
1265 (description "This package provides Haskell bindings for the OpenGL
1266 graphics system (GL, version 4.5) and its accompanying utility library (GLU,
1267 version 1.3).")
1268 (license license:bsd-3)))
1269
1270 (define-public ghc-streaming-commons
1271 (package
1272 (name "ghc-streaming-commons")
1273 (version "0.1.14.2")
1274 (source
1275 (origin
1276 (method url-fetch)
1277 (uri (string-append
1278 "https://hackage.haskell.org/package/streaming-commons/streaming-commons-"
1279 version
1280 ".tar.gz"))
1281 (sha256
1282 (base32
1283 "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
1284 (build-system haskell-build-system)
1285 (inputs
1286 `(("ghc-blaze-builder" ,ghc-blaze-builder)
1287 ("ghc-network" ,ghc-network)
1288 ("ghc-random" ,ghc-random)
1289 ("ghc-stm" ,ghc-stm)
1290 ("ghc-text" ,ghc-text)
1291 ("ghc-zlib" ,ghc-zlib)))
1292 (native-inputs
1293 `(("ghc-quickcheck" ,ghc-quickcheck)
1294 ("ghc-hspec" ,ghc-hspec)
1295 ("hspec-discover" ,hspec-discover)))
1296 (home-page "https://hackage.haskell.org/package/streaming-commons")
1297 (synopsis "Conduit and pipes needed by some streaming data libraries")
1298 (description "Provides low-dependency functionality commonly needed by
1299 various Haskell streaming data libraries, such as @code{conduit} and
1300 @code{pipe}s.")
1301 (license license:bsd-3)))
1302
1303 (define-public cpphs
1304 (package
1305 (name "cpphs")
1306 (version "1.19.3")
1307 (source
1308 (origin
1309 (method url-fetch)
1310 (uri (string-append
1311 "https://hackage.haskell.org/package/" name "/"
1312 name "-" version ".tar.gz"))
1313 (sha256
1314 (base32
1315 "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
1316 (build-system haskell-build-system)
1317 (inputs
1318 `(("ghc-polyparse" ,ghc-polyparse)
1319 ("ghc-old-locale" ,ghc-old-locale)
1320 ("ghc-old-time" ,ghc-old-time)))
1321 (home-page "http://projects.haskell.org/cpphs/")
1322 (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
1323 (description "Cpphs is a re-implementation of the C pre-processor that is
1324 both more compatible with Haskell, and itself written in Haskell so that it
1325 can be distributed with compilers. This version of the C pre-processor is
1326 pretty-much feature-complete and compatible with traditional (K&R)
1327 pre-processors. Additional features include: a plain-text mode; an option to
1328 unlit literate code files; and an option to turn off macro-expansion.")
1329 (license (list license:lgpl2.1+ license:gpl3+))))
1330
1331 (define-public ghc-reflection
1332 (package
1333 (name "ghc-reflection")
1334 (version "2.1")
1335 (source
1336 (origin
1337 (method url-fetch)
1338 (uri (string-append
1339 "https://hackage.haskell.org/package/reflection/reflection-"
1340 version
1341 ".tar.gz"))
1342 (sha256
1343 (base32
1344 "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
1345 (build-system haskell-build-system)
1346 (inputs `(("ghc-tagged" ,ghc-tagged)))
1347 (home-page "https://github.com/ekmett/reflection")
1348 (synopsis "Reify arbitrary terms into types that can be reflected back
1349 into terms")
1350 (description "This package addresses the 'configuration problem' which is
1351 propogating configurations that are available at run-time, allowing multiple
1352 configurations to coexist without resorting to mutable global variables or
1353 @code{System.IO.Unsafe.unsafePerformIO}.")
1354 (license license:bsd-3)))
1355
1356 (define-public ghc-old-locale
1357 (package
1358 (name "ghc-old-locale")
1359 (version "1.0.0.7")
1360 (source
1361 (origin
1362 (method url-fetch)
1363 (uri (string-append
1364 "https://hackage.haskell.org/package/old-locale/old-locale-"
1365 version
1366 ".tar.gz"))
1367 (sha256
1368 (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
1369 (build-system haskell-build-system)
1370 (home-page "https://hackage.haskell.org/package/old-locale")
1371 (synopsis "Adapt to locale conventions")
1372 (description
1373 "This package provides the ability to adapt to locale conventions such as
1374 date and time formats.")
1375 (license license:bsd-3)))
1376
1377 (define-public ghc-old-time
1378 (package
1379 (name "ghc-old-time")
1380 (version "1.1.0.3")
1381 (source
1382 (origin
1383 (method url-fetch)
1384 (uri (string-append
1385 "https://hackage.haskell.org/package/old-time/old-time-"
1386 version
1387 ".tar.gz"))
1388 (sha256
1389 (base32
1390 "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
1391 (build-system haskell-build-system)
1392 (inputs
1393 `(("ghc-old-locale" ,ghc-old-locale)))
1394 (home-page "https://hackage.haskell.org/package/old-time")
1395 (synopsis "Time compatibility library for Haskell")
1396 (description "Old-time is a package for backwards compatibility with the
1397 old @code{time} library. For new projects, the newer
1398 @uref{https://hackage.haskell.org/package/time, time library} is recommended.")
1399 (license license:bsd-3)))
1400
1401 (define-public ghc-data-default-instances-old-locale
1402 (package
1403 (name "ghc-data-default-instances-old-locale")
1404 (version "0.0.1")
1405 (source
1406 (origin
1407 (method url-fetch)
1408 (uri (string-append
1409 "https://hackage.haskell.org/package/"
1410 "data-default-instances-old-locale/"
1411 "data-default-instances-old-locale-" version ".tar.gz"))
1412 (sha256
1413 (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0"))))
1414 (build-system haskell-build-system)
1415 (inputs
1416 `(("ghc-data-default-class" ,ghc-data-default-class)
1417 ("ghc-old-locale" ,ghc-old-locale)))
1418 (home-page
1419 "https://hackage.haskell.org/package/data-default-instances-old-locale")
1420 (synopsis "Default instances for types in old-locale")
1421 (description "Provides Default instances for types from the old-locale
1422 package.")
1423 (license license:bsd-3)))
1424
1425 (define-public ghc-dlist
1426 (package
1427 (name "ghc-dlist")
1428 (version "0.7.1.2")
1429 (source
1430 (origin
1431 (method url-fetch)
1432 (uri (string-append
1433 "https://hackage.haskell.org/package/dlist/dlist-"
1434 version
1435 ".tar.gz"))
1436 (sha256
1437 (base32 "10rp96rryij7d8gz5kv8ygc6chm1624ck5mbnqs2a3fkdzqj2b9k"))))
1438 (build-system haskell-build-system)
1439 (inputs
1440 `(("ghc-quickcheck" ,ghc-quickcheck)))
1441 (home-page "https://github.com/spl/dlist")
1442 (synopsis "Difference lists")
1443 (description
1444 "Difference lists are a list-like type supporting O(1) append. This is
1445 particularly useful for efficient logging and pretty printing (e.g. with the
1446 Writer monad), where list append quickly becomes too expensive.")
1447 (license license:bsd-3)))
1448
1449 (define-public ghc-extensible-exceptions
1450 (package
1451 (name "ghc-extensible-exceptions")
1452 (version "0.1.1.4")
1453 (source
1454 (origin
1455 (method url-fetch)
1456 (uri (string-append "https://hackage.haskell.org/package/"
1457 "extensible-exceptions/extensible-exceptions-"
1458 version ".tar.gz"))
1459 (sha256
1460 (base32 "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc"))))
1461 (build-system haskell-build-system)
1462 (home-page "https://hackage.haskell.org/package/extensible-exceptions")
1463 (synopsis "Extensible exceptions for Haskell")
1464 (description
1465 "This package provides extensible exceptions for both new and old
1466 versions of GHC (i.e., < 6.10).")
1467 (license license:bsd-3)))
1468
1469 (define-public cabal-install
1470 (package
1471 (name "cabal-install")
1472 (version "1.22.6.0")
1473 (source
1474 (origin
1475 (method url-fetch)
1476 (uri (string-append
1477 "https://hackage.haskell.org/package/cabal-install/cabal-install-"
1478 version
1479 ".tar.gz"))
1480 (sha256
1481 (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx"))))
1482 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
1483 (build-system haskell-build-system)
1484 (inputs
1485 `(("ghc-http" ,ghc-http)
1486 ("ghc-mtl" ,ghc-mtl)
1487 ("ghc-network-uri" ,ghc-network-uri)
1488 ("ghc-network" ,ghc-network)
1489 ("ghc-random" ,ghc-random)
1490 ("ghc-stm" ,ghc-stm)
1491 ("ghc-zlib" ,ghc-zlib)))
1492 (home-page "http://www.haskell.org/cabal/")
1493 (synopsis "Command-line interface for Cabal and Hackage")
1494 (description
1495 "The cabal command-line program simplifies the process of managing
1496 Haskell software by automating the fetching, configuration, compilation and
1497 installation of Haskell libraries and programs.")
1498 (license license:bsd-3)))
1499
1500 (define-public ghc-mtl
1501 (package
1502 (name "ghc-mtl")
1503 (version "2.2.1")
1504 (outputs '("out" "doc"))
1505 (source
1506 (origin
1507 (method url-fetch)
1508 (uri (string-append
1509 "https://hackage.haskell.org/package/mtl/mtl-"
1510 version
1511 ".tar.gz"))
1512 (sha256
1513 (base32
1514 "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
1515 (build-system haskell-build-system)
1516 (home-page "https://github.com/ekmett/mtl")
1517 (synopsis
1518 "Monad classes, using functional dependencies")
1519 (description "Monad classes using functional dependencies, with instances
1520 for various monad transformers, inspired by the paper 'Functional Programming
1521 with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced
1522 School of Functional Programming', 1995. See
1523 @uref{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
1524 (license license:bsd-3)))
1525
1526 (define-public ghc-paths
1527 (package
1528 (name "ghc-paths")
1529 (version "0.1.0.9")
1530 (outputs '("out" "doc"))
1531 (source
1532 (origin
1533 (method url-fetch)
1534 (uri (string-append
1535 "https://hackage.haskell.org/package/ghc-paths/ghc-paths-"
1536 version
1537 ".tar.gz"))
1538 (sha256
1539 (base32
1540 "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
1541 (build-system haskell-build-system)
1542 (home-page "https://github.com/simonmar/ghc-paths")
1543 (synopsis
1544 "Knowledge of GHC's installation directories")
1545 (description
1546 "Knowledge of GHC's installation directories.")
1547 (license license:bsd-3)))
1548
1549 (define-public ghc-utf8-string
1550 (package
1551 (name "ghc-utf8-string")
1552 (version "1.0.1.1")
1553 (source
1554 (origin
1555 (method url-fetch)
1556 (uri (string-append
1557 "https://hackage.haskell.org/package/utf8-string/utf8-string-"
1558 version
1559 ".tar.gz"))
1560 (sha256
1561 (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv"))))
1562 (build-system haskell-build-system)
1563 (home-page "https://github.com/glguy/utf8-string/")
1564 (synopsis "Support for reading and writing UTF8 Strings")
1565 (description
1566 "A UTF8 layer for Strings. The utf8-string package provides operations
1567 for encoding UTF8 strings to Word8 lists and back, and for reading and writing
1568 UTF8 without truncation.")
1569 (license license:bsd-3)))
1570
1571 (define-public ghc-setenv
1572 (package
1573 (name "ghc-setenv")
1574 (version "0.1.1.3")
1575 (source
1576 (origin
1577 (method url-fetch)
1578 (uri (string-append
1579 "https://hackage.haskell.org/package/setenv/setenv-"
1580 version
1581 ".tar.gz"))
1582 (sha256
1583 (base32
1584 "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73"))))
1585 (build-system haskell-build-system)
1586 (home-page "https://hackage.haskell.org/package/setenv")
1587 (synopsis "Library for setting environment variables")
1588 (description "This package provides a Haskell library for setting
1589 environment variables.")
1590 (license license:expat)))
1591
1592 (define-public ghc-setlocale
1593 (package
1594 (name "ghc-setlocale")
1595 (version "1.0.0.4")
1596 (source (origin
1597 (method url-fetch)
1598 (uri (string-append
1599 "https://hackage.haskell.org/package/setlocale-"
1600 version "/setlocale-" version ".tar.gz"))
1601 (sha256
1602 (base32
1603 "1sd73zgpijr9xjdj5p562cmlcxmx5iff5k8xh9b6rpcgrgnnlf9j"))))
1604 (build-system haskell-build-system)
1605 (home-page "https://hackage.haskell.org/package/setlocale")
1606 (synopsis "Haskell bindings to setlocale")
1607 (description "This package provides Haskell bindings to the
1608 @code{setlocale} C function.")
1609 (license license:bsd-3)))
1610
1611 (define-public ghc-x11
1612 (package
1613 (name "ghc-x11")
1614 (version "1.6.1.2")
1615 (source
1616 (origin
1617 (method url-fetch)
1618 (uri (string-append "https://hackage.haskell.org/package/X11/"
1619 "X11-" version ".tar.gz"))
1620 (sha256
1621 (base32 "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj"))))
1622 (build-system haskell-build-system)
1623 (inputs
1624 `(("libx11" ,libx11)
1625 ("libxrandr" ,libxrandr)
1626 ("libxinerama" ,libxinerama)
1627 ("libxscrnsaver" ,libxscrnsaver)
1628 ("ghc-data-default" ,ghc-data-default)))
1629 (home-page "https://github.com/haskell-pkg-janitors/X11")
1630 (synopsis "Bindings to the X11 graphics library")
1631 (description
1632 "This package provides Haskell bindings to the X11 graphics library. The
1633 bindings are a direct translation of the C bindings.")
1634 (license license:bsd-3)))
1635
1636 (define-public ghc-x11-xft
1637 (package
1638 (name "ghc-x11-xft")
1639 (version "0.3.1")
1640 (source
1641 (origin
1642 (method url-fetch)
1643 (uri (string-append "https://hackage.haskell.org/package/X11-xft/"
1644 "X11-xft-" version ".tar.gz"))
1645 (sha256
1646 (base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
1647 (inputs
1648 `(("ghc-x11" ,ghc-x11)
1649 ("ghc-utf8-string" ,ghc-utf8-string)
1650 ("libx11" ,libx11)
1651 ("libxft" ,libxft)
1652 ("xproto" ,xproto)))
1653 (native-inputs
1654 `(("pkg-config" ,pkg-config)))
1655 (build-system haskell-build-system)
1656 (home-page "https://hackage.haskell.org/package/X11-xft")
1657 (synopsis "Bindings to Xft")
1658 (description
1659 "Bindings to the Xft, X Free Type interface library, and some Xrender
1660 parts.")
1661 (license license:lgpl2.1)))
1662
1663 (define-public ghc-stringbuilder
1664 (package
1665 (name "ghc-stringbuilder")
1666 (version "0.5.0")
1667 (source
1668 (origin
1669 (method url-fetch)
1670 (uri (string-append
1671 "https://hackage.haskell.org/package/stringbuilder/stringbuilder-"
1672 version
1673 ".tar.gz"))
1674 (sha256
1675 (base32
1676 "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9"))))
1677 (build-system haskell-build-system)
1678 (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests
1679 ; enabled
1680 (home-page "https://hackage.haskell.org/package/stringbuilder")
1681 (synopsis "Writer monad for multi-line string literals")
1682 (description "This package provides a writer monad for multi-line string
1683 literals.")
1684 (license license:expat)))
1685
1686 (define-public ghc-zlib
1687 (package
1688 (name "ghc-zlib")
1689 (version "0.5.4.2")
1690 (outputs '("out" "doc"))
1691 (source
1692 (origin
1693 (method url-fetch)
1694 (uri (string-append
1695 "https://hackage.haskell.org/package/zlib/zlib-"
1696 version
1697 ".tar.gz"))
1698 (sha256
1699 (base32
1700 "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
1701 (build-system haskell-build-system)
1702 (inputs `(("zlib" ,zlib)))
1703 (home-page "https://hackage.haskell.org/package/zlib")
1704 (synopsis
1705 "Compression and decompression in the gzip and zlib formats")
1706 (description
1707 "This package provides a pure interface for compressing and decompressing
1708 streams of data represented as lazy 'ByteString's. It uses the zlib C library
1709 so it has high performance. It supports the 'zlib', 'gzip' and 'raw'
1710 compression formats. It provides a convenient high level API suitable for
1711 most tasks and for the few cases where more control is needed it provides
1712 access to the full zlib feature set.")
1713 (license license:bsd-3)))
1714
1715 (define-public ghc-stm
1716 (package
1717 (name "ghc-stm")
1718 (version "2.4.4")
1719 (outputs '("out" "doc"))
1720 (source
1721 (origin
1722 (method url-fetch)
1723 (uri (string-append
1724 "https://hackage.haskell.org/package/stm/stm-"
1725 version
1726 ".tar.gz"))
1727 (sha256
1728 (base32
1729 "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
1730 (build-system haskell-build-system)
1731 (home-page "https://hackage.haskell.org/package/stm")
1732 (synopsis "Software Transactional Memory")
1733 (description
1734 "A modular composable concurrency abstraction.")
1735 (license license:bsd-3)))
1736
1737 (define-public ghc-parallel
1738 (package
1739 (name "ghc-parallel")
1740 (version "3.2.0.6")
1741 (outputs '("out" "doc"))
1742 (source
1743 (origin
1744 (method url-fetch)
1745 (uri (string-append
1746 "https://hackage.haskell.org/package/parallel/parallel-"
1747 version
1748 ".tar.gz"))
1749 (sha256
1750 (base32
1751 "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
1752 (build-system haskell-build-system)
1753 (home-page "https://hackage.haskell.org/package/parallel")
1754 (synopsis "Parallel programming library")
1755 (description
1756 "This package provides a library for parallel programming.")
1757 (license license:bsd-3)))
1758
1759 (define-public ghc-text
1760 (package
1761 (name "ghc-text")
1762 (version "1.2.1.3")
1763 (outputs '("out" "doc"))
1764 (source
1765 (origin
1766 (method url-fetch)
1767 (uri (string-append
1768 "https://hackage.haskell.org/package/text/text-"
1769 version
1770 ".tar.gz"))
1771 (sha256
1772 (base32
1773 "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq"))))
1774 (build-system haskell-build-system)
1775 (arguments
1776 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
1777 (home-page "https://github.com/bos/text")
1778 (synopsis "Efficient packed Unicode text type library")
1779 (description
1780 "An efficient packed, immutable Unicode text type (both strict and
1781 lazy), with a powerful loop fusion optimization framework.
1782
1783 The 'Text' type represents Unicode character strings, in a time and
1784 space-efficient manner. This package provides text processing
1785 capabilities that are optimized for performance critical use, both
1786 in terms of large data quantities and high speed.")
1787 (license license:bsd-3)))
1788
1789 (define-public ghc-hashable
1790 (package
1791 (name "ghc-hashable")
1792 (version "1.2.3.3")
1793 (outputs '("out" "doc"))
1794 (source
1795 (origin
1796 (method url-fetch)
1797 (uri (string-append
1798 "https://hackage.haskell.org/package/hashable/hashable-"
1799 version
1800 ".tar.gz"))
1801 (sha256
1802 (base32
1803 "0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw"))))
1804 (build-system haskell-build-system)
1805 (arguments
1806 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
1807 (inputs
1808 `(("ghc-text" ,ghc-text)))
1809 (home-page "https://github.com/tibbe/hashable")
1810 (synopsis
1811 "Class for types that can be converted to a hash value")
1812 (description
1813 "This package defines a class, 'Hashable', for types that can be
1814 converted to a hash value. This class exists for the benefit of hashing-based
1815 data structures. The package provides instances for basic types and a way to
1816 combine hash values.")
1817 (license license:bsd-3)))
1818
1819 (define-public ghc-hunit
1820 (package
1821 (name "ghc-hunit")
1822 (version "1.2.5.2")
1823 (outputs '("out" "doc"))
1824 (source
1825 (origin
1826 (method url-fetch)
1827 (uri (string-append
1828 "https://hackage.haskell.org/package/HUnit/HUnit-"
1829 version
1830 ".tar.gz"))
1831 (sha256
1832 (base32
1833 "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
1834 (build-system haskell-build-system)
1835 (home-page "http://hunit.sourceforge.net/")
1836 (synopsis "Unit testing framework for Haskell")
1837 (description
1838 "HUnit is a unit testing framework for Haskell, inspired by the
1839 JUnit tool for Java.")
1840 (license license:bsd-3)))
1841
1842 (define-public ghc-random
1843 (package
1844 (name "ghc-random")
1845 (version "1.1")
1846 (outputs '("out" "doc"))
1847 (source
1848 (origin
1849 (method url-fetch)
1850 (uri (string-append
1851 "https://hackage.haskell.org/package/random/random-"
1852 version
1853 ".tar.gz"))
1854 (sha256
1855 (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
1856 (build-system haskell-build-system)
1857 (home-page "https://hackage.haskell.org/package/random")
1858 (synopsis "Random number library")
1859 (description "This package provides a basic random number generation
1860 library, including the ability to split random number generators.")
1861 (license license:bsd-3)))
1862
1863 (define-public ghc-primitive
1864 (package
1865 (name "ghc-primitive")
1866 (version "0.6.1.0")
1867 (outputs '("out" "doc"))
1868 (source
1869 (origin
1870 (method url-fetch)
1871 (uri (string-append
1872 "https://hackage.haskell.org/package/primitive/primitive-"
1873 version
1874 ".tar.gz"))
1875 (sha256
1876 (base32
1877 "1j1q7l21rdm8kfs93vibr3xwkkhqis181w2k6klfhx5g5skiywwk"))))
1878 (build-system haskell-build-system)
1879 (home-page
1880 "https://github.com/haskell/primitive")
1881 (synopsis "Primitive memory-related operations")
1882 (description
1883 "This package provides various primitive memory-related operations.")
1884 (license license:bsd-3)))
1885
1886 (define-public ghc-test-framework
1887 (package
1888 (name "ghc-test-framework")
1889 (version "0.8.1.1")
1890 (source
1891 (origin
1892 (method url-fetch)
1893 (uri (string-append "https://hackage.haskell.org/package/test-framework/"
1894 "test-framework-" version ".tar.gz"))
1895 (sha256
1896 (base32
1897 "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
1898 (build-system haskell-build-system)
1899 (native-inputs
1900 `(("ghc-hunit" ,ghc-hunit)
1901 ("ghc-quickcheck" ,ghc-quickcheck)))
1902 (inputs
1903 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
1904 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
1905 ("ghc-hostname" ,ghc-hostname)
1906 ("ghc-old-locale" ,ghc-old-locale)
1907 ("ghc-random" ,ghc-random)
1908 ("ghc-regex-posix" ,ghc-regex-posix)
1909 ("ghc-xml" ,ghc-xml)
1910 ("ghc-libxml" ,ghc-libxml)))
1911 (home-page "https://batterseapower.github.io/test-framework/")
1912 (synopsis "Framework for running and organising tests")
1913 (description
1914 "This package allows tests such as QuickCheck properties and HUnit test
1915 cases to be assembled into test groups, run in parallel (but reported in
1916 deterministic order, to aid diff interpretation) and filtered and controlled
1917 by command line options. All of this comes with colored test output, progress
1918 reporting and test statistics output.")
1919 (license license:bsd-3)))
1920
1921 (define-public ghc-test-framework-hunit
1922 (package
1923 (name "ghc-test-framework-hunit")
1924 (version "0.3.0.1")
1925 (source
1926 (origin
1927 (method url-fetch)
1928 (uri (string-append "https://hackage.haskell.org/package/"
1929 "test-framework-hunit/test-framework-hunit-"
1930 version ".tar.gz"))
1931 (sha256
1932 (base32
1933 "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
1934 (build-system haskell-build-system)
1935 (inputs
1936 `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
1937 ("ghc-hunit" ,ghc-hunit)
1938 ("ghc-test-framework" ,ghc-test-framework)))
1939 (home-page "https://batterseapower.github.io/test-framework/")
1940 (synopsis "HUnit support for test-framework")
1941 (description
1942 "This package provides HUnit support for the test-framework package.")
1943 (license license:bsd-3)))
1944
1945 (define-public ghc-test-framework-quickcheck2
1946 (package
1947 (name "ghc-test-framework-quickcheck2")
1948 (version "0.3.0.3")
1949 (source
1950 (origin
1951 (method url-fetch)
1952 (uri (string-append "https://hackage.haskell.org/package/"
1953 "test-framework-quickcheck2/"
1954 "test-framework-quickcheck2-" version ".tar.gz"))
1955 (sha256
1956 (base32
1957 "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
1958 (modules '((guix build utils)))
1959 (snippet
1960 ;; The Hackage page and the cabal file linked there for this package
1961 ;; both list 2.9 as the upper version limit, but the source tarball
1962 ;; specifies 2.8. Assume the Hackage page is correct.
1963 '(substitute* "test-framework-quickcheck2.cabal"
1964 (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
1965 (build-system haskell-build-system)
1966 (inputs
1967 `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
1968 ("ghc-quickcheck" ,ghc-quickcheck)
1969 ("ghc-random" ,ghc-random)
1970 ("ghc-test-framework" ,ghc-test-framework)))
1971 (home-page "https://batterseapower.github.io/test-framework/")
1972 (synopsis "QuickCheck2 support for test-framework")
1973 (description
1974 "This packages provides QuickCheck2 support for the test-framework
1975 package.")
1976 (license license:bsd-3)))
1977
1978 (define-public ghc-tf-random
1979 (package
1980 (name "ghc-tf-random")
1981 (version "0.5")
1982 (outputs '("out" "doc"))
1983 (source
1984 (origin
1985 (method url-fetch)
1986 (uri (string-append
1987 "https://hackage.haskell.org/package/tf-random/tf-random-"
1988 version
1989 ".tar.gz"))
1990 (sha256
1991 (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
1992 (build-system haskell-build-system)
1993 (inputs
1994 `(("ghc-primitive" ,ghc-primitive)
1995 ("ghc-random" ,ghc-random)))
1996 (home-page "https://hackage.haskell.org/package/tf-random")
1997 (synopsis "High-quality splittable pseudorandom number generator")
1998 (description "This package contains an implementation of a high-quality
1999 splittable pseudorandom number generator. The generator is based on a
2000 cryptographic hash function built on top of the ThreeFish block cipher. See
2001 the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
2002 Hashing\" by Claessen, Pałka for details and the rationale of the design.")
2003 (license license:bsd-3)))
2004
2005 (define-public ghc-transformers-base
2006 (package
2007 (name "ghc-transformers-base")
2008 (version "0.4.4")
2009 (source
2010 (origin
2011 (method url-fetch)
2012 (uri (string-append
2013 "https://hackage.haskell.org/package/transformers-base/transformers-base-"
2014 version
2015 ".tar.gz"))
2016 (sha256
2017 (base32
2018 "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va"))))
2019 (build-system haskell-build-system)
2020 (inputs
2021 `(("ghc-stm" ,ghc-stm)
2022 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2023 (home-page
2024 "https://hackage.haskell.org/package/transformers-compat")
2025 (synopsis
2026 "Backported transformer library")
2027 (description
2028 "Backported versions of types that were added to transformers in
2029 transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3
2030 compatibility to run on old versions of the platform.")
2031 (license license:bsd-3)))
2032
2033 (define-public ghc-transformers-compat
2034 (package
2035 (name "ghc-transformers-compat")
2036 (version "0.4.0.4")
2037 (source
2038 (origin
2039 (method url-fetch)
2040 (uri (string-append
2041 "https://hackage.haskell.org/package/transformers-compat"
2042 "/transformers-compat-" version ".tar.gz"))
2043 (sha256
2044 (base32
2045 "0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym"))))
2046 (build-system haskell-build-system)
2047 (home-page "https://github.com/ekmett/transformers-compat/")
2048 (synopsis "Small compatibility shim between transformers 0.3 and 0.4")
2049 (description "This package includes backported versions of types that were
2050 added to transformers in transformers 0.3 and 0.4 for users who need strict
2051 transformers 0.2 or 0.3 compatibility to run on old versions of the platform,
2052 but also need those types.")
2053 (license license:bsd-3)))
2054
2055 (define-public ghc-unix-time
2056 (package
2057 (name "ghc-unix-time")
2058 (version "0.3.6")
2059 (source
2060 (origin
2061 (method url-fetch)
2062 (uri (string-append
2063 "https://hackage.haskell.org/package/unix-time/unix-time-"
2064 version
2065 ".tar.gz"))
2066 (sha256
2067 (base32
2068 "0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax"))))
2069 (build-system haskell-build-system)
2070 (arguments
2071 `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
2072 ; is weird, that should be provided by GHC 7.10.2.
2073 (inputs
2074 `(("ghc-old-time" ,ghc-old-time)
2075 ("ghc-old-locale" ,ghc-old-locale)))
2076 (home-page "https://hackage.haskell.org/package/unix-time")
2077 (synopsis "Unix time parser/formatter and utilities")
2078 (description "This library provides fast parsing and formatting utilities
2079 for Unix time in Haskell.")
2080 (license license:bsd-3)))
2081
2082 (define-public ghc-unix-compat
2083 (package
2084 (name "ghc-unix-compat")
2085 (version "0.4.1.4")
2086 (source
2087 (origin
2088 (method url-fetch)
2089 (uri (string-append
2090 "https://hackage.haskell.org/package/unix-compat/unix-compat-"
2091 version
2092 ".tar.gz"))
2093 (sha256
2094 (base32
2095 "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps"))))
2096 (build-system haskell-build-system)
2097 (home-page
2098 "https://github.com/jystic/unix-compat")
2099 (synopsis "Portable POSIX-compatibility layer")
2100 (description
2101 "This package provides portable implementations of parts of the unix
2102 package. This package re-exports the unix package when available. When it
2103 isn't available, portable implementations are used.")
2104 (license license:bsd-3)))
2105
2106 (define-public ghc-http-types
2107 (package
2108 (name "ghc-http-types")
2109 (version "0.9")
2110 (source
2111 (origin
2112 (method url-fetch)
2113 (uri (string-append
2114 "https://hackage.haskell.org/package/http-types/http-types-"
2115 version
2116 ".tar.gz"))
2117 (sha256
2118 (base32
2119 "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc"))))
2120 (build-system haskell-build-system)
2121 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find
2122 ; Blaze.Bytestring.Builder, which should be
2123 ; provided by ghc-blaze-builder.
2124 (inputs
2125 `(("ghc-case-insensitive" ,ghc-case-insensitive)
2126 ("ghc-blaze-builder" ,ghc-blaze-builder)
2127 ("ghc-text" ,ghc-text)))
2128 (home-page "https://github.com/aristidb/http-types")
2129 (synopsis "Generic HTTP types for Haskell")
2130 (description "This package provides generic HTTP types for Haskell (for
2131 both client and server code).")
2132 (license license:bsd-3)))
2133
2134 (define-public ghc-indents
2135 (package
2136 (name "ghc-indents")
2137 (version "0.3.3")
2138 (source (origin
2139 (method url-fetch)
2140 (uri (string-append
2141 "https://hackage.haskell.org/package/indents/indents-"
2142 version ".tar.gz"))
2143 (sha256
2144 (base32
2145 "16lz21bp9j14xilnq8yym22p3saxvc9fsgfcf5awn2a6i6n527xn"))))
2146 (build-system haskell-build-system)
2147 (inputs
2148 `(("ghc-parsec" ,ghc-parsec)
2149 ("ghc-concatenative" ,ghc-concatenative)
2150 ("ghc-mtl" ,ghc-mtl)))
2151 (home-page "http://patch-tag.com/r/salazar/indents")
2152 (synopsis "Indentation sensitive parser-combinators for parsec")
2153 (description
2154 "This library provides functions for use in parsing indentation sensitive
2155 contexts. It parses blocks of lines all indented to the same level as well as
2156 lines continued at an indented level below.")
2157 (license license:bsd-3)))
2158
2159 (define-public ghc-iproute
2160 (package
2161 (name "ghc-iproute")
2162 (version "1.7.0")
2163 (source
2164 (origin
2165 (method url-fetch)
2166 (uri (string-append
2167 "https://hackage.haskell.org/package/iproute/iproute-"
2168 version
2169 ".tar.gz"))
2170 (sha256
2171 (base32
2172 "1ply0i110c2sppjbfyysgw48jfjnsbam5zwil8xws0hp20rh1pb5"))))
2173 (build-system haskell-build-system)
2174 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder,
2175 ; exported by ghc-byteorder. Doctest issue.
2176 (inputs
2177 `(("ghc-appar" ,ghc-appar)
2178 ("ghc-byteorder" ,ghc-byteorder)
2179 ("ghc-network" ,ghc-network)
2180 ("ghc-safe" ,ghc-safe)))
2181 (home-page "http://www.mew.org/~kazu/proj/iproute/")
2182 (synopsis "IP routing table")
2183 (description "IP Routing Table is a tree of IP ranges to search one of
2184 them on the longest match base. It is a kind of TRIE with one way branching
2185 removed. Both IPv4 and IPv6 are supported.")
2186 (license license:bsd-3)))
2187
2188 (define-public ghc-regex-base
2189 (package
2190 (name "ghc-regex-base")
2191 (version "0.93.2")
2192 (source
2193 (origin
2194 (method url-fetch)
2195 (uri (string-append
2196 "https://hackage.haskell.org/package/regex-base/regex-base-"
2197 version
2198 ".tar.gz"))
2199 (sha256
2200 (base32
2201 "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
2202 (build-system haskell-build-system)
2203 (inputs
2204 `(("ghc-mtl" ,ghc-mtl)))
2205 (home-page
2206 "https://sourceforge.net/projects/lazy-regex")
2207 (synopsis "Replaces/Enhances Text.Regex")
2208 (description "@code{Text.Regex.Base} provides the interface API for
2209 regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
2210 (license license:bsd-3)))
2211
2212 (define-public ghc-regex-posix
2213 (package
2214 (name "ghc-regex-posix")
2215 (version "0.95.2")
2216 (source
2217 (origin
2218 (method url-fetch)
2219 (uri (string-append
2220 "https://hackage.haskell.org/package/regex-posix/regex-posix-"
2221 version
2222 ".tar.gz"))
2223 (sha256
2224 (base32
2225 "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
2226 (build-system haskell-build-system)
2227 (inputs
2228 `(("ghc-regex-base" ,ghc-regex-base)))
2229 (home-page "https://sourceforge.net/projects/lazy-regex")
2230 (synopsis "POSIX regular expressions for Haskell")
2231 (description "This library provides the POSIX regex backend used by the
2232 Haskell library @code{regex-base}.")
2233 (license license:bsd-3)))
2234
2235 (define-public ghc-regex-compat
2236 (package
2237 (name "ghc-regex-compat")
2238 (version "0.95.1")
2239 (source
2240 (origin
2241 (method url-fetch)
2242 (uri (string-append
2243 "https://hackage.haskell.org/package/regex-compat/regex-compat-"
2244 version
2245 ".tar.gz"))
2246 (sha256
2247 (base32
2248 "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
2249 (build-system haskell-build-system)
2250 (inputs
2251 `(("ghc-regex-base" ,ghc-regex-base)
2252 ("ghc-regex-posix" ,ghc-regex-posix)))
2253 (home-page "https://sourceforge.net/projects/lazy-regex")
2254 (synopsis "Replaces/Enhances Text.Regex")
2255 (description "This library provides one module layer over
2256 @code{regex-posix} to replace @code{Text.Regex}.")
2257 (license license:bsd-3)))
2258
2259 (define-public ghc-regex-tdfa-rc
2260 (package
2261 (name "ghc-regex-tdfa-rc")
2262 (version "1.1.8.3")
2263 (source
2264 (origin
2265 (method url-fetch)
2266 (uri (string-append
2267 "https://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-"
2268 version
2269 ".tar.gz"))
2270 (sha256
2271 (base32
2272 "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3"))))
2273 (build-system haskell-build-system)
2274 (inputs
2275 `(("ghc-regex-base" ,ghc-regex-base)
2276 ("ghc-parsec" ,ghc-parsec)
2277 ("ghc-mtl" ,ghc-mtl)))
2278 (home-page
2279 "https://hackage.haskell.org/package/regex-tdfa")
2280 (synopsis "Tagged DFA regex engine for Haskell")
2281 (description "A new all-Haskell \"tagged\" DFA regex engine, inspired by
2282 @code{libtre} (fork by Roman Cheplyaka).")
2283 (license license:bsd-3)))
2284
2285 (define-public ghc-parsers
2286 (package
2287 (name "ghc-parsers")
2288 (version "0.12.3")
2289 (source
2290 (origin
2291 (method url-fetch)
2292 (uri (string-append
2293 "https://hackage.haskell.org/package/parsers/parsers-"
2294 version
2295 ".tar.gz"))
2296 (sha256
2297 (base32
2298 "18wzmp8y3py4qa8hdsxqm0jfzmwy744dw7xa48r5s8ynhpimi462"))))
2299 (build-system haskell-build-system)
2300 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2301 ; -package attoparsec-0.13.0.1"
2302 (inputs
2303 `(("ghc-base-orphans" ,ghc-base-orphans)
2304 ("ghc-attoparsec" ,ghc-attoparsec)
2305 ("ghc-parsec" ,ghc-parsec)
2306 ("ghc-scientific" ,ghc-scientific)
2307 ("ghc-charset" ,ghc-charset)
2308 ("ghc-text" ,ghc-text)
2309 ("ghc-unordered-containers" ,ghc-unordered-containers)))
2310 (home-page "https://github.com/ekmett/parsers/")
2311 (synopsis "Parsing combinators")
2312 (description "This library provides convenient combinators for working
2313 with and building parsing combinator libraries. Given a few simple instances,
2314 you get access to a large number of canned definitions. Instances exist for
2315 the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s
2316 @code{Text.Read}.")
2317 (license license:bsd-3)))
2318
2319 (define-public ghc-trifecta
2320 (package
2321 (name "ghc-trifecta")
2322 (version "1.6")
2323 (source (origin
2324 (method url-fetch)
2325 (uri (string-append
2326 "https://hackage.haskell.org/package/trifecta/"
2327 "trifecta-" version ".tar.gz"))
2328 (sha256
2329 (base32
2330 "0rbhv9m17k7l1zr70i0yw5da0qjgxmfh1da8brj0zdzwjn9ac0mk"))))
2331 (build-system haskell-build-system)
2332 (inputs
2333 `(("ghc-reducers" ,ghc-reducers)
2334 ("ghc-semigroups" ,ghc-semigroups)
2335 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
2336 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
2337 ("ghc-blaze-builder" ,ghc-blaze-builder)
2338 ("ghc-blaze-html" ,ghc-blaze-html)
2339 ("ghc-blaze-markup" ,ghc-blaze-markup)
2340 ("ghc-charset" ,ghc-charset)
2341 ("ghc-comonad" ,ghc-comonad)
2342 ("ghc-doctest" ,ghc-doctest)
2343 ("ghc-fingertree" ,ghc-fingertree)
2344 ("ghc-hashable" ,ghc-hashable)
2345 ("ghc-lens" ,ghc-lens)
2346 ("ghc-mtl" ,ghc-mtl)
2347 ("ghc-parsers" ,ghc-parsers)
2348 ("ghc-profunctors" ,ghc-profunctors)
2349 ("ghc-quickcheck" ,ghc-quickcheck)
2350 ("ghc-unordered-containers" ,ghc-unordered-containers)
2351 ("ghc-utf8-string" ,ghc-utf8-string)))
2352 (home-page "https://github.com/ekmett/trifecta/")
2353 (synopsis "Parser combinator library with convenient diagnostics")
2354 (description "Trifecta is a modern parser combinator library for Haskell,
2355 with slicing and Clang-style colored diagnostics.")
2356 (license license:bsd-3)))
2357
2358 (define-public ghc-attoparsec
2359 (package
2360 (name "ghc-attoparsec")
2361 (version "0.13.0.1")
2362 (source
2363 (origin
2364 (method url-fetch)
2365 (uri (string-append
2366 "https://hackage.haskell.org/package/attoparsec/attoparsec-"
2367 version
2368 ".tar.gz"))
2369 (sha256
2370 (base32
2371 "0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f"))))
2372 (build-system haskell-build-system)
2373 (inputs
2374 `(("ghc-scientific" ,ghc-scientific)
2375 ("ghc-text" ,ghc-text)))
2376 (native-inputs
2377 `(("ghc-quickcheck" ,ghc-quickcheck)
2378 ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
2379 ("ghc-test-framework" ,ghc-test-framework)
2380 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
2381 ("ghc-vector" ,ghc-vector)))
2382 (home-page "https://github.com/bos/attoparsec")
2383 (synopsis "Fast combinator parsing for bytestrings and text")
2384 (description "This library provides a fast parser combinator library,
2385 aimed particularly at dealing efficiently with network protocols and
2386 complicated text/binary file formats.")
2387 (license license:bsd-3)))
2388
2389 (define-public ghc-css-text
2390 (package
2391 (name "ghc-css-text")
2392 (version "0.1.2.1")
2393 (source
2394 (origin
2395 (method url-fetch)
2396 (uri (string-append
2397 "https://hackage.haskell.org/package/css-text/css-text-"
2398 version
2399 ".tar.gz"))
2400 (sha256
2401 (base32
2402 "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw"))))
2403 (build-system haskell-build-system)
2404 (inputs
2405 `(("ghc-text" ,ghc-text)
2406 ("ghc-attoparsec" ,ghc-attoparsec)
2407 ("ghc-hspec" ,ghc-hspec)
2408 ("ghc-quickcheck" ,ghc-quickcheck)))
2409 (home-page "http://www.yesodweb.com/")
2410 (synopsis "CSS parser and renderer")
2411 (description "This package provides a CSS parser and renderer for
2412 Haskell.")
2413 (license license:bsd-3)))
2414
2415 (define-public ghc-zip-archive
2416 (package
2417 (name "ghc-zip-archive")
2418 (version "0.2.3.7")
2419 (source
2420 (origin
2421 (method url-fetch)
2422 (uri (string-append
2423 "https://hackage.haskell.org/package/zip-archive/zip-archive-"
2424 version
2425 ".tar.gz"))
2426 (sha256
2427 (base32
2428 "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1"))))
2429 (build-system haskell-build-system)
2430 (inputs
2431 `(("ghc-old-time" ,ghc-old-time)
2432 ("ghc-digest" ,ghc-digest)
2433 ("zip" ,zip)
2434 ("ghc-mtl" ,ghc-mtl)
2435 ("ghc-text" ,ghc-text)
2436 ("ghc-zlib" ,ghc-zlib)))
2437 (native-inputs
2438 `(("ghc-hunit" ,ghc-hunit)))
2439 (home-page "https://hackage.haskell.org/package/zip-archive")
2440 (synopsis "Zip archive library for Haskell")
2441 (description "The zip-archive library provides functions for creating,
2442 modifying, and extracting files from zip archives in Haskell.")
2443 (license license:bsd-3)))
2444
2445 (define-public ghc-distributive
2446 (package
2447 (name "ghc-distributive")
2448 (version "0.4.4")
2449 (source
2450 (origin
2451 (method url-fetch)
2452 (uri (string-append
2453 "https://hackage.haskell.org/package/distributive/distributive-"
2454 version
2455 ".tar.gz"))
2456 (sha256
2457 (base32
2458 "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2"))))
2459 (build-system haskell-build-system)
2460 (arguments `(#:tests? #f)) ; FIXME: fails with "cannot satisfy -package
2461 ; tagged-0.8.1". Suspected Cabal issue.
2462 (inputs
2463 `(("ghc-tagged" ,ghc-tagged)
2464 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2465 (home-page "https://github.com/ekmett/distributive/")
2466 (synopsis "Distributive functors for Haskell")
2467 (description "This package provides distributive functors for Haskell.
2468 Dual to @code{Traversable}.")
2469 (license license:bsd-3)))
2470
2471 (define-public ghc-cereal
2472 (package
2473 (name "ghc-cereal")
2474 (version "0.4.1.1")
2475 (source
2476 (origin
2477 (method url-fetch)
2478 (uri (string-append
2479 "https://hackage.haskell.org/package/cereal/cereal-"
2480 version
2481 ".tar.gz"))
2482 (sha256
2483 (base32
2484 "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z"))))
2485 (build-system haskell-build-system)
2486 (home-page "https://hackage.haskell.org/package/cereal")
2487 (synopsis "Binary serialization library")
2488 (description "This package provides a binary serialization library,
2489 similar to @code{binary}, that introduces an @code{isolate} primitive for
2490 parser isolation, and labeled blocks for better error messages.")
2491 (license license:bsd-3)))
2492
2493 (define-public ghc-comonad
2494 (package
2495 (name "ghc-comonad")
2496 (version "4.2.7.2")
2497 (source
2498 (origin
2499 (method url-fetch)
2500 (uri (string-append
2501 "https://hackage.haskell.org/package/comonad/comonad-"
2502 version
2503 ".tar.gz"))
2504 (sha256
2505 (base32
2506 "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp"))))
2507 (build-system haskell-build-system)
2508 (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy
2509 ; -package contravariant-1.3.3"
2510 (inputs
2511 `(("ghc-distributive" ,ghc-distributive)
2512 ("ghc-transformers-compat" ,ghc-transformers-compat)
2513 ("ghc-contravariant" ,ghc-contravariant)
2514 ("ghc-semigroups" ,ghc-semigroups)
2515 ("ghc-tagged" ,ghc-tagged)
2516 ("ghc-contravariant" ,ghc-contravariant)))
2517 (home-page "https://github.com/ekmett/comonad/")
2518 (synopsis "Comonads for Haskell")
2519 (description "This library provides @code{Comonad}s for Haskell.")
2520 (license license:bsd-3)))
2521
2522 (define-public hscolour
2523 (package
2524 (name "hscolour")
2525 (version "1.23")
2526 (source
2527 (origin
2528 (method url-fetch)
2529 (uri (string-append
2530 "https://hackage.haskell.org/package/hscolour/hscolour-"
2531 version
2532 ".tar.gz"))
2533 (sha256
2534 (base32
2535 "1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp"))))
2536 (build-system haskell-build-system)
2537 (home-page "https://hackage.haskell.org/package/hscolour")
2538 (synopsis "Script to colourise Haskell code")
2539 (description "HSColour is a small Haskell script to colourise Haskell
2540 code. It currently has six output formats: ANSI terminal codes (optionally
2541 XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01
2542 with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX,
2543 and mIRC chat codes.")
2544 (license license:bsd-3)))
2545
2546 (define-public ghc-polyparse
2547 (package
2548 (name "ghc-polyparse")
2549 (version "1.11")
2550 (source
2551 (origin
2552 (method url-fetch)
2553 (uri (string-append
2554 "https://hackage.haskell.org/package/polyparse/polyparse-"
2555 version
2556 ".tar.gz"))
2557 (sha256
2558 (base32
2559 "1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh"))))
2560 (build-system haskell-build-system)
2561 (inputs
2562 `(("ghc-text" ,ghc-text)))
2563 (home-page
2564 "http://code.haskell.org/~malcolm/polyparse/")
2565 (synopsis
2566 "Alternative parser combinator libraries")
2567 (description
2568 "This package provides a variety of alternative parser combinator
2569 libraries, including the original HuttonMeijer set. The Poly sets have
2570 features like good error reporting, arbitrary token type, running state, lazy
2571 parsing, and so on. Finally, Text.Parse is a proposed replacement for the
2572 standard Read class, for better deserialisation of Haskell values from
2573 Strings.")
2574 (license license:lgpl2.1)))
2575
2576 (define-public ghc-extra
2577 (package
2578 (name "ghc-extra")
2579 (version "1.4.2")
2580 (source
2581 (origin
2582 (method url-fetch)
2583 (uri (string-append
2584 "https://hackage.haskell.org/package/extra/extra-"
2585 version
2586 ".tar.gz"))
2587 (sha256
2588 (base32
2589 "1h9hxkrqrqscx420yz1lmivbrhi6jc3a5ap61vkxd2mhdgark9hf"))))
2590 (build-system haskell-build-system)
2591 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
2592 (home-page "https://github.com/ndmitchell/extra")
2593 (synopsis "Extra Haskell functions")
2594 (description "This library provides extra functions for the standard
2595 Haskell libraries. Most functions are simple additions, filling out missing
2596 functionality. A few functions are available in later versions of GHC, but
2597 this package makes them available back to GHC 7.2.")
2598 (license license:bsd-3)))
2599
2600 (define-public ghc-profunctors
2601 (package
2602 (name "ghc-profunctors")
2603 (version "5.1.1")
2604 (source
2605 (origin
2606 (method url-fetch)
2607 (uri (string-append
2608 "https://hackage.haskell.org/package/profunctors/profunctors-"
2609 version
2610 ".tar.gz"))
2611 (sha256
2612 (base32
2613 "0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7"))))
2614 (build-system haskell-build-system)
2615 (inputs
2616 `(("ghc-distributive" ,ghc-distributive)
2617 ("ghc-comonad" ,ghc-comonad)
2618 ("ghc-tagged" ,ghc-tagged)))
2619 (home-page "https://github.com/ekmett/profunctors/")
2620 (synopsis "Profunctors for Haskell")
2621 (description "This library provides profunctors for Haskell.")
2622 (license license:bsd-3)))
2623
2624 (define-public ghc-reducers
2625 (package
2626 (name "ghc-reducers")
2627 (version "3.12.1")
2628 (source
2629 (origin
2630 (method url-fetch)
2631 (uri (string-append
2632 "https://hackage.haskell.org/package/reducers/reducers-"
2633 version
2634 ".tar.gz"))
2635 (sha256
2636 (base32
2637 "0pkddg0s3cn759miq0nfrq7lnp3imk5sx784ihsilsbjh9kvffz4"))))
2638 (build-system haskell-build-system)
2639 (inputs
2640 `(("ghc-fingertree" ,ghc-fingertree)
2641 ("ghc-hashable" ,ghc-hashable)
2642 ("ghc-text" ,ghc-text)
2643 ("ghc-unordered-containers" ,ghc-unordered-containers)
2644 ("ghc-semigroupoids" ,ghc-semigroupoids)
2645 ("ghc-semigroups" ,ghc-semigroups)))
2646 (home-page "https://github.com/ekmett/reducers/")
2647 (synopsis "Semigroups, specialized containers and a general map/reduce framework")
2648 (description "This library provides various semigroups, specialized
2649 containers and a general map/reduce framework for Haskell.")
2650 (license license:bsd-3)))
2651
2652 (define-public ghc-appar
2653 (package
2654 (name "ghc-appar")
2655 (version "0.1.4")
2656 (source
2657 (origin
2658 (method url-fetch)
2659 (uri (string-append
2660 "https://hackage.haskell.org/package/appar/appar-"
2661 version
2662 ".tar.gz"))
2663 (sha256
2664 (base32
2665 "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq"))))
2666 (build-system haskell-build-system)
2667 (home-page
2668 "https://hackage.haskell.org/package/appar")
2669 (synopsis "Simple applicative parser")
2670 (description "This package provides a simple applicative parser in Parsec
2671 style.")
2672 (license license:bsd-3)))
2673
2674 (define-public ghc-safe
2675 (package
2676 (name "ghc-safe")
2677 (version "0.3.9")
2678 (source
2679 (origin
2680 (method url-fetch)
2681 (uri (string-append
2682 "https://hackage.haskell.org/package/safe/safe-"
2683 version
2684 ".tar.gz"))
2685 (sha256
2686 (base32
2687 "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh"))))
2688 (build-system haskell-build-system)
2689 (home-page "https://github.com/ndmitchell/safe#readme")
2690 (synopsis "Library of safe (exception free) functions")
2691 (description "This library provides wrappers around @code{Prelude} and
2692 @code{Data.List} functions, such as @code{head} and @code{!!}, that can throw
2693 exceptions.")
2694 (license license:bsd-3)))
2695
2696 (define-public ghc-generic-deriving
2697 (package
2698 (name "ghc-generic-deriving")
2699 (version "1.8.0")
2700 (source
2701 (origin
2702 (method url-fetch)
2703 (uri (string-append
2704 "https://hackage.haskell.org/package/generic-deriving/generic-deriving-"
2705 version
2706 ".tar.gz"))
2707 (sha256
2708 (base32
2709 "1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6"))))
2710 (build-system haskell-build-system)
2711 (home-page "https://hackage.haskell.org/package/generic-deriving")
2712 (synopsis "Generalise the deriving mechanism to arbitrary classes")
2713 (description "This package provides functionality for generalising the
2714 deriving mechanism in Haskell to arbitrary classes.")
2715 (license license:bsd-3)))
2716
2717 (define-public ghc-pcre-light
2718 (package
2719 (name "ghc-pcre-light")
2720 (version "0.4.0.3")
2721 (source
2722 (origin
2723 (method url-fetch)
2724 (uri (string-append
2725 "https://hackage.haskell.org/package/pcre-light/pcre-light-"
2726 version
2727 ".tar.gz"))
2728 (sha256
2729 (base32
2730 "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf"))))
2731 (build-system haskell-build-system)
2732 (inputs
2733 `(("pcre" ,pcre)))
2734 (home-page "https://github.com/Daniel-Diaz/pcre-light")
2735 (synopsis "Haskell library for Perl 5 compatible regular expressions")
2736 (description "This package provides a small, efficient, and portable regex
2737 library for Perl 5 compatible regular expressions. The PCRE library is a set
2738 of functions that implement regular expression pattern matching using the same
2739 syntax and semantics as Perl 5.")
2740 (license license:bsd-3)))
2741
2742 (define-public ghc-logict
2743 (package
2744 (name "ghc-logict")
2745 (version "0.6.0.2")
2746 (source
2747 (origin
2748 (method url-fetch)
2749 (uri (string-append
2750 "https://hackage.haskell.org/package/logict/logict-"
2751 version
2752 ".tar.gz"))
2753 (sha256
2754 (base32
2755 "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
2756 (build-system haskell-build-system)
2757 (inputs `(("ghc-mtl" ,ghc-mtl)))
2758 (home-page "http://code.haskell.org/~dolio/")
2759 (synopsis "Backtracking logic-programming monad")
2760 (description "This library provides a continuation-based, backtracking,
2761 logic programming monad. An adaptation of the two-continuation implementation
2762 found in the paper \"Backtracking, Interleaving, and Terminating Monad
2763 Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf,
2764 online}.")
2765 (license license:bsd-3)))
2766
2767 (define-public ghc-xml
2768 (package
2769 (name "ghc-xml")
2770 (version "1.3.14")
2771 (source
2772 (origin
2773 (method url-fetch)
2774 (uri (string-append
2775 "https://hackage.haskell.org/package/xml/xml-"
2776 version
2777 ".tar.gz"))
2778 (sha256
2779 (base32
2780 "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
2781 (build-system haskell-build-system)
2782 (inputs
2783 `(("ghc-text" ,ghc-text)))
2784 (home-page "http://code.galois.com")
2785 (synopsis "Simple XML library for Haskell")
2786 (description "This package provides a simple XML library for Haskell.")
2787 (license license:bsd-3)))
2788
2789 (define-public ghc-exceptions
2790 (package
2791 (name "ghc-exceptions")
2792 (version "0.8.0.2")
2793 (source
2794 (origin
2795 (method url-fetch)
2796 (uri (string-append
2797 "https://hackage.haskell.org/package/exceptions/exceptions-"
2798 version
2799 ".tar.gz"))
2800 (sha256
2801 (base32
2802 "1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7"))))
2803 (build-system haskell-build-system)
2804 (arguments `(#:tests? #f)) ; FIXME: Missing test-framework package.
2805 (inputs
2806 `(("ghc-stm" ,ghc-stm)
2807 ("ghc-mtl" ,ghc-mtl)
2808 ("ghc-transformers-compat" ,ghc-transformers-compat)))
2809 (home-page "https://github.com/ekmett/exceptions/")
2810 (synopsis "Extensible optionally-pure exceptions")
2811 (description "This library provides extensible optionally-pure exceptions
2812 for Haskell.")
2813 (license license:bsd-3)))
2814
2815 (define-public ghc-temporary
2816 (package
2817 (name "ghc-temporary")
2818 (version "1.2.0.3")
2819 (source
2820 (origin
2821 (method url-fetch)
2822 (uri (string-append
2823 "https://hackage.haskell.org/package/temporary/temporary-"
2824 version
2825 ".tar.gz"))
2826 (sha256
2827 (base32
2828 "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a"))))
2829 (build-system haskell-build-system)
2830 (inputs `(("ghc-exceptions" ,ghc-exceptions)))
2831 (home-page "http://www.github.com/batterseapower/temporary")
2832 (synopsis "Temporary file and directory support")
2833 (description "The functions for creating temporary files and directories
2834 in the Haskelll base library are quite limited. This library just repackages
2835 the Cabal implementations of its own temporary file and folder functions so
2836 that you can use them without linking against Cabal or depending on it being
2837 installed.")
2838 (license license:bsd-3)))
2839
2840 (define-public ghc-temporary-rc
2841 (package
2842 (name "ghc-temporary-rc")
2843 (version "1.2.0.3")
2844 (source
2845 (origin
2846 (method url-fetch)
2847 (uri (string-append
2848 "https://hackage.haskell.org/package/temporary-rc/temporary-rc-"
2849 version
2850 ".tar.gz"))
2851 (sha256
2852 (base32
2853 "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs"))))
2854 (build-system haskell-build-system)
2855 (inputs `(("ghc-exceptions" ,ghc-exceptions)))
2856 (home-page
2857 "http://www.github.com/feuerbach/temporary")
2858 (synopsis
2859 "Portable temporary file and directory support")
2860 (description
2861 "The functions for creating temporary files and directories in the base
2862 library are quite limited. The unixutils package contains some good ones, but
2863 they aren't portable to Windows. This library just repackages the Cabal
2864 implementations of its own temporary file and folder functions so that you can
2865 use them without linking against Cabal or depending on it being installed.
2866 This is a better maintained fork of the \"temporary\" package.")
2867 (license license:bsd-3)))
2868
2869 (define-public ghc-smallcheck
2870 (package
2871 (name "ghc-smallcheck")
2872 (version "1.1.1")
2873 (source
2874 (origin
2875 (method url-fetch)
2876 (uri (string-append
2877 "https://hackage.haskell.org/package/smallcheck/smallcheck-"
2878 version
2879 ".tar.gz"))
2880 (sha256
2881 (base32
2882 "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
2883 (build-system haskell-build-system)
2884 (inputs
2885 `(("ghc-logict" ,ghc-logict)
2886 ("ghc-mtl" ,ghc-mtl)))
2887 (home-page
2888 "https://github.com/feuerbach/smallcheck")
2889 (synopsis "Property-based testing library")
2890 (description "SmallCheck is a testing library that allows to verify
2891 properties for all test cases up to some depth. The test cases are generated
2892 automatically by SmallCheck.")
2893 (license license:bsd-3)))
2894
2895 (define-public ghc-tasty-ant-xml
2896 (package
2897 (name "ghc-tasty-ant-xml")
2898 (version "1.0.2")
2899 (source
2900 (origin
2901 (method url-fetch)
2902 (uri (string-append
2903 "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
2904 version
2905 ".tar.gz"))
2906 (sha256
2907 (base32
2908 "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
2909 (build-system haskell-build-system)
2910 (inputs
2911 `(("ghc-generic-deriving" ,ghc-generic-deriving)
2912 ("ghc-xml" ,ghc-xml)
2913 ("ghc-mtl" ,ghc-mtl)
2914 ("ghc-stm" ,ghc-stm)
2915 ("ghc-tagged" ,ghc-tagged)
2916 ("ghc-tasty" ,ghc-tasty)))
2917 (home-page
2918 "https://github.com/ocharles/tasty-ant-xml")
2919 (synopsis
2920 "Render tasty output to XML for Jenkins")
2921 (description
2922 "A tasty ingredient to output test results in XML, using the Ant
2923 schema. This XML can be consumed by the Jenkins continuous integration
2924 framework.")
2925 (license license:bsd-3)))
2926
2927 (define-public ghc-tasty-smallcheck
2928 (package
2929 (name "ghc-tasty-smallcheck")
2930 (version "0.8.0.1")
2931 (source
2932 (origin
2933 (method url-fetch)
2934 (uri (string-append
2935 "https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
2936 version
2937 ".tar.gz"))
2938 (sha256
2939 (base32
2940 "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
2941 (build-system haskell-build-system)
2942 (inputs
2943 `(("ghc-tasty" ,ghc-tasty)
2944 ("ghc-smallcheck" ,ghc-smallcheck)
2945 ("ghc-async" ,ghc-async)
2946 ("ghc-tagged" ,ghc-tagged)))
2947 (home-page "http://documentup.com/feuerbach/tasty")
2948 (synopsis "SmallCheck support for the Tasty test framework")
2949 (description "This package provides SmallCheck support for the Tasty
2950 Haskell test framework.")
2951 (license license:bsd-3)))
2952
2953 (define-public ghc-silently
2954 (package
2955 (name "ghc-silently")
2956 (version "1.2.5")
2957 (source
2958 (origin
2959 (method url-fetch)
2960 (uri (string-append
2961 "https://hackage.haskell.org/package/silently/silently-"
2962 version
2963 ".tar.gz"))
2964 (sha256
2965 (base32
2966 "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf"))))
2967 (build-system haskell-build-system)
2968 (arguments `(#:tests? #f)) ;; circular dependency with nanospec
2969 ;; (inputs
2970 ;; `(("ghc-temporary" ,ghc-temporary)))
2971 (home-page "https://github.com/hspec/silently")
2972 (synopsis "Prevent writing to stdout")
2973 (description "This package provides functions to prevent or capture
2974 writing to stdout and other handles.")
2975 (license license:bsd-3)))
2976
2977 (define-public ghc-quickcheck-instances
2978 (package
2979 (name "ghc-quickcheck-instances")
2980 (version "0.3.12")
2981 (source
2982 (origin
2983 (method url-fetch)
2984 (uri (string-append
2985 "https://hackage.haskell.org/package/"
2986 "quickcheck-instances/quickcheck-instances-"
2987 version ".tar.gz"))
2988 (sha256
2989 (base32
2990 "1wwvkzpams7i0j7nk5qj8vvhj8x5zcbgbgrpczszgvshva4bkmfx"))))
2991 (build-system haskell-build-system)
2992 (inputs
2993 `(("ghc-old-time" ,ghc-old-time)
2994 ("ghc-unordered-containers" ,ghc-unordered-containers)
2995 ("ghc-hashable" ,ghc-hashable)
2996 ("ghc-quickcheck" ,ghc-quickcheck)
2997 ("ghc-scientific" ,ghc-scientific)
2998 ("ghc-vector" ,ghc-vector)
2999 ("ghc-text" ,ghc-text)))
3000 (home-page
3001 "https://github.com/aslatter/qc-instances")
3002 (synopsis "Common quickcheck instances")
3003 (description "This package provides QuickCheck instances for types
3004 provided by the Haskell Platform.")
3005 (license license:bsd-3)))
3006
3007 (define-public ghc-quickcheck-unicode
3008 (package
3009 (name "ghc-quickcheck-unicode")
3010 (version "1.0.0.1")
3011 (source
3012 (origin
3013 (method url-fetch)
3014 (uri (string-append
3015 "https://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
3016 version
3017 ".tar.gz"))
3018 (sha256
3019 (base32
3020 "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
3021 (build-system haskell-build-system)
3022 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
3023 (home-page
3024 "https://github.com/bos/quickcheck-unicode")
3025 (synopsis "Generator functions Unicode-related tests")
3026 (description "This package provides generator and shrink functions for
3027 testing Unicode-related software.")
3028 (license license:bsd-3)))
3029
3030 (define-public ghc-quickcheck-io
3031 (package
3032 (name "ghc-quickcheck-io")
3033 (version "0.1.2")
3034 (source
3035 (origin
3036 (method url-fetch)
3037 (uri (string-append
3038 "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
3039 version
3040 ".tar.gz"))
3041 (sha256
3042 (base32
3043 "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
3044 (build-system haskell-build-system)
3045 (inputs
3046 `(("ghc-quickcheck" ,ghc-quickcheck)
3047 ("ghc-hunit" ,ghc-hunit)))
3048 (home-page
3049 "https://github.com/hspec/quickcheck-io#readme")
3050 (synopsis "Use HUnit assertions as QuickCheck properties")
3051 (description "This package provides an orphan instance that allows you to
3052 use HUnit assertions as QuickCheck properties.")
3053 (license license:expat)))
3054
3055 (define-public ghc-quickcheck
3056 (package
3057 (name "ghc-quickcheck")
3058 (version "2.8.2")
3059 (outputs '("out" "doc"))
3060 (source
3061 (origin
3062 (method url-fetch)
3063 (uri (string-append
3064 "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
3065 version
3066 ".tar.gz"))
3067 (sha256
3068 (base32
3069 "1ai6k5v0bibaxq8xffcblc6rwmmk6gf8vjyd9p2h3y6vwbhlvilq"))))
3070 (build-system haskell-build-system)
3071 (arguments
3072 `(#:tests? #f ; FIXME: currently missing libraries used for tests.
3073 #:configure-flags '("-f base4")))
3074 (inputs
3075 `(("ghc-tf-random" ,ghc-tf-random)))
3076 (home-page
3077 "https://github.com/nick8325/quickcheck")
3078 (synopsis
3079 "Automatic testing of Haskell programs")
3080 (description
3081 "QuickCheck is a library for random testing of program properties.")
3082 (license license:bsd-3)))
3083
3084 (define-public ghc-case-insensitive
3085 (package
3086 (name "ghc-case-insensitive")
3087 (version "1.2.0.4")
3088 (outputs '("out" "doc"))
3089 (source
3090 (origin
3091 (method url-fetch)
3092 (uri (string-append
3093 "https://hackage.haskell.org/package/case-insensitive/case-insensitive-"
3094 version
3095 ".tar.gz"))
3096 (sha256
3097 (base32
3098 "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
3099 (build-system haskell-build-system)
3100 (inputs
3101 `(("ghc-hunit" ,ghc-hunit)))
3102 ;; these inputs are necessary to use this library
3103 (inputs
3104 `(("ghc-text" ,ghc-text)
3105 ("ghc-hashable" ,ghc-hashable)))
3106 (arguments
3107 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3108 (home-page
3109 "https://github.com/basvandijk/case-insensitive")
3110 (synopsis "Case insensitive string comparison")
3111 (description
3112 "The module 'Data.CaseInsensitive' provides the 'CI' type constructor
3113 which can be parameterised by a string-like type like: 'String', 'ByteString',
3114 'Text', etc.. Comparisons of values of the resulting type will be insensitive
3115 to cases.")
3116 (license license:bsd-3)))
3117
3118 (define-public ghc-syb
3119 (package
3120 (name "ghc-syb")
3121 (version "0.6")
3122 (outputs '("out" "doc"))
3123 (source
3124 (origin
3125 (method url-fetch)
3126 (uri (string-append
3127 "https://hackage.haskell.org/package/syb/syb-"
3128 version
3129 ".tar.gz"))
3130 (sha256
3131 (base32
3132 "1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3"))))
3133 (build-system haskell-build-system)
3134 (inputs
3135 `(("ghc-hunit" ,ghc-hunit)
3136 ("ghc-mtl" ,ghc-mtl)))
3137 (home-page
3138 "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
3139 (synopsis "Scrap Your Boilerplate")
3140 (description "This package contains the generics system described in the
3141 /Scrap Your Boilerplate/ papers (see
3142 @uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It
3143 defines the 'Data' class of types permitting folding and unfolding of
3144 constructor applications, instances of this class for primitive types, and a
3145 variety of traversals.")
3146 (license license:bsd-3)))
3147
3148 (define-public ghc-fgl
3149 (package
3150 (name "ghc-fgl")
3151 (version "5.5.3.0")
3152 (outputs '("out" "doc"))
3153 (source
3154 (origin
3155 (method url-fetch)
3156 (uri (string-append
3157 "https://hackage.haskell.org/package/fgl/fgl-"
3158 version
3159 ".tar.gz"))
3160 (sha256
3161 (base32
3162 "0fbyb6jxy9whgrv6dgnkzz70cmy98arx3q2gnkhgl4a3d7idh36p"))))
3163 (build-system haskell-build-system)
3164 (inputs
3165 `(("ghc-mtl" ,ghc-mtl)
3166 ("ghc-hspec" ,ghc-hspec)
3167 ("ghc-quickcheck" ,ghc-quickcheck)))
3168 (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
3169 (synopsis
3170 "Martin Erwig's Functional Graph Library")
3171 (description "The functional graph library, FGL, is a collection of type
3172 and function definitions to address graph problems. The basis of the library
3173 is an inductive definition of graphs in the style of algebraic data types that
3174 encourages inductive, recursive definitions of graph algorithms.")
3175 (license license:bsd-3)))
3176
3177 (define-public ghc-chasingbottoms
3178 (package
3179 (name "ghc-chasingbottoms")
3180 (version "1.3.0.13")
3181 (source
3182 (origin
3183 (method url-fetch)
3184 (uri (string-append "https://hackage.haskell.org/package/ChasingBottoms/"
3185 "ChasingBottoms-" version ".tar.gz"))
3186 (sha256
3187 (base32
3188 "1fb86jd6cdz4rx3fj3r9n8d60kx824ywwy7dw4qnrdran46ja3pl"))
3189 (modules '((guix build utils)))
3190 (snippet
3191 ;; The Hackage page and the cabal file linked there for this package
3192 ;; both list 0.7 as the upper version limit, but the source tarball
3193 ;; specifies 0.6. Assume the Hackage page is correct.
3194 '(substitute* "ChasingBottoms.cabal"
3195 (("syb >= 0.1.0.2 && < 0.6") "syb >= 0.1.0.2 && < 0.7")))))
3196 (build-system haskell-build-system)
3197 (inputs
3198 `(("ghc-mtl" ,ghc-mtl)
3199 ("ghc-quickcheck" ,ghc-quickcheck)
3200 ("ghc-random" ,ghc-random)
3201 ("ghc-syb" ,ghc-syb)))
3202 (home-page "https://hackage.haskell.org/package/ChasingBottoms")
3203 (synopsis "Testing of partial and infinite values in Haskell")
3204 (description
3205 ;; FIXME: There should be a @comma{} in the uref text, but it is not
3206 ;; rendered properly.
3207 "This is a library for testing code involving bottoms or infinite values.
3208 For the underlying theory and a larger example involving use of QuickCheck,
3209 see the article
3210 @uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
3211 \"Chasing Bottoms A Case Study in Program Verification in the Presence of
3212 Partial and Infinite Values\"}.")
3213 (license license:expat)))
3214
3215 (define-public ghc-unordered-containers
3216 (package
3217 (name "ghc-unordered-containers")
3218 (version "0.2.5.1")
3219 (outputs '("out" "doc"))
3220 (source
3221 (origin
3222 (method url-fetch)
3223 (uri (string-append
3224 "https://hackage.haskell.org/package/unordered-containers"
3225 "/unordered-containers-" version ".tar.gz"))
3226 (sha256
3227 (base32
3228 "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
3229 (build-system haskell-build-system)
3230 (inputs
3231 `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
3232 ("ghc-hunit" ,ghc-hunit)
3233 ("ghc-quickcheck" ,ghc-quickcheck)
3234 ("ghc-test-framework" ,ghc-test-framework)
3235 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
3236 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
3237 ("ghc-hashable" ,ghc-hashable)))
3238 (home-page
3239 "https://github.com/tibbe/unordered-containers")
3240 (synopsis
3241 "Efficient hashing-based container types")
3242 (description
3243 "Efficient hashing-based container types. The containers have been
3244 optimized for performance critical use, both in terms of large data quantities
3245 and high speed.")
3246 (license license:bsd-3)))
3247
3248 (define-public ghc-uniplate
3249 (package
3250 (name "ghc-uniplate")
3251 (version "1.6.12")
3252 (source
3253 (origin
3254 (method url-fetch)
3255 (uri (string-append
3256 "https://hackage.haskell.org/package/uniplate/uniplate-"
3257 version
3258 ".tar.gz"))
3259 (sha256
3260 (base32
3261 "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw"))))
3262 (build-system haskell-build-system)
3263 (inputs
3264 `(("ghc-syb" ,ghc-syb)
3265 ("ghc-hashable" ,ghc-hashable)
3266 ("ghc-unordered-containers" ,ghc-unordered-containers)))
3267 (home-page "http://community.haskell.org/~ndm/uniplate/")
3268 (synopsis "Simple, concise and fast generic operations")
3269 (description "Uniplate is a library for writing simple and concise generic
3270 operations. Uniplate has similar goals to the original Scrap Your Boilerplate
3271 work, but is substantially simpler and faster.")
3272 (license license:bsd-3)))
3273
3274 (define-public ghc-base64-bytestring
3275 (package
3276 (name "ghc-base64-bytestring")
3277 (version "1.0.0.1")
3278 (source
3279 (origin
3280 (method url-fetch)
3281 (uri (string-append
3282 "https://hackage.haskell.org/package/base64-bytestring/base64-bytestring-"
3283 version
3284 ".tar.gz"))
3285 (sha256
3286 (base32
3287 "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db"))))
3288 (build-system haskell-build-system)
3289 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3290 (home-page "https://github.com/bos/base64-bytestring")
3291 (synopsis "Base64 encoding and decoding for ByteStrings")
3292 (description "This library provides fast base64 encoding and decoding for
3293 Haskell @code{ByteString}s.")
3294 (license license:bsd-3)))
3295
3296 (define-public ghc-annotated-wl-pprint
3297 (package
3298 (name "ghc-annotated-wl-pprint")
3299 (version "0.7.0")
3300 (source
3301 (origin
3302 (method url-fetch)
3303 (uri (string-append
3304 "https://hackage.haskell.org/package/annotated-wl-pprint"
3305 "/annotated-wl-pprint-" version
3306 ".tar.gz"))
3307 (sha256
3308 (base32
3309 "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc"))))
3310 (build-system haskell-build-system)
3311 (home-page
3312 "https://github.com/david-christiansen/annotated-wl-pprint")
3313 (synopsis
3314 "The Wadler/Leijen Pretty Printer, with annotation support")
3315 (description "This is a modified version of wl-pprint, which was based on
3316 Wadler's paper \"A Prettier Printer\". This version allows the library user
3317 to annotate the text with semantic information, which can later be rendered in
3318 a variety of ways.")
3319 (license license:bsd-3)))
3320
3321 (define-public ghc-wl-pprint
3322 (package
3323 (name "ghc-wl-pprint")
3324 (version "1.2")
3325 (source (origin
3326 (method url-fetch)
3327 (uri (string-append
3328 "https://hackage.haskell.org/package/wl-pprint/wl-pprint-"
3329 version ".tar.gz"))
3330 (sha256
3331 (base32
3332 "166zvk4zwn2zaa9kx66m1av38m34qp6h4i65bri2sfnxgvx0700r"))))
3333 (build-system haskell-build-system)
3334 (home-page "https://hackage.haskell.org/package/wl-pprint")
3335 (synopsis "Wadler/Leijen pretty printer")
3336 (description
3337 "This is a pretty printing library based on Wadler's paper @i{A Prettier
3338 Printer}. This version allows the library user to declare overlapping
3339 instances of the @code{Pretty} class.")
3340 (license license:bsd-3)))
3341
3342 (define-public ghc-ansi-wl-pprint
3343 (package
3344 (name "ghc-ansi-wl-pprint")
3345 (version "0.6.7.3")
3346 (source
3347 (origin
3348 (method url-fetch)
3349 (uri (string-append
3350 "https://hackage.haskell.org/package/ansi-wl-pprint/ansi-wl-pprint-"
3351 version
3352 ".tar.gz"))
3353 (sha256
3354 (base32
3355 "025pyphsjf0dnbrmj5nscbi6gzyigwgp3ifxb3psn7kji6mfr29p"))))
3356 (build-system haskell-build-system)
3357 (inputs
3358 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)))
3359 (home-page "https://github.com/ekmett/ansi-wl-pprint")
3360 (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output")
3361 (description "This is a pretty printing library based on Wadler's paper
3362 \"A Prettier Printer\". It has been enhanced with support for ANSI terminal
3363 colored output using the ansi-terminal package.")
3364 (license license:bsd-3)))
3365
3366 (define-public ghc-split
3367 (package
3368 (name "ghc-split")
3369 (version "0.2.2")
3370 (outputs '("out" "doc"))
3371 (source
3372 (origin
3373 (method url-fetch)
3374 (uri (string-append
3375 "https://hackage.haskell.org/package/split/split-"
3376 version
3377 ".tar.gz"))
3378 (sha256
3379 (base32
3380 "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))
3381 (modules '((guix build utils)))
3382 (snippet
3383 ;; The Cabal file on Hackage is updated, but the tar.gz does not
3384 ;; include it. See
3385 ;; <https://hackage.haskell.org/package/split-0.2.2/revisions/>.
3386 '(substitute* "split.cabal"
3387 (("base <4.8") "base <4.9")))))
3388 (build-system haskell-build-system)
3389 (inputs
3390 `(("ghc-quickcheck" ,ghc-quickcheck)))
3391 (home-page "https://hackage.haskell.org/package/split")
3392 (synopsis "Combinator library for splitting lists")
3393 (description "This package provides a collection of Haskell functions for
3394 splitting lists into parts, akin to the @code{split} function found in several
3395 mainstream languages.")
3396 (license license:bsd-3)))
3397
3398 (define-public ghc-parsec
3399 (package
3400 (name "ghc-parsec")
3401 (version "3.1.9")
3402 (outputs '("out" "doc"))
3403 (source
3404 (origin
3405 (method url-fetch)
3406 (uri (string-append
3407 "https://hackage.haskell.org/package/parsec/parsec-"
3408 version
3409 ".tar.gz"))
3410 (sha256
3411 (base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
3412 (build-system haskell-build-system)
3413 (native-inputs
3414 `(("ghc-hunit" ,ghc-hunit)))
3415 (inputs
3416 `(("ghc-text" ,ghc-text)
3417 ("ghc-mtl" ,ghc-mtl)))
3418 (arguments
3419 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3420 (home-page
3421 "https://github.com/aslatter/parsec")
3422 (synopsis "Monadic parser combinators")
3423 (description "Parsec is a parser library. It is simple, safe, well
3424 documented, has extensive libraries, good error messages, and is fast. It is
3425 defined as a monad transformer that can be stacked on arbitrary monads, and it
3426 is also parametric in the input stream type.")
3427 (license license:bsd-3)))
3428
3429 (define-public ghc-vector
3430 (package
3431 (name "ghc-vector")
3432 (version "0.11.0.0")
3433 (outputs '("out" "doc"))
3434 (source
3435 (origin
3436 (method url-fetch)
3437 (uri (string-append
3438 "https://hackage.haskell.org/package/vector/vector-"
3439 version
3440 ".tar.gz"))
3441 (sha256
3442 (base32
3443 "1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa"))))
3444 (build-system haskell-build-system)
3445 (inputs
3446 `(("ghc-primitive" ,ghc-primitive)
3447 ("ghc-quickcheck" ,ghc-quickcheck)))
3448 (arguments
3449 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3450 (home-page "https://github.com/haskell/vector")
3451 (synopsis "Efficient Arrays")
3452 (description "This library provides an efficient implementation of
3453 Int-indexed arrays (both mutable and immutable), with a powerful loop
3454 optimisation framework.")
3455 (license license:bsd-3)))
3456
3457 (define-public ghc-vector-binary-instances
3458 (package
3459 (name "ghc-vector-binary-instances")
3460 (version "0.2.1.0")
3461 (source
3462 (origin
3463 (method url-fetch)
3464 (uri (string-append
3465 "https://hackage.haskell.org/package/"
3466 "vector-binary-instances/vector-binary-instances-"
3467 version ".tar.gz"))
3468 (sha256
3469 (base32
3470 "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l"))))
3471 (build-system haskell-build-system)
3472 (inputs
3473 `(("ghc-cereal" ,ghc-cereal)
3474 ("ghc-vector" ,ghc-vector)))
3475 (home-page "https://github.com/bos/vector-binary-instances")
3476 (synopsis "Instances of Data.Binary and Data.Serialize for vector")
3477 (description "This library provides instances of @code{Binary} for the
3478 types defined in the @code{vector} package, making it easy to serialize
3479 vectors to and from disk. We use the generic interface to vectors, so all
3480 vector types are supported. Specific instances are provided for unboxed,
3481 boxed and storable vectors.")
3482 (license license:bsd-3)))
3483
3484 (define-public ghc-network
3485 (package
3486 (name "ghc-network")
3487 (version "2.6.2.1")
3488 (outputs '("out" "doc"))
3489 (source
3490 (origin
3491 (method url-fetch)
3492 (uri (string-append
3493 "https://hackage.haskell.org/package/network/network-"
3494 version
3495 ".tar.gz"))
3496 (sha256
3497 (base32
3498 "1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3"))))
3499 (build-system haskell-build-system)
3500 (inputs
3501 `(("ghc-hunit" ,ghc-hunit)))
3502 (arguments
3503 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3504 (home-page "https://github.com/haskell/network")
3505 (synopsis "Low-level networking interface")
3506 (description
3507 "This package provides a low-level networking interface.")
3508 (license license:bsd-3)))
3509
3510 (define-public ghc-network-uri
3511 (package
3512 (name "ghc-network-uri")
3513 (version "2.6.0.3")
3514 (outputs '("out" "doc"))
3515 (source
3516 (origin
3517 (method url-fetch)
3518 (uri (string-append
3519 "https://hackage.haskell.org/package/network-uri/network-uri-"
3520 version
3521 ".tar.gz"))
3522 (sha256
3523 (base32
3524 "1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg"))))
3525 (build-system haskell-build-system)
3526 (arguments
3527 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3528 (native-inputs
3529 `(("ghc-hunit" ,ghc-hunit)))
3530 (inputs
3531 `(("ghc-parsec" ,ghc-parsec)
3532 ("ghc-network" ,ghc-network)))
3533 (home-page
3534 "https://github.com/haskell/network-uri")
3535 (synopsis "Library for URI manipulation")
3536 (description "This package provides an URI manipulation interface. In
3537 'network-2.6' the 'Network.URI' module was split off from the 'network'
3538 package into this package.")
3539 (license license:bsd-3)))
3540
3541 (define-public ghc-ansi-terminal
3542 (package
3543 (name "ghc-ansi-terminal")
3544 (version "0.6.2.3")
3545 (source
3546 (origin
3547 (method url-fetch)
3548 (uri (string-append
3549 "https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
3550 version
3551 ".tar.gz"))
3552 (sha256
3553 (base32
3554 "0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d"))))
3555 (build-system haskell-build-system)
3556 (home-page "https://github.com/feuerbach/ansi-terminal")
3557 (synopsis "ANSI terminal support for Haskell")
3558 (description "This package provides ANSI terminal support for Haskell. It
3559 allows cursor movement, screen clearing, color output showing or hiding the
3560 cursor, and changing the title.")
3561 (license license:bsd-3)))
3562
3563 (define-public ghc-http
3564 (package
3565 (name "ghc-http")
3566 (version "4000.2.20")
3567 (outputs '("out" "doc"))
3568 (source
3569 (origin
3570 (method url-fetch)
3571 (uri (string-append
3572 "https://hackage.haskell.org/package/HTTP/HTTP-"
3573 version
3574 ".tar.gz"))
3575 (sha256
3576 (base32
3577 "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4"))))
3578 (build-system haskell-build-system)
3579 (native-inputs
3580 `(("ghc-hunit" ,ghc-hunit)))
3581 (inputs
3582 `(("ghc-old-time" ,ghc-old-time)
3583 ("ghc-parsec" ,ghc-parsec)
3584 ("ghc-mtl" ,ghc-mtl)
3585 ("ghc-network" ,ghc-network)
3586 ("ghc-network-uri" ,ghc-network-uri)))
3587 (arguments
3588 `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
3589 (home-page "https://github.com/haskell/HTTP")
3590 (synopsis "Library for client-side HTTP")
3591 (description
3592 "The HTTP package supports client-side web programming in Haskell. It
3593 lets you set up HTTP connections, transmitting requests and processing the
3594 responses coming back.")
3595 (license license:bsd-3)))
3596
3597 (define-public ghc-hspec
3598 (package
3599 (name "ghc-hspec")
3600 (version "2.2.0")
3601 (source
3602 (origin
3603 (method url-fetch)
3604 (uri (string-append
3605 "https://hackage.haskell.org/package/hspec/hspec-"
3606 version
3607 ".tar.gz"))
3608 (sha256
3609 (base32
3610 "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
3611 (build-system haskell-build-system)
3612 (inputs
3613 `(("ghc-hspec-core" ,ghc-hspec-core)
3614 ("hspec-discover" ,hspec-discover)
3615 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3616 ("ghc-quickcheck" ,ghc-quickcheck)
3617 ("ghc-hunit" ,ghc-hunit)
3618 ("ghc-stringbuilder" ,ghc-stringbuilder)
3619 ("ghc-hspec-meta" ,ghc-hspec-meta)))
3620 (home-page "http://hspec.github.io/")
3621 (synopsis "Testing Framework for Haskell")
3622 (description "This library provides the Hspec testing framework for
3623 Haskell, inspired by the Ruby library RSpec.")
3624 (license license:expat)))
3625
3626 (define-public ghc-hspec-contrib
3627 (package
3628 (name "ghc-hspec-contrib")
3629 (version "0.3.0")
3630 (source (origin
3631 (method url-fetch)
3632 (uri (string-append "https://hackage.haskell.org/package/"
3633 "hspec-contrib/hspec-contrib-"
3634 version ".tar.gz"))
3635 (sha256
3636 (base32
3637 "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
3638 (build-system haskell-build-system)
3639 (inputs
3640 `(("ghc-hspec-core" ,ghc-hspec-core)
3641 ("ghc-hunit" ,ghc-hunit)
3642 ("ghc-hspec" ,ghc-hspec)
3643 ("ghc-quickcheck" ,ghc-quickcheck)))
3644 (native-inputs
3645 `(("hspec-discover" ,hspec-discover)))
3646 (home-page "http://hspec.github.io/")
3647 (synopsis "Contributed functionality for Hspec")
3648 (description
3649 "This package provides contributed Hspec extensions.")
3650 (license license:expat)))
3651
3652 (define-public ghc-hspec-expectations
3653 (package
3654 (name "ghc-hspec-expectations")
3655 (version "0.7.2")
3656 (source
3657 (origin
3658 (method url-fetch)
3659 (uri (string-append
3660 "https://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
3661 version
3662 ".tar.gz"))
3663 (sha256
3664 (base32
3665 "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
3666 (build-system haskell-build-system)
3667 (inputs `(("ghc-hunit" ,ghc-hunit)))
3668 (home-page "https://github.com/sol/hspec-expectations")
3669 (synopsis "Catchy combinators for HUnit")
3670 (description "This library provides catchy combinators for HUnit, see
3671 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
3672 (license license:expat)))
3673
3674 (define-public hspec-discover
3675 (package
3676 (name "hspec-discover")
3677 (version "2.2.0")
3678 (source
3679 (origin
3680 (method url-fetch)
3681 (uri (string-append
3682 "https://hackage.haskell.org/package/hspec-discover/hspec-discover-"
3683 version
3684 ".tar.gz"))
3685 (sha256
3686 (base32
3687 "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
3688 (build-system haskell-build-system)
3689 (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
3690 ; documentation files.
3691 (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
3692 (home-page "http://hspec.github.io/")
3693 (synopsis "Automatically discover and run Hspec tests")
3694 (description "hspec-discover is a tool which automatically discovers and
3695 runs Hspec tests.")
3696 (license license:expat)))
3697
3698 (define-public ghc-hspec-core
3699 (package
3700 (name "ghc-hspec-core")
3701 (version "2.2.0")
3702 (source
3703 (origin
3704 (method url-fetch)
3705 (uri (string-append
3706 "https://hackage.haskell.org/package/hspec-core/hspec-core-"
3707 version
3708 ".tar.gz"))
3709 (sha256
3710 (base32
3711 "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
3712 (build-system haskell-build-system)
3713 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3714 (inputs
3715 `(("ghc-setenv" ,ghc-setenv)
3716 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
3717 ("ghc-async" ,ghc-async)
3718 ("ghc-quickcheck-io" ,ghc-quickcheck-io)
3719 ("ghc-hunit" ,ghc-hunit)
3720 ("ghc-quickcheck" ,ghc-quickcheck)
3721 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3722 ("ghc-silently" ,ghc-silently)))
3723 (home-page "http://hspec.github.io/")
3724 (synopsis "Testing framework for Haskell")
3725 (description "This library exposes internal types and functions that can
3726 be used to extend Hspec's functionality.")
3727 (license license:expat)))
3728
3729 (define-public ghc-hspec-meta
3730 (package
3731 (name "ghc-hspec-meta")
3732 (version "2.2.0")
3733 (source
3734 (origin
3735 (method url-fetch)
3736 (uri (string-append
3737 "https://hackage.haskell.org/package/hspec-meta/hspec-meta-"
3738 version
3739 ".tar.gz"))
3740 (sha256
3741 (base32
3742 "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
3743 (build-system haskell-build-system)
3744 (inputs
3745 `(("ghc-quickcheck" ,ghc-quickcheck)
3746 ("ghc-hunit" ,ghc-hunit)
3747 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
3748 ("ghc-async" ,ghc-async)
3749 ("ghc-hspec-expectations" ,ghc-hspec-expectations)
3750 ("ghc-setenv" ,ghc-setenv)
3751 ("ghc-random" ,ghc-random)
3752 ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
3753 (home-page "http://hspec.github.io/")
3754 (synopsis "Version of Hspec to test Hspec itself")
3755 (description "This library provides a stable version of Hspec which is
3756 used to test the in-development version of Hspec.")
3757 (license license:expat)))
3758
3759 (define-public ghc-vault
3760 (package
3761 (name "ghc-vault")
3762 (version "0.3.0.4")
3763 (source
3764 (origin
3765 (method url-fetch)
3766 (uri (string-append
3767 "https://hackage.haskell.org/package/vault/vault-"
3768 version
3769 ".tar.gz"))
3770 (sha256
3771 (base32
3772 "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn"))))
3773 (build-system haskell-build-system)
3774 (inputs
3775 `(("ghc-unordered-containers" ,ghc-unordered-containers)
3776 ("ghc-hashable" ,ghc-hashable)))
3777 (home-page
3778 "https://github.com/HeinrichApfelmus/vault")
3779 (synopsis "Persistent store for arbitrary values")
3780 (description "This package provides vaults for Haskell. A vault is a
3781 persistent store for values of arbitrary types. It's like having first-class
3782 access to the storage space behind @code{IORefs}. The data structure is
3783 analogous to a bank vault, where you can access different bank boxes with
3784 different keys; hence the name. Also provided is a @code{locker} type,
3785 representing a store for a single element.")
3786 (license license:bsd-3)))
3787
3788 (define-public ghc-mmorph
3789 (package
3790 (name "ghc-mmorph")
3791 (version "1.0.4")
3792 (source
3793 (origin
3794 (method url-fetch)
3795 (uri (string-append
3796 "https://hackage.haskell.org/package/mmorph/mmorph-"
3797 version
3798 ".tar.gz"))
3799 (sha256
3800 (base32
3801 "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2"))))
3802 (build-system haskell-build-system)
3803 (home-page
3804 "https://hackage.haskell.org/package/mmorph")
3805 (synopsis "Monad morphisms")
3806 (description
3807 "This library provides monad morphism utilities, most commonly used for
3808 manipulating monad transformer stacks.")
3809 (license license:bsd-3)))
3810
3811 (define-public ghc-monad-control
3812 (package
3813 (name "ghc-monad-control")
3814 (version "1.0.0.4")
3815 (source
3816 (origin
3817 (method url-fetch)
3818 (uri (string-append
3819 "https://hackage.haskell.org/package/monad-control"
3820 "/monad-control-" version ".tar.gz"))
3821 (sha256
3822 (base32
3823 "07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179"))))
3824 (build-system haskell-build-system)
3825 (inputs
3826 `(("ghc-stm" ,ghc-stm)
3827 ("ghc-transformers-base" ,ghc-transformers-base)
3828 ("ghc-transformers-compat" ,ghc-transformers-compat)))
3829 (home-page "https://github.com/basvandijk/monad-control")
3830 (synopsis "Monad transformers to lift control operations like exception
3831 catching")
3832 (description "This package defines the type class @code{MonadBaseControl},
3833 a subset of @code{MonadBase} into which generic control operations such as
3834 @code{catch} can be lifted from @code{IO} or any other base monad.")
3835 (license license:bsd-3)))
3836
3837 (define-public ghc-byteorder
3838 (package
3839 (name "ghc-byteorder")
3840 (version "1.0.4")
3841 (source
3842 (origin
3843 (method url-fetch)
3844 (uri (string-append
3845 "https://hackage.haskell.org/package/byteorder/byteorder-"
3846 version
3847 ".tar.gz"))
3848 (sha256
3849 (base32
3850 "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x"))))
3851 (build-system haskell-build-system)
3852 (home-page
3853 "http://community.haskell.org/~aslatter/code/byteorder")
3854 (synopsis
3855 "Exposes the native endianness of the system")
3856 (description
3857 "This package is for working with the native byte-ordering of the
3858 system.")
3859 (license license:bsd-3)))
3860
3861 (define-public ghc-base-compat
3862 (package
3863 (name "ghc-base-compat")
3864 (version "0.8.2")
3865 (source
3866 (origin
3867 (method url-fetch)
3868 (uri (string-append
3869 "https://hackage.haskell.org/package/base-compat/base-compat-"
3870 version
3871 ".tar.gz"))
3872 (sha256
3873 (base32
3874 "02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q"))))
3875 (build-system haskell-build-system)
3876 (native-inputs
3877 `(("ghc-quickcheck" ,ghc-quickcheck)
3878 ("ghc-hspec" ,ghc-hspec)
3879 ("hspec-discover" ,hspec-discover)))
3880 (home-page "https://hackage.haskell.org/package/base-compat")
3881 (synopsis "Haskell compiler compatibility library")
3882 (description "This library provides functions available in later versions
3883 of base to a wider range of compilers, without requiring the use of CPP
3884 pragmas in your code.")
3885 (license license:bsd-3)))
3886
3887 (define-public ghc-blaze-builder
3888 (package
3889 (name "ghc-blaze-builder")
3890 (version "0.4.0.1")
3891 (source
3892 (origin
3893 (method url-fetch)
3894 (uri (string-append
3895 "https://hackage.haskell.org/package/blaze-builder/blaze-builder-"
3896 version
3897 ".tar.gz"))
3898 (sha256
3899 (base32
3900 "1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1"))))
3901 (build-system haskell-build-system)
3902 (arguments `(#:tests? #f)) ; FIXME: Missing test libraries.
3903 (inputs
3904 `(("ghc-text" ,ghc-text)
3905 ("ghc-utf8-string" ,ghc-utf8-string)))
3906 (home-page "https://github.com/lpsmith/blaze-builder")
3907 (synopsis "Efficient buffered output")
3908 (description "This library provides an implementation of the older
3909 @code{blaze-builder} interface in terms of the new builder that shipped with
3910 @code{bytestring-0.10.4.0}. This implementation is mostly intended as a
3911 bridge to the new builder, so that code that uses the old interface can
3912 interoperate with code that uses the new implementation.")
3913 (license license:bsd-3)))
3914
3915 (define-public ghc-blaze-markup
3916 (package
3917 (name "ghc-blaze-markup")
3918 (version "0.7.0.3")
3919 (source
3920 (origin
3921 (method url-fetch)
3922 (uri (string-append
3923 "https://hackage.haskell.org/package/blaze-markup/blaze-markup-"
3924 version
3925 ".tar.gz"))
3926 (sha256
3927 (base32
3928 "080vlhd8dwjxrma4bb524lh8gxs5lm3xh122icy6lnnyipla0s9y"))))
3929 (build-system haskell-build-system)
3930 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3931 (inputs
3932 `(("ghc-blaze-builder" ,ghc-blaze-builder)
3933 ("ghc-text" ,ghc-text)))
3934 (home-page "http://jaspervdj.be/blaze")
3935 (synopsis "Fast markup combinator library for Haskell")
3936 (description "This library provides core modules of a markup combinator
3937 library for Haskell.")
3938 (license license:bsd-3)))
3939
3940 (define-public ghc-blaze-html
3941 (package
3942 (name "ghc-blaze-html")
3943 (version "0.8.1.1")
3944 (source
3945 (origin
3946 (method url-fetch)
3947 (uri (string-append
3948 "https://hackage.haskell.org/package/blaze-html/blaze-html-"
3949 version
3950 ".tar.gz"))
3951 (sha256
3952 (base32
3953 "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq"))))
3954 (build-system haskell-build-system)
3955 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
3956 (inputs
3957 `(("ghc-blaze-builder" ,ghc-blaze-builder)
3958 ("ghc-text" ,ghc-text)
3959 ("ghc-blaze-markup" ,ghc-blaze-markup)))
3960 (home-page "http://jaspervdj.be/blaze")
3961 (synopsis "Fast HTML combinator library")
3962 (description "This library provides HTML combinators for Haskell.")
3963 (license license:bsd-3)))
3964
3965 (define-public ghc-easy-file
3966 (package
3967 (name "ghc-easy-file")
3968 (version "0.2.1")
3969 (source
3970 (origin
3971 (method url-fetch)
3972 (uri (string-append
3973 "https://hackage.haskell.org/package/easy-file/easy-file-"
3974 version
3975 ".tar.gz"))
3976 (sha256
3977 (base32
3978 "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz"))))
3979 (build-system haskell-build-system)
3980 (home-page
3981 "https://github.com/kazu-yamamoto/easy-file")
3982 (synopsis "File handling library for Haskell")
3983 (description "This library provides file handling utilities for Haskell.")
3984 (license license:bsd-3)))
3985
3986 (define-public ghc-async
3987 (package
3988 (name "ghc-async")
3989 (version "2.0.2")
3990 (source
3991 (origin
3992 (method url-fetch)
3993 (uri (string-append
3994 "https://hackage.haskell.org/package/async/async-"
3995 version
3996 ".tar.gz"))
3997 (sha256
3998 (base32
3999 "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v"))))
4000 (build-system haskell-build-system)
4001 (inputs
4002 `(("ghc-stm" ,ghc-stm)
4003 ("ghc-hunit" ,ghc-hunit)
4004 ("ghc-test-framework" ,ghc-test-framework)
4005 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
4006 (home-page "https://github.com/simonmar/async")
4007 (synopsis "Library to run IO operations asynchronously")
4008 (description "Async provides a library to run IO operations
4009 asynchronously, and wait for their results. It is a higher-level interface
4010 over threads in Haskell, in which @code{Async a} is a concurrent thread that
4011 will eventually deliver a value of type @code{a}.")
4012 (license license:bsd-3)))
4013
4014 (define-public ghc-fingertree
4015 (package
4016 (name "ghc-fingertree")
4017 (version "0.1.1.0")
4018 (source
4019 (origin
4020 (method url-fetch)
4021 (uri (string-append
4022 "https://hackage.haskell.org/package/fingertree/fingertree-"
4023 version
4024 ".tar.gz"))
4025 (sha256
4026 (base32
4027 "1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n"))))
4028 (build-system haskell-build-system)
4029 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
4030 (home-page "https://hackage.haskell.org/package/fingertree")
4031 (synopsis "Generic finger-tree structure")
4032 (description "This library provides finger trees, a general sequence
4033 representation with arbitrary annotations, for use as a base for
4034 implementations of various collection types. It includes examples, as
4035 described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a
4036 simple general-purpose data structure\".")
4037 (license license:bsd-3)))
4038
4039 (define-public ghc-optparse-applicative
4040 (package
4041 (name "ghc-optparse-applicative")
4042 (version "0.11.0.2")
4043 (source
4044 (origin
4045 (method url-fetch)
4046 (uri (string-append
4047 "https://hackage.haskell.org/package/optparse-applicative"
4048 "/optparse-applicative-" version ".tar.gz"))
4049 (sha256
4050 (base32
4051 "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii"))))
4052 (build-system haskell-build-system)
4053 (inputs
4054 `(("ghc-transformers-compat" ,ghc-transformers-compat)
4055 ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
4056 (home-page "https://github.com/pcapriotti/optparse-applicative")
4057 (synopsis "Utilities and combinators for parsing command line options")
4058 (description "This package provides utilities and combinators for parsing
4059 command line options in Haskell.")
4060 (license license:bsd-3)))
4061
4062 (define-public ghc-base-orphans
4063 (package
4064 (name "ghc-base-orphans")
4065 (version "0.4.4")
4066 (source
4067 (origin
4068 (method url-fetch)
4069 (uri (string-append
4070 "https://hackage.haskell.org/package/base-orphans/base-orphans-"
4071 version
4072 ".tar.gz"))
4073 (sha256
4074 (base32
4075 "0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl"))))
4076 (build-system haskell-build-system)
4077 (native-inputs
4078 `(("ghc-quickcheck" ,ghc-quickcheck)
4079 ("ghc-hspec" ,ghc-hspec)
4080 ("hspec-discover" ,hspec-discover)))
4081 (home-page "https://hackage.haskell.org/package/base-orphans")
4082 (synopsis "Orphan instances for backwards compatibility")
4083 (description "This package defines orphan instances that mimic instances
4084 available in later versions of base to a wider (older) range of compilers.")
4085 (license license:bsd-3)))
4086
4087 (define-public ghc-auto-update
4088 (package
4089 (name "ghc-auto-update")
4090 (version "0.1.2.2")
4091 (source
4092 (origin
4093 (method url-fetch)
4094 (uri (string-append
4095 "https://hackage.haskell.org/package/auto-update/auto-update-"
4096 version
4097 ".tar.gz"))
4098 (sha256
4099 (base32
4100 "1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v"))))
4101 (build-system haskell-build-system)
4102 (home-page "https://github.com/yesodweb/wai")
4103 (synopsis "Efficiently run periodic, on-demand actions")
4104 (description "This library provides mechanisms to efficiently run
4105 periodic, on-demand actions in Haskell.")
4106 (license license:expat)))
4107
4108 (define-public ghc-tagged
4109 (package
4110 (name "ghc-tagged")
4111 (version "0.8.1")
4112 (source
4113 (origin
4114 (method url-fetch)
4115 (uri (string-append
4116 "https://hackage.haskell.org/package/tagged/tagged-"
4117 version
4118 ".tar.gz"))
4119 (sha256
4120 (base32
4121 "1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav"))))
4122 (build-system haskell-build-system)
4123 (home-page "https://hackage.haskell.org/package/tagged")
4124 (synopsis "Haskell phantom types to avoid passing dummy arguments")
4125 (description "This library provides phantom types for Haskell 98, to avoid
4126 having to unsafely pass dummy arguments.")
4127 (license license:bsd-3)))
4128
4129 (define-public ghc-unbounded-delays
4130 (package
4131 (name "ghc-unbounded-delays")
4132 (version "0.1.0.9")
4133 (source
4134 (origin
4135 (method url-fetch)
4136 (uri (string-append
4137 "https://hackage.haskell.org/package/unbounded-delays/unbounded-delays-"
4138 version
4139 ".tar.gz"))
4140 (sha256
4141 (base32
4142 "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420"))))
4143 (build-system haskell-build-system)
4144 (home-page "https://github.com/basvandijk/unbounded-delays")
4145 (synopsis "Unbounded thread delays and timeouts")
4146 (description "The @code{threadDelay} and @code{timeout} functions from the
4147 Haskell base library use the bounded @code{Int} type for specifying the delay
4148 or timeout period. This package provides alternative functions which use the
4149 unbounded @code{Integer} type.")
4150 (license license:bsd-3)))
4151
4152 ;; This package builds `clock` without tests, since the tests rely on tasty
4153 ;; and tasty-quickcheck, which in turn require clock to build. When tasty and
4154 ;; tasty-quickcheck are added, we will add ghc-clock with tests enabled.
4155 (define ghc-clock-bootstrap
4156 (package
4157 (name "ghc-clock-bootstrap")
4158 (version "0.5.1")
4159 (source
4160 (origin
4161 (method url-fetch)
4162 (uri (string-append
4163 "https://hackage.haskell.org/package/"
4164 "clock/"
4165 "clock-" version ".tar.gz"))
4166 (sha256
4167 (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
4168 (build-system haskell-build-system)
4169 (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
4170 ;; tasty-quickcheck, which need clock to build.
4171 (home-page "https://hackage.haskell.org/package/clock")
4172 (synopsis "High-resolution clock for Haskell")
4173 (description "A package for convenient access to high-resolution clock and
4174 timer functions of different operating systems via a unified API.")
4175 (license license:bsd-3)))
4176
4177 (define-public ghc-clock
4178 (package
4179 (name "ghc-clock")
4180 (version "0.5.1")
4181 (source
4182 (origin
4183 (method url-fetch)
4184 (uri (string-append
4185 "https://hackage.haskell.org/package/"
4186 "clock/"
4187 "clock-" version ".tar.gz"))
4188 (sha256
4189 (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
4190 (build-system haskell-build-system)
4191 (inputs
4192 `(("ghc-tasty" ,ghc-tasty)
4193 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
4194 (home-page "https://hackage.haskell.org/package/clock")
4195 (synopsis "High-resolution clock for Haskell")
4196 (description "A package for convenient access to high-resolution clock and
4197 timer functions of different operating systems via a unified API.")
4198 (license license:bsd-3)))
4199
4200 (define-public ghc-charset
4201 (package
4202 (name "ghc-charset")
4203 (version "0.3.7.1")
4204 (source
4205 (origin
4206 (method url-fetch)
4207 (uri (string-append
4208 "https://hackage.haskell.org/package/charset/charset-"
4209 version
4210 ".tar.gz"))
4211 (sha256
4212 (base32
4213 "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"))))
4214 (build-system haskell-build-system)
4215 (inputs
4216 `(("ghc-semigroups" ,ghc-semigroups)
4217 ("ghc-unordered-containers" ,ghc-unordered-containers)))
4218 (home-page "https://github.com/ekmett/charset")
4219 (synopsis "Fast unicode character sets for Haskell")
4220 (description "This package provides fast unicode character sets for
4221 Haskell, based on complemented PATRICIA tries.")
4222 (license license:bsd-3)))
4223
4224 (define-public ghc-bytestring-builder
4225 (package
4226 (name "ghc-bytestring-builder")
4227 (version "0.10.6.0.0")
4228 (source
4229 (origin
4230 (method url-fetch)
4231 (uri (string-append
4232 "https://hackage.haskell.org/package/bytestring-builder"
4233 "/bytestring-builder-" version ".tar.gz"))
4234 (sha256
4235 (base32
4236 "1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww"))))
4237 (build-system haskell-build-system)
4238 (arguments `(#:haddock? #f)) ; Package contains no documentation.
4239 (home-page "https://hackage.haskell.org/package/bytestring-builder")
4240 (synopsis "The new bytestring builder, packaged outside of GHC")
4241 (description "This package provides the bytestring builder that is
4242 debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8.
4243 Compatibility package for older packages.")
4244 (license license:bsd-3)))
4245
4246 (define-public ghc-nats
4247 (package
4248 (name "ghc-nats")
4249 (version "1")
4250 (source
4251 (origin
4252 (method url-fetch)
4253 (uri (string-append
4254 "https://hackage.haskell.org/package/nats/nats-"
4255 version
4256 ".tar.gz"))
4257 (sha256
4258 (base32
4259 "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0"))))
4260 (build-system haskell-build-system)
4261 (arguments `(#:haddock? #f))
4262 (inputs
4263 `(("ghc-hashable" ,ghc-hashable)))
4264 (home-page "https://hackage.haskell.org/package/nats")
4265 (synopsis "Natural numbers")
4266 (description "This library provides the natural numbers for Haskell.")
4267 (license license:bsd-3)))
4268
4269 (define-public ghc-void
4270 (package
4271 (name "ghc-void")
4272 (version "0.7.1")
4273 (source
4274 (origin
4275 (method url-fetch)
4276 (uri (string-append
4277 "https://hackage.haskell.org/package/void/void-"
4278 version
4279 ".tar.gz"))
4280 (sha256
4281 (base32
4282 "1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69"))))
4283 (build-system haskell-build-system)
4284 (inputs
4285 `(("ghc-semigroups" ,ghc-semigroups)
4286 ("ghc-hashable" ,ghc-hashable)))
4287 (home-page "https://github.com/ekmett/void")
4288 (synopsis
4289 "Logically uninhabited data type")
4290 (description
4291 "A Haskell 98 logically uninhabited data type, used to indicate that a
4292 given term should not exist.")
4293 (license license:bsd-3)))
4294
4295 (define-public ghc-kan-extensions
4296 (package
4297 (name "ghc-kan-extensions")
4298 (version "4.2.3")
4299 (source
4300 (origin
4301 (method url-fetch)
4302 (uri (string-append
4303 "https://hackage.haskell.org/package/kan-extensions/kan-extensions-"
4304 version
4305 ".tar.gz"))
4306 (sha256
4307 (base32
4308 "0iywbadpy8s3isfzlx9dlz3apaywhqq4gdbxkwygksq8pzdhwkrk"))))
4309 (build-system haskell-build-system)
4310 (inputs
4311 `(("ghc-adjunctions" ,ghc-adjunctions)
4312 ("ghc-comonad" ,ghc-comonad)
4313 ("ghc-contravariant" ,ghc-contravariant)
4314 ("ghc-distributive" ,ghc-distributive)
4315 ("ghc-free" ,ghc-free)
4316 ("ghc-mtl" ,ghc-mtl)
4317 ("ghc-semigroupoids" ,ghc-semigroupoids)
4318 ("ghc-tagged" ,ghc-tagged)))
4319 (home-page "https://github.com/ekmett/kan-extensions/")
4320 (synopsis "Kan extensions library")
4321 (description "This library provides Kan extensions, Kan lifts, various
4322 forms of the Yoneda lemma, and (co)density (co)monads for Haskell.")
4323 (license license:bsd-3)))
4324
4325 (define-public ghc-statevar
4326 (package
4327 (name "ghc-statevar")
4328 (version "1.1.0.1")
4329 (source
4330 (origin
4331 (method url-fetch)
4332 (uri (string-append
4333 "https://hackage.haskell.org/package/StateVar/StateVar-"
4334 version
4335 ".tar.gz"))
4336 (sha256
4337 (base32
4338 "1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf"))))
4339 (build-system haskell-build-system)
4340 (inputs
4341 `(("ghc-stm" ,ghc-stm)))
4342 (home-page "https://hackage.haskell.org/package/StateVar")
4343 (synopsis "State variables for Haskell")
4344 (description "This package provides state variables, which are references
4345 in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.")
4346 (license license:bsd-3)))
4347
4348 (define-public ghc-lens
4349 (package
4350 (name "ghc-lens")
4351 (version "4.13")
4352 (source
4353 (origin
4354 (method url-fetch)
4355 (uri (string-append
4356 "https://hackage.haskell.org/package/lens/lens-"
4357 version
4358 ".tar.gz"))
4359 (sha256
4360 (base32
4361 "0g4g0xksrb2m8wgsmraaq8qnk1sssb42kr65fc7clgyid6zyfmim"))))
4362 (build-system haskell-build-system)
4363 (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
4364 (inputs
4365 `(("ghc-base-orphans" ,ghc-base-orphans)
4366 ("ghc-bifunctors" ,ghc-bifunctors)
4367 ("ghc-distributive" ,ghc-distributive)
4368 ("ghc-exceptions" ,ghc-exceptions)
4369 ("ghc-free" ,ghc-free)
4370 ("ghc-kan-extensions" ,ghc-kan-extensions)
4371 ("ghc-parallel" ,ghc-parallel)
4372 ("ghc-reflection" ,ghc-reflection)
4373 ("ghc-semigroupoids" ,ghc-semigroupoids)
4374 ("ghc-vector" ,ghc-vector)
4375 ("ghc-comonad" ,ghc-comonad)
4376 ("ghc-contravariant" ,ghc-contravariant)
4377 ("ghc-hashable" ,ghc-hashable)
4378 ("ghc-mtl" ,ghc-mtl)
4379 ("ghc-profunctors" ,ghc-profunctors)
4380 ("ghc-semigroups" ,ghc-semigroups)
4381 ("ghc-tagged" ,ghc-tagged)
4382 ("ghc-text" ,ghc-text)
4383 ("ghc-transformers-compat" ,ghc-transformers-compat)
4384 ("ghc-unordered-containers" ,ghc-unordered-containers)
4385 ("ghc-void" ,ghc-void)
4386 ("ghc-generic-deriving" ,ghc-generic-deriving)
4387 ("ghc-nats" ,ghc-nats)
4388 ("ghc-simple-reflect" ,ghc-simple-reflect)
4389 ("hlint" ,hlint)))
4390 (home-page "https://github.com/ekmett/lens/")
4391 (synopsis "Lenses, Folds and Traversals")
4392 (description "This library provides @code{Control.Lens}. The combinators
4393 in @code{Control.Lens} provide a highly generic toolbox for composing families
4394 of getters, folds, isomorphisms, traversals, setters and lenses and their
4395 indexed variants.")
4396 (license license:bsd-3)))
4397
4398 (define-public ghc-tagsoup
4399 (package
4400 (name "ghc-tagsoup")
4401 (version "0.14")
4402 (source
4403 (origin
4404 (method url-fetch)
4405 (uri (string-append
4406 "https://hackage.haskell.org/package/tagsoup/tagsoup-"
4407 version
4408 ".tar.gz"))
4409 (sha256
4410 (base32
4411 "07pax7i0bl79dmqqz58zy09yrgpnyyr2ya0z183hv96kp65jv0lh"))))
4412 (build-system haskell-build-system)
4413 (inputs `(("ghc-text" ,ghc-text)))
4414 (home-page
4415 "http://community.haskell.org/~ndm/tagsoup/")
4416 (synopsis
4417 "Parsing and extracting information from (possibly malformed) HTML/XML
4418 documents")
4419 (description
4420 "TagSoup is a library for parsing HTML/XML. It supports the HTML 5
4421 specification, and can be used to parse either well-formed XML, or
4422 unstructured and malformed HTML from the web. The library also provides
4423 useful functions to extract information from an HTML document, making it ideal
4424 for screen-scraping.")
4425 (license license:bsd-3)))
4426
4427 (define-public ghc-digest
4428 (package
4429 (name "ghc-digest")
4430 (version "0.0.1.2")
4431 (source
4432 (origin
4433 (method url-fetch)
4434 (uri (string-append
4435 "https://hackage.haskell.org/package/digest/digest-"
4436 version
4437 ".tar.gz"))
4438 (sha256
4439 (base32
4440 "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4"))))
4441 (build-system haskell-build-system)
4442 (inputs
4443 `(("zlib" ,zlib)))
4444 (home-page
4445 "https://hackage.haskell.org/package/digest")
4446 (synopsis
4447 "Various cryptographic hashes for bytestrings")
4448 (description
4449 "This package provides efficient cryptographic hash implementations for
4450 strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they
4451 are implemented as FFI bindings to efficient code from zlib.")
4452 (license license:bsd-3)))
4453
4454 (define-public ghc-cheapskate
4455 (package
4456 (name "ghc-cheapskate")
4457 (version "0.1.0.4")
4458 (source
4459 (origin
4460 (method url-fetch)
4461 (uri (string-append
4462 "https://hackage.haskell.org/package/cheapskate/cheapskate-"
4463 version
4464 ".tar.gz"))
4465 (sha256
4466 (base32
4467 "0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2"))))
4468 (build-system haskell-build-system)
4469 (inputs
4470 `(("ghc-xss-sanitize" ,ghc-xss-sanitize)
4471 ("ghc-data-default" ,ghc-data-default)
4472 ("ghc-mtl" ,ghc-mtl)
4473 ("ghc-text" ,ghc-text)
4474 ("ghc-blaze-html" ,ghc-blaze-html)
4475 ("ghc-syb" ,ghc-syb)
4476 ("ghc-uniplate" ,ghc-uniplate)
4477 ("ghc-aeson" ,ghc-aeson)
4478 ("ghc-wai-extra" ,ghc-wai-extra)
4479 ("ghc-wai" ,ghc-wai)
4480 ("ghc-http-types" ,ghc-http-types)))
4481 (home-page "https://github.com/jgm/cheapskate")
4482 (synopsis "Experimental markdown processor")
4483 (description "Cheapskate is an experimental Markdown processor in pure
4484 Haskell. It aims to process Markdown efficiently and in the most forgiving
4485 possible way. It is designed to deal with any input, including garbage, with
4486 linear performance. Output is sanitized by default for protection against XSS
4487 attacks.")
4488 (license license:bsd-3)))
4489
4490 (define-public ghc-bifunctors
4491 (package
4492 (name "ghc-bifunctors")
4493 (version "5")
4494 (source
4495 (origin
4496 (method url-fetch)
4497 (uri (string-append
4498 "https://hackage.haskell.org/package/bifunctors/bifunctors-"
4499 version
4500 ".tar.gz"))
4501 (sha256
4502 (base32
4503 "13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1"))))
4504 (build-system haskell-build-system)
4505 (inputs
4506 `(("ghc-tagged" ,ghc-tagged)
4507 ("ghc-semigroups" ,ghc-semigroups)))
4508 (home-page "https://github.com/ekmett/bifunctors/")
4509 (synopsis "Bifunctors for Haskell")
4510 (description "This package provides bifunctors for Haskell.")
4511 (license license:bsd-3)))
4512
4513 (define-public ghc-semigroupoids
4514 (package
4515 (name "ghc-semigroupoids")
4516 (version "5.0.0.4")
4517 (source
4518 (origin
4519 (method url-fetch)
4520 (uri (string-append
4521 "https://hackage.haskell.org/package/semigroupoids/semigroupoids-"
4522 version
4523 ".tar.gz"))
4524 (sha256
4525 (base32
4526 "1jf7jnfhdvl6p18wdr21yi2fim1xb8alcn6szhrdswj0dkilgq6d"))))
4527 (build-system haskell-build-system)
4528 (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem.
4529 (inputs
4530 `(("ghc-base-orphans" ,ghc-base-orphans)
4531 ("ghc-transformers-compat" ,ghc-transformers-compat)
4532 ("ghc-bifunctors" ,ghc-bifunctors)
4533 ("ghc-comonad" ,ghc-comonad)
4534 ("ghc-contravariant" ,ghc-contravariant)
4535 ("ghc-distributive" ,ghc-distributive)
4536 ("ghc-semigroups" ,ghc-semigroups)
4537 ("ghc-tagged" ,ghc-tagged)))
4538 (home-page "https://github.com/ekmett/semigroupoids")
4539 (synopsis "Semigroupoids operations for Haskell")
4540 (description "This library provides a wide array of (semi)groupoids and
4541 operations for working with them. A @code{Semigroupoid} is a @code{Category}
4542 without the requirement of identity arrows for every object in the category.
4543 A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds.
4544 Finally, to work with these weaker structures it is beneficial to have
4545 containers that can provide stronger guarantees about their contents, so
4546 versions of @code{Traversable} and @code{Foldable} that can be folded with
4547 just a @code{Semigroup} are added.")
4548 (license license:bsd-3)))
4549
4550 (define-public ghc-contravariant
4551 (package
4552 (name "ghc-contravariant")
4553 (version "1.3.3")
4554 (source
4555 (origin
4556 (method url-fetch)
4557 (uri (string-append
4558 "https://hackage.haskell.org/package/contravariant/contravariant-"
4559 version
4560 ".tar.gz"))
4561 (sha256
4562 (base32
4563 "184hcmhsznqrkmqlc1kza9pb5p591anva574ry8wrh81vqmhwfb5"))))
4564 (build-system haskell-build-system)
4565 (inputs
4566 `(("ghc-void" ,ghc-void)
4567 ("ghc-transformers-compat" ,ghc-transformers-compat)
4568 ("ghc-statevar" ,ghc-statevar)
4569 ("ghc-semigroups" ,ghc-semigroups)))
4570 (home-page
4571 "https://github.com/ekmett/contravariant/")
4572 (synopsis "Contravariant functors")
4573 (description "Contravariant functors for Haskell.")
4574 (license license:bsd-3)))
4575
4576 (define-public ghc-semigroups
4577 (package
4578 (name "ghc-semigroups")
4579 (version "0.18.2")
4580 (source
4581 (origin
4582 (method url-fetch)
4583 (uri (string-append
4584 "https://hackage.haskell.org/package/semigroups/semigroups-"
4585 version
4586 ".tar.gz"))
4587 (sha256
4588 (base32
4589 "1r6hsn3am3dpf4rprrj4m04d9318v9iq02bin0pl29dg4a3gzjax"))))
4590 (build-system haskell-build-system)
4591 (inputs
4592 `(("ghc-nats" ,ghc-nats)
4593 ("ghc-tagged" ,ghc-tagged)
4594 ("ghc-unordered-containers" ,ghc-unordered-containers)
4595 ("ghc-text" ,ghc-text)
4596 ("ghc-hashable" ,ghc-hashable)))
4597 (home-page "https://github.com/ekmett/semigroups/")
4598 (synopsis "Semigroup operations for Haskell")
4599 (description "This package provides semigroups for Haskell. In
4600 mathematics, a semigroup is an algebraic structure consisting of a set
4601 together with an associative binary operation. A semigroup generalizes a
4602 monoid in that there might not exist an identity element. It
4603 also (originally) generalized a group (a monoid with all inverses) to a type
4604 where every element did not have to have an inverse, thus the name
4605 semigroup.")
4606 (license license:bsd-3)))
4607
4608 (define-public ghc-free
4609 (package
4610 (name "ghc-free")
4611 (version "4.12.1")
4612 (source
4613 (origin
4614 (method url-fetch)
4615 (uri (string-append
4616 "https://hackage.haskell.org/package/free/free-"
4617 version
4618 ".tar.gz"))
4619 (sha256
4620 (base32
4621 "0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p"))))
4622 (build-system haskell-build-system)
4623 (inputs
4624 `(("ghc-prelude-extras" ,ghc-prelude-extras)
4625 ("ghc-profunctors" ,ghc-profunctors)
4626 ("ghc-exceptions" ,ghc-exceptions)
4627 ("ghc-bifunctors" ,ghc-bifunctors)
4628 ("ghc-comonad" ,ghc-comonad)
4629 ("ghc-distributive" ,ghc-distributive)
4630 ("ghc-mtl" ,ghc-mtl)
4631 ("ghc-semigroupoids" ,ghc-semigroupoids)
4632 ("ghc-semigroups" ,ghc-semigroups)))
4633 (home-page "https://github.com/ekmett/free/")
4634 (synopsis "Unrestricted monads for Haskell")
4635 (description "This library provides free monads, which are useful for many
4636 tree-like structures and domain specific languages. If @code{f} is a
4637 @code{Functor} then the free @code{Monad} on @code{f} is the type of trees
4638 whose nodes are labeled with the constructors of @code{f}. The word \"free\"
4639 is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free
4640 f} makes no constraining assumptions beyond those given by @code{f} and the
4641 definition of @code{Monad}.")
4642 (license license:bsd-3)))
4643
4644 (define-public ghc-adjunctions
4645 (package
4646 (name "ghc-adjunctions")
4647 (version "4.2.2")
4648 (source
4649 (origin
4650 (method url-fetch)
4651 (uri (string-append
4652 "https://hackage.haskell.org/package/adjunctions/adjunctions-"
4653 version
4654 ".tar.gz"))
4655 (sha256
4656 (base32
4657 "00p030iypjzjib8pxz1x6mxfi59wvyrwjj11zv9bh766dgkdbwjq"))))
4658 (build-system haskell-build-system)
4659 (inputs
4660 `(("ghc-profunctors" ,ghc-profunctors)
4661 ("ghc-comonad" ,ghc-comonad)
4662 ("ghc-contravariant" ,ghc-contravariant)
4663 ("ghc-distributive" ,ghc-distributive)
4664 ("ghc-free" ,ghc-free)
4665 ("ghc-mtl" ,ghc-mtl)
4666 ("ghc-tagged" ,ghc-tagged)
4667 ("ghc-semigroupoids" ,ghc-semigroupoids)
4668 ("ghc-semigroups" ,ghc-semigroups)
4669 ("ghc-void" ,ghc-void)))
4670 (home-page "https://github.com/ekmett/adjunctions/")
4671 (synopsis "Adjunctions and representable functors")
4672 (description "This library provides adjunctions and representable functors
4673 for Haskell.")
4674 (license license:bsd-3)))
4675
4676 (define-public ghc-fast-logger
4677 (package
4678 (name "ghc-fast-logger")
4679 (version "2.4.1")
4680 (source
4681 (origin
4682 (method url-fetch)
4683 (uri (string-append
4684 "https://hackage.haskell.org/package/fast-logger/fast-logger-"
4685 version
4686 ".tar.gz"))
4687 (sha256
4688 (base32
4689 "0kjk1861qcls8m8y7i55msfpprws5wk6c5mxzi35g2qbl2sih4p5"))))
4690 (build-system haskell-build-system)
4691 (inputs
4692 `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
4693 ("ghc-auto-update" ,ghc-auto-update)
4694 ("ghc-text" ,ghc-text)))
4695 (native-inputs
4696 `(("hspec-discover" ,hspec-discover)
4697 ("ghc-hspec" ,ghc-hspec)))
4698 (home-page "https://hackage.haskell.org/package/fast-logger")
4699 (synopsis "Fast logging system")
4700 (description "This library provides a fast logging system for Haskell.")
4701 (license license:bsd-3)))
4702
4703 (define-public ghc-doctest
4704 (package
4705 (name "ghc-doctest")
4706 (version "0.10.1")
4707 (source
4708 (origin
4709 (method url-fetch)
4710 (uri (string-append
4711 "https://hackage.haskell.org/package/doctest/doctest-"
4712 version
4713 ".tar.gz"))
4714 (sha256
4715 (base32
4716 "1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm"))))
4717 (build-system haskell-build-system)
4718 (arguments `(#:tests? #f)) ; FIXME: missing test framework
4719 (inputs
4720 `(("ghc-syb" ,ghc-syb)
4721 ("ghc-paths" ,ghc-paths)
4722 ("ghc-base-compat" ,ghc-base-compat)
4723 ("ghc-hunit" ,ghc-hunit)
4724 ("ghc-hspec" ,ghc-hspec)
4725 ("ghc-quickcheck" ,ghc-quickcheck)
4726 ("ghc-stringbuilder" ,ghc-stringbuilder)
4727 ("ghc-silently" ,ghc-silently)
4728 ("ghc-setenv" ,ghc-setenv)))
4729 (home-page
4730 "https://github.com/sol/doctest#readme")
4731 (synopsis "Test interactive Haskell examples")
4732 (description "The doctest program checks examples in source code comments.
4733 It is modeled after doctest for Python, see
4734 @uref{http://docs.python.org/library/doctest.html, the Doctest website}.")
4735 (license license:expat)))
4736
4737 (define-public ghc-lifted-base
4738 (package
4739 (name "ghc-lifted-base")
4740 (version "0.2.3.6")
4741 (source
4742 (origin
4743 (method url-fetch)
4744 (uri (string-append
4745 "https://hackage.haskell.org/package/lifted-base/lifted-base-"
4746 version
4747 ".tar.gz"))
4748 (sha256
4749 (base32
4750 "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap"))))
4751 (build-system haskell-build-system)
4752 (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries.
4753 (inputs
4754 `(("ghc-transformers-base" ,ghc-transformers-base)
4755 ("ghc-monad-control" ,ghc-monad-control)
4756 ("ghc-transformers-compat" ,ghc-transformers-compat)
4757 ("ghc-hunit" ,ghc-hunit)))
4758 (home-page "https://github.com/basvandijk/lifted-base")
4759 (synopsis "Lifted IO operations from the base library")
4760 (description "Lifted-base exports IO operations from the @code{base}
4761 library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}.
4762 Note that not all modules from @code{base} are converted yet. The package
4763 includes a copy of the @code{monad-peel} test suite written by Anders
4764 Kaseorg.")
4765 (license license:bsd-3)))
4766
4767 (define-public ghc-word8
4768 (package
4769 (name "ghc-word8")
4770 (version "0.1.2")
4771 (source
4772 (origin
4773 (method url-fetch)
4774 (uri (string-append
4775 "https://hackage.haskell.org/package/word8/word8-"
4776 version
4777 ".tar.gz"))
4778 (sha256
4779 (base32
4780 "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw"))))
4781 (build-system haskell-build-system)
4782 (native-inputs
4783 `(("ghc-hspec" ,ghc-hspec)
4784 ("hspec-discover" ,hspec-discover)))
4785 (home-page "https://hackage.haskell.org/package/word8")
4786 (synopsis "Word8 library for Haskell")
4787 (description "Word8 library to be used with @code{Data.ByteString}.")
4788 (license license:bsd-3)))
4789
4790 (define-public ghc-stringsearch
4791 (package
4792 (name "ghc-stringsearch")
4793 (version "0.3.6.6")
4794 (source
4795 (origin
4796 (method url-fetch)
4797 (uri (string-append
4798 "https://hackage.haskell.org/package/stringsearch/stringsearch-"
4799 version
4800 ".tar.gz"))
4801 (sha256
4802 (base32
4803 "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9"))))
4804 (build-system haskell-build-system)
4805 (home-page "https://bitbucket.org/dafis/stringsearch")
4806 (synopsis "Fast searching, splitting and replacing of ByteStrings")
4807 (description "This package provides several functions to quickly search
4808 for substrings in strict or lazy @code{ByteStrings}. It also provides
4809 functions for breaking or splitting on substrings and replacing all
4810 occurrences of a substring (the first in case of overlaps) with another.")
4811 (license license:bsd-3)))
4812
4813 (define-public ghc-tasty-quickcheck
4814 (package
4815 (name "ghc-tasty-quickcheck")
4816 (version "0.8.4")
4817 (source
4818 (origin
4819 (method url-fetch)
4820 (uri (string-append
4821 "https://hackage.haskell.org/package/tasty-quickcheck/"
4822 "tasty-quickcheck-" version ".tar.gz"))
4823 (sha256
4824 (base32
4825 "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
4826 (build-system haskell-build-system)
4827 (inputs
4828 `(("ghc-quickcheck" ,ghc-quickcheck)
4829 ("ghc-tagged" ,ghc-tagged)
4830 ("ghc-tasty" ,ghc-tasty)
4831 ("ghc-random" ,ghc-random)
4832 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
4833 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4834 ("ghc-pcre-light" ,ghc-pcre-light)))
4835 (home-page "http://documentup.com/feuerbach/tasty")
4836 (synopsis "QuickCheck support for the Tasty test framework")
4837 (description "This package provides QuickCheck support for the Tasty
4838 Haskell test framework.")
4839 (license license:expat)))
4840
4841 (define-public ghc-tasty-golden
4842 (package
4843 (name "ghc-tasty-golden")
4844 (version "2.3.0.2")
4845 (source
4846 (origin
4847 (method url-fetch)
4848 (uri (string-append
4849 "https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
4850 version
4851 ".tar.gz"))
4852 (sha256
4853 (base32
4854 "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
4855 (build-system haskell-build-system)
4856 (inputs
4857 `(("ghc-temporary" ,ghc-temporary)
4858 ("ghc-tasty" ,ghc-tasty)
4859 ("ghc-mtl" ,ghc-mtl)
4860 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
4861 ("ghc-tagged" ,ghc-tagged)
4862 ("ghc-async" ,ghc-async)
4863 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4864 ("ghc-temporary-rc" ,ghc-temporary-rc)))
4865 (home-page
4866 "https://github.com/feuerbach/tasty-golden")
4867 (synopsis "Golden tests support for tasty")
4868 (description
4869 "This package provides support for 'golden testing'. A golden test is an
4870 IO action that writes its result to a file. To pass the test, this output
4871 file should be identical to the corresponding 'golden' file, which contains
4872 the correct result for the test.")
4873 (license license:expat)))
4874
4875 (define-public ghc-tasty
4876 (package
4877 (name "ghc-tasty")
4878 (version "0.11.0.1")
4879 (source
4880 (origin
4881 (method url-fetch)
4882 (uri (string-append
4883 "https://hackage.haskell.org/package/tasty/tasty-"
4884 version
4885 ".tar.gz"))
4886 (sha256
4887 (base32
4888 "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
4889 (build-system haskell-build-system)
4890 (inputs
4891 `(("ghc-stm" ,ghc-stm)
4892 ("ghc-mtl" ,ghc-mtl)
4893 ("ghc-tagged" ,ghc-tagged)
4894 ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
4895 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
4896 ("ghc-unbounded-delays" ,ghc-unbounded-delays)
4897 ("ghc-async" ,ghc-async)
4898 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
4899 ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
4900 (home-page "http://documentup.com/feuerbach/tasty")
4901 (synopsis "Modern and extensible testing framework")
4902 (description "Tasty is a modern testing framework for Haskell. It lets
4903 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
4904 and any other types of tests into a single test suite.")
4905 (license license:expat)))
4906
4907 (define-public ghc-tasty-hunit
4908 (package
4909 (name "ghc-tasty-hunit")
4910 (version "0.9.2")
4911 (source
4912 (origin
4913 (method url-fetch)
4914 (uri (string-append
4915 "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
4916 version
4917 ".tar.gz"))
4918 (sha256
4919 (base32
4920 "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
4921 (build-system haskell-build-system)
4922 (inputs
4923 `(("ghc-tasty" ,ghc-tasty)))
4924 (home-page "http://documentup.com/feuerbach/tasty")
4925 (synopsis "HUnit support for the Tasty test framework")
4926 (description "This package provides HUnit support for the Tasty Haskell
4927 test framework.")
4928 (license license:expat)))
4929
4930 (define-public ghc-cookie
4931 (package
4932 (name "ghc-cookie")
4933 (version "0.4.1.6")
4934 (source
4935 (origin
4936 (method url-fetch)
4937 (uri (string-append
4938 "https://hackage.haskell.org/package/cookie/cookie-"
4939 version
4940 ".tar.gz"))
4941 (sha256
4942 (base32
4943 "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s"))))
4944 (build-system haskell-build-system)
4945 (inputs
4946 `(("ghc-old-locale" ,ghc-old-locale)
4947 ("ghc-blaze-builder" ,ghc-blaze-builder)
4948 ("ghc-text" ,ghc-text)
4949 ("ghc-data-default-class" ,ghc-data-default-class)
4950 ("ghc-hunit" ,ghc-hunit)
4951 ("ghc-quickcheck" ,ghc-quickcheck)
4952 ("ghc-tasty" ,ghc-tasty)
4953 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4954 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
4955 (home-page "https://github.com/snoyberg/cookie")
4956 (synopsis "HTTP cookie parsing and rendering")
4957 (description "HTTP cookie parsing and rendering library for Haskell.")
4958 (license license:bsd-3)))
4959
4960 (define-public ghc-scientific
4961 (package
4962 (name "ghc-scientific")
4963 (version "0.3.4.2")
4964 (source
4965 (origin
4966 (method url-fetch)
4967 (uri (string-append
4968 "https://hackage.haskell.org/package/scientific/scientific-"
4969 version
4970 ".tar.gz"))
4971 (sha256
4972 (base32
4973 "0mimdkva0cgzaychr6whv9if29z0r5wwhkss9bmd4rz8kq1kgngn"))))
4974 (build-system haskell-build-system)
4975 (inputs
4976 `(("ghc-hashable" ,ghc-hashable)
4977 ("ghc-vector" ,ghc-vector)
4978 ("ghc-text" ,ghc-text)
4979 ("ghc-tasty" ,ghc-tasty)
4980 ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
4981 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
4982 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
4983 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
4984 ("ghc-smallcheck" ,ghc-smallcheck)
4985 ("ghc-quickcheck" ,ghc-quickcheck)))
4986 (home-page "https://github.com/basvandijk/scientific")
4987 (synopsis "Numbers represented using scientific notation")
4988 (description "This package provides @code{Data.Scientific}, which provides
4989 the number type @code{Scientific}. Scientific numbers are arbitrary precision
4990 and space efficient. They are represented using
4991 @uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific
4992 notation}.")
4993 (license license:bsd-3)))
4994
4995 (define-public ghc-aeson
4996 (package
4997 (name "ghc-aeson")
4998 (version "0.10.0.0")
4999 (source
5000 (origin
5001 (method url-fetch)
5002 (uri (string-append
5003 "https://hackage.haskell.org/package/aeson/aeson-"
5004 version
5005 ".tar.gz"))
5006 (sha256
5007 (base32
5008 "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz"))))
5009 (build-system haskell-build-system)
5010 (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
5011 (inputs
5012 `(("ghc-attoparsec" ,ghc-attoparsec)
5013 ("ghc-dlist" ,ghc-dlist)
5014 ("ghc-mtl" ,ghc-mtl)
5015 ("ghc-scientific" ,ghc-scientific)
5016 ("ghc-syb" ,ghc-syb)
5017 ("ghc-unordered-containers" ,ghc-unordered-containers)
5018 ("ghc-vector" ,ghc-vector)
5019 ("ghc-hashable" ,ghc-hashable)
5020 ("ghc-text" ,ghc-text)
5021 ("ghc-hunit" ,ghc-hunit)
5022 ("ghc-quickcheck" ,ghc-quickcheck)))
5023 (home-page "https://github.com/bos/aeson")
5024 (synopsis "Fast JSON parsing and encoding")
5025 (description "This package provides a JSON parsing and encoding library
5026 for Haskell, optimized for ease of use and high performance. (A note on
5027 naming: in Greek mythology, Aeson was the father of Jason.)")
5028 (license license:bsd-3)))
5029
5030 (define-public ghc-aeson-pretty
5031 (package
5032 (name "ghc-aeson-pretty")
5033 (version "0.7.2")
5034 (source (origin
5035 (method url-fetch)
5036 (uri (string-append
5037 "https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
5038 version ".tar.gz"))
5039 (sha256
5040 (base32
5041 "03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234"))))
5042 (build-system haskell-build-system)
5043 (inputs
5044 `(("ghc-aeson" ,ghc-aeson)
5045 ("ghc-vector" ,ghc-vector)
5046 ("ghc-text" ,ghc-text)
5047 ("ghc-unordered-containers"
5048 ,ghc-unordered-containers)
5049 ("ghc-attoparsec" ,ghc-attoparsec)
5050 ("ghc-cmdargs" ,ghc-cmdargs)))
5051 (home-page "https://github.com/informatikr/aeson-pretty")
5052 (synopsis "JSON pretty-printing library and command-line tool")
5053 (description
5054 "This package provides a JSON pretty-printing library compatible with aeson
5055 as well as a command-line tool to improve readabilty of streams of JSON data.
5056 The library provides the function @code{encodePretty}. It is a drop-in
5057 replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
5058 human readers. The command-line tool reads JSON from stdin and writes
5059 prettified JSON to stdout. It also offers a complementary \"compact\"-mode,
5060 essentially the opposite of pretty-printing.")
5061 (license license:bsd-3)))
5062
5063 (define-public ghc-wai
5064 (package
5065 (name "ghc-wai")
5066 (version "3.0.4.0")
5067 (source
5068 (origin
5069 (method url-fetch)
5070 (uri (string-append
5071 "https://hackage.haskell.org/package/wai/wai-"
5072 version
5073 ".tar.gz"))
5074 (sha256
5075 (base32
5076 "1551n0g0n22vml33v0jz5xgjcy6j79algvsdqg11a1z5ljjrjlqf"))))
5077 (build-system haskell-build-system)
5078 (inputs
5079 `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
5080 ("ghc-unix-compat" ,ghc-unix-compat)
5081 ("ghc-vault" ,ghc-vault)
5082 ("ghc-blaze-builder" ,ghc-blaze-builder)
5083 ("ghc-network" ,ghc-network)
5084 ("ghc-text" ,ghc-text)
5085 ("ghc-http-types" ,ghc-http-types)))
5086 (native-inputs
5087 `(("hspec-discover" ,hspec-discover)
5088 ("ghc-quickcheck" ,ghc-quickcheck)
5089 ("ghc-hunit" ,ghc-hunit)
5090 ("ghc-hspec" ,ghc-hspec)))
5091 (home-page "https://hackage.haskell.org/package/wai")
5092 (synopsis "Web application interface for Haskell")
5093 (description "This package provides a Web Application Interface (WAI)
5094 library for the Haskell language. It defines a common protocol for
5095 communication between web applications and web servers.")
5096 (license license:bsd-3)))
5097
5098 (define-public ghc-wai-logger
5099 (package
5100 (name "ghc-wai-logger")
5101 (version "2.2.4.1")
5102 (source
5103 (origin
5104 (method url-fetch)
5105 (uri (string-append
5106 "https://hackage.haskell.org/package/wai-logger/wai-logger-"
5107 version
5108 ".tar.gz"))
5109 (sha256
5110 (base32
5111 "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk"))))
5112 (build-system haskell-build-system)
5113 (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
5114 ; by propagated-inputs.
5115 (inputs
5116 `(("ghc-auto-update" ,ghc-auto-update)
5117 ("ghc-byteorder" ,ghc-byteorder)
5118 ("ghc-easy-file" ,ghc-easy-file)
5119 ("ghc-unix-time" ,ghc-unix-time)
5120 ("ghc-blaze-builder" ,ghc-blaze-builder)
5121 ("ghc-case-insensitive" ,ghc-case-insensitive)
5122 ("ghc-fast-logger" ,ghc-fast-logger)
5123 ("ghc-http-types" ,ghc-http-types)
5124 ("ghc-network" ,ghc-network)
5125 ("ghc-wai" ,ghc-wai)))
5126 (home-page "https://hackage.haskell.org/package/wai-logger")
5127 (synopsis "Logging system for WAI")
5128 (description "This package provides the logging system for WAI.")
5129 (license license:bsd-3)))
5130
5131 (define-public ghc-wai-extra
5132 (package
5133 (name "ghc-wai-extra")
5134 (version "3.0.11.1")
5135 (source
5136 (origin
5137 (method url-fetch)
5138 (uri (string-append
5139 "https://hackage.haskell.org/package/wai-extra/wai-extra-"
5140 version
5141 ".tar.gz"))
5142 (sha256
5143 (base32
5144 "1kr2s5qyx1dvnwr372h7pca4sgxjv0pdx96xkgsfi180h3mb0vq8"))))
5145 (build-system haskell-build-system)
5146 (inputs
5147 `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
5148 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
5149 ("ghc-cookie" ,ghc-cookie)
5150 ("ghc-blaze-builder" ,ghc-blaze-builder)
5151 ("ghc-network" ,ghc-network)
5152 ("ghc-lifted-base" ,ghc-lifted-base)
5153 ("ghc-streaming-commons" ,ghc-streaming-commons)
5154 ("ghc-stringsearch" ,ghc-stringsearch)
5155 ("ghc-resourcet" ,ghc-resourcet)
5156 ("ghc-fast-logger" ,ghc-fast-logger)
5157 ("ghc-wai-logger" ,ghc-wai-logger)
5158 ("ghc-zlib" ,ghc-zlib)
5159 ("ghc-word8" ,ghc-word8)
5160 ("ghc-iproute" ,ghc-iproute)
5161 ("ghc-void" ,ghc-void)
5162 ("ghc-wai" ,ghc-wai)
5163 ("ghc-http-types" ,ghc-http-types)
5164 ("ghc-text" ,ghc-text)
5165 ("ghc-case-insensitive" ,ghc-case-insensitive)
5166 ("ghc-data-default-class" ,ghc-data-default-class)
5167 ("ghc-unix-compat" ,ghc-unix-compat)
5168 ("ghc-vault" ,ghc-vault)
5169 ("ghc-aeson" ,ghc-aeson)))
5170 (native-inputs
5171 `(("hspec-discover" ,hspec-discover)
5172 ("ghc-hspec" ,ghc-hspec)
5173 ("ghc-hunit" ,ghc-hunit)))
5174 (home-page "https://github.com/yesodweb/wai")
5175 (synopsis "Some basic WAI handlers and middleware")
5176 (description "This library provides basic WAI handlers and middleware
5177 functionality.")
5178 (license license:expat)))
5179
5180 (define-public ghc-deepseq-generics
5181 (package
5182 (name "ghc-deepseq-generics")
5183 (version "0.1.1.2")
5184 (source (origin
5185 (method url-fetch)
5186 (uri (string-append "https://hackage.haskell.org/package/"
5187 "deepseq-generics/deepseq-generics-"
5188 version ".tar.gz"))
5189 (sha256
5190 (base32
5191 "01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3"))))
5192 (build-system haskell-build-system)
5193 (arguments
5194 `(#:phases
5195 (modify-phases %standard-phases
5196 (add-after 'unpack 'relax-ghc-prim-dependency
5197 (lambda _
5198 (substitute* "deepseq-generics.cabal"
5199 (("< 0.4") "< 0.5"))
5200 #t)))))
5201 (native-inputs
5202 `(("ghc-hunit" ,ghc-hunit)
5203 ("ghc-test-framework" ,ghc-test-framework)
5204 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
5205 (home-page "https://github.com/hvr/deepseq-generics")
5206 (synopsis "Generic RNF implementation")
5207 (description
5208 "This package provides a @code{GHC.Generics}-based
5209 @code{Control.DeepSeq.Generics.genericRnf} function which can be used for
5210 providing an 'rnf' implementation.")
5211 (license license:bsd-3)))
5212
5213 (define-public ghc-pandoc-types
5214 (package
5215 (name "ghc-pandoc-types")
5216 (version "1.16.1.1")
5217 (source (origin
5218 (method url-fetch)
5219 (uri (string-append "https://hackage.haskell.org/package/"
5220 "pandoc-types/pandoc-types-"
5221 version ".tar.gz"))
5222 (sha256
5223 (base32
5224 "094mzgdxva84kcpjf9m8b5n3chm1wm44bzflh5x6xhddz6pb7zpq"))))
5225 (build-system haskell-build-system)
5226 (inputs
5227 `(("ghc-syb" ,ghc-syb)
5228 ("ghc-aeson" ,ghc-aeson)
5229 ("ghc-deepseq-generics" ,ghc-deepseq-generics)))
5230 (home-page "http://johnmacfarlane.net/pandoc")
5231 (synopsis "Types for representing a structured document")
5232 (description
5233 "This module defines the @code{Pandoc} data structure, which is used by
5234 pandoc to represent structured documents. It also provides functions for
5235 building up, manipulating and serialising @code{Pandoc} structures.")
5236 (license license:bsd-3)))
5237
5238 (define-public ghc-texmath
5239 (package
5240 (name "ghc-texmath")
5241 (version "0.8.6.5")
5242 (source (origin
5243 (method url-fetch)
5244 (uri (string-append "https://hackage.haskell.org/package/"
5245 "texmath/texmath-" version ".tar.gz"))
5246 (sha256
5247 (base32
5248 "143c8k7dyhwa9blpa8svy23ybx7i4xzb9jnfcimj8iigizbw7y1k"))))
5249 (build-system haskell-build-system)
5250 (inputs
5251 `(("ghc-syb" ,ghc-syb)
5252 ("ghc-network-uri" ,ghc-network-uri)
5253 ("ghc-split" ,ghc-split)
5254 ("ghc-temporary" ,ghc-temporary)
5255 ("ghc-utf8-string" ,ghc-utf8-string)
5256 ("ghc-xml" ,ghc-xml)
5257 ("ghc-parsec" ,ghc-parsec)
5258 ("ghc-mtl" ,ghc-mtl)
5259 ("ghc-pandoc-types" ,ghc-pandoc-types)))
5260 (home-page "https://github.com/jgm/texmath")
5261 (synopsis "Conversion between formats used to represent mathematics")
5262 (description
5263 "The texmath library provides functions to read and write TeX math,
5264 presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
5265 Office). Support is also included for converting math formats to pandoc's
5266 native format (allowing conversion, via pandoc, to a variety of different
5267 markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
5268 it can parse and apply LaTeX macros.")
5269 (license license:gpl2+)))
5270
5271 (define-public ghc-regex-pcre-builtin
5272 (package
5273 (name "ghc-regex-pcre-builtin")
5274 (version "0.94.4.8.8.35")
5275 (source (origin
5276 (method url-fetch)
5277 (uri (string-append "https://hackage.haskell.org/package/"
5278 "regex-pcre-builtin/regex-pcre-builtin-"
5279 version ".tar.gz"))
5280 (sha256
5281 (base32
5282 "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
5283 (build-system haskell-build-system)
5284 (inputs
5285 `(("ghc-regex-base" ,ghc-regex-base)))
5286 (home-page "https://hackage.haskell.org/package/regex-pcre")
5287 (synopsis "Enhancement of the builtin Text.Regex library")
5288 (description
5289 "This package is an enhancement of the @code{Text.Regex} library,
5290 providing the PCRE backend to accompany regex-base, with bundled code from
5291 @url{http://www.pcre.org}.")
5292 (license license:bsd-3)))
5293
5294 (define-public ghc-diff
5295 (package
5296 (name "ghc-diff")
5297 (version "0.3.2")
5298 (source (origin
5299 (method url-fetch)
5300 (uri (string-append "https://hackage.haskell.org/package/"
5301 "Diff/Diff-" version ".tar.gz"))
5302 (sha256
5303 (base32
5304 "13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz"))))
5305 (build-system haskell-build-system)
5306 (home-page "http://hub.darcs.net/sterlingclover/Diff")
5307 (synopsis "O(ND) diff algorithm in Haskell")
5308 (description
5309 "This package provides an implementation of the standard diff algorithm,
5310 and utilities for pretty printing.")
5311 (license license:bsd-3)))
5312
5313 (define-public ghc-highlighting-kate
5314 (package
5315 (name "ghc-highlighting-kate")
5316 (version "0.6.3")
5317 (source (origin
5318 (method url-fetch)
5319 (uri (string-append "https://hackage.haskell.org/package/"
5320 "highlighting-kate/highlighting-kate-"
5321 version ".tar.gz"))
5322 (sha256
5323 (base32
5324 "03c4flh4h1jd48bx0qmplax3q8w6wj1dhbh6j0xhaf5h95fbinki"))))
5325 (build-system haskell-build-system)
5326 (inputs
5327 `(("ghc-diff" ,ghc-diff)
5328 ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
5329 (native-inputs
5330 `(("ghc-parsec" ,ghc-parsec)
5331 ("ghc-blaze-html" ,ghc-blaze-html)
5332 ("ghc-utf8-string" ,ghc-utf8-string)
5333 ("ghc-mtl" ,ghc-mtl)))
5334 (home-page "https://github.com/jgm/highlighting-kate")
5335 (synopsis "Syntax highlighting library")
5336 (description
5337 "Highlighting-kate is a syntax highlighting library with support for
5338 nearly one hundred languages. The syntax parsers are automatically generated
5339 from @uref{http://kate-editor.org/, Kate syntax descriptions}, so any syntax
5340 supported by Kate can be added. An (optional) command-line program is
5341 provided, along with a utility for generating new parsers from Kate XML syntax
5342 descriptions.")
5343 (license license:gpl2+)))
5344
5345 (define-public ghc-cmark
5346 (package
5347 (name "ghc-cmark")
5348 (version "0.5.3.1")
5349 (source (origin
5350 (method url-fetch)
5351 (uri (string-append "https://hackage.haskell.org/package/"
5352 "cmark/cmark-" version ".tar.gz"))
5353 (sha256
5354 (base32
5355 "09515h9b26az9c2mbl6l7azimaixa6yff8w359k0ml8jwykjvqaa"))))
5356 (build-system haskell-build-system)
5357 (inputs
5358 `(("ghc-text" ,ghc-text)))
5359 (native-inputs
5360 `(("ghc-hunit" ,ghc-hunit)))
5361 (home-page "https://github.com/jgm/commonmark-hs")
5362 (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
5363 (description
5364 "This package provides Haskell bindings for
5365 @uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
5366 CommonMark, a fully specified variant of Markdown. It includes sources for
5367 libcmark (0.21.0) and does not require prior installation of the C library.")
5368 (license license:bsd-3)))
5369
5370 (define-public ghc-executable-path
5371 (package
5372 (name "ghc-executable-path")
5373 (version "0.0.3")
5374 (source (origin
5375 (method url-fetch)
5376 (uri (string-append "https://hackage.haskell.org/package/"
5377 "executable-path/executable-path-"
5378 version ".tar.gz"))
5379 (sha256
5380 (base32
5381 "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc"))))
5382 (build-system haskell-build-system)
5383 (home-page "https://hackage.haskell.org/package/executable-path")
5384 (synopsis "Find out the full path of the executable")
5385 (description
5386 "The documentation of @code{System.Environment.getProgName} says that
5387 \"However, this is hard-to-impossible to implement on some non-Unix OSes, so
5388 instead, for maximum portability, we just return the leafname of the program
5389 as invoked.\" This library tries to provide the missing path.")
5390 (license license:public-domain)))
5391
5392 (define-public ghc-enclosed-exceptions
5393 (package
5394 (name "ghc-enclosed-exceptions")
5395 (version "1.0.1.1")
5396 (source (origin
5397 (method url-fetch)
5398 (uri (string-append "https://hackage.haskell.org/package/"
5399 "enclosed-exceptions/enclosed-exceptions-"
5400 version ".tar.gz"))
5401 (sha256
5402 (base32
5403 "16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5"))))
5404 (build-system haskell-build-system)
5405 (inputs
5406 `(("ghc-lifted-base" ,ghc-lifted-base)
5407 ("ghc-monad-control" ,ghc-monad-control)
5408 ("ghc-async" ,ghc-async)
5409 ("ghc-transformers-base" ,ghc-transformers-base)))
5410 (native-inputs
5411 `(("ghc-hspec" ,ghc-hspec)
5412 ("ghc-quickcheck" ,ghc-quickcheck)))
5413 (home-page "https://github.com/jcristovao/enclosed-exceptions")
5414 (synopsis "Catch all exceptions from within an enclosed computation")
5415 (description
5416 "This library implements a technique to catch all exceptions raised
5417 within an enclosed computation, while remaining responsive to (external)
5418 asynchronous exceptions.")
5419 (license license:expat)))
5420
5421 (define-public ghc-packedstring
5422 (package
5423 (name "ghc-packedstring")
5424 (version "0.1.0.1")
5425 (source (origin
5426 (method url-fetch)
5427 (uri (string-append "https://hackage.haskell.org/package/"
5428 "packedstring/packedstring-"
5429 version ".tar.gz"))
5430 (sha256
5431 (base32
5432 "1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8"))))
5433 (build-system haskell-build-system)
5434 (arguments
5435 `(#:phases
5436 (modify-phases %standard-phases
5437 (add-after 'unpack 'enable-extension
5438 (lambda _
5439 ;; This package won't compile without the StandaloneDeriving
5440 ;; extension.
5441 (substitute* "packedstring.cabal"
5442 (("CPP") "CPP, StandaloneDeriving"))
5443 #t)))))
5444 (home-page "https://hackage.haskell.org/package/packedstring")
5445 (synopsis "Library for packed strings")
5446 (description
5447 "This deprecated library provides an implementation of packed strings.")
5448 (license license:bsd-3)))
5449
5450 (define-public ghc-th-lift
5451 (package
5452 (name "ghc-th-lift")
5453 (version "0.7.5")
5454 (source (origin
5455 (method url-fetch)
5456 (uri (string-append "https://hackage.haskell.org/package/"
5457 "th-lift/th-lift-" version ".tar.gz"))
5458 (sha256
5459 (base32
5460 "13xdkk1chdghf059sfx8d3d8r0mj1dbzdi5kf2zf0mjmz3qq7m7k"))))
5461 (build-system haskell-build-system)
5462 (inputs
5463 `(("ghc-packedstring" ,ghc-packedstring)))
5464 (home-page "https://github.com/mboes/th-lift")
5465 (synopsis "Derive Template Haskell's Lift class for datatypes")
5466 (description
5467 "This is a Haskell library to derive Template Haskell's Lift class for
5468 datatypes.")
5469 (license license:bsd-3)))
5470
5471 (define-public ghc-th-expand-syns
5472 (package
5473 (name "ghc-th-expand-syns")
5474 (version "0.3.0.6")
5475 (source (origin
5476 (method url-fetch)
5477 (uri (string-append "https://hackage.haskell.org/package/"
5478 "th-expand-syns/th-expand-syns-"
5479 version ".tar.gz"))
5480 (sha256
5481 (base32
5482 "03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j"))))
5483 (build-system haskell-build-system)
5484 (inputs
5485 `(("ghc-syb" ,ghc-syb)))
5486 (home-page "https://hackage.haskell.org/package/th-expand-syns")
5487 (synopsis "Expands type synonyms in Template Haskell ASTs")
5488 (description
5489 "This package enables users to expand type synonyms in Template Haskell
5490 @dfn{abstract syntax trees} (ASTs).")
5491 (license license:bsd-3)))
5492
5493 (define-public ghc-th-reify-many
5494 (package
5495 (name "ghc-th-reify-many")
5496 (version "0.1.3")
5497 (source (origin
5498 (method url-fetch)
5499 (uri (string-append "https://hackage.haskell.org/package/"
5500 "th-reify-many/th-reify-many-"
5501 version ".tar.gz"))
5502 (sha256
5503 (base32
5504 "00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx"))))
5505 (build-system haskell-build-system)
5506 (inputs
5507 `(("ghc-mtl" ,ghc-mtl)
5508 ("ghc-safe" ,ghc-safe)
5509 ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
5510 (home-page "https://github.com/mgsloan/th-reify-many")
5511 (synopsis "Recurseively reify template haskell datatype info")
5512 (description
5513 "th-reify-many provides functions for recursively reifying top level
5514 declarations. The main intended use case is for enumerating the names of
5515 datatypes reachable from an initial datatype, and passing these names to some
5516 function which generates instances.")
5517 (license license:bsd-3)))
5518
5519 (define-public ghc-th-orphans
5520 (package
5521 (name "ghc-th-orphans")
5522 (version "0.13.0")
5523 (source (origin
5524 (method url-fetch)
5525 (uri (string-append "https://hackage.haskell.org/package/"
5526 "th-orphans/th-orphans-" version ".tar.gz"))
5527 (sha256
5528 (base32
5529 "105y03bxh0a2r69l603i7md17gg1vxs1jj1n40pn5q486lmfxbmx"))))
5530 (build-system haskell-build-system)
5531 (inputs
5532 `(("ghc-th-lift" ,ghc-th-lift)
5533 ("ghc-th-reify-many" ,ghc-th-reify-many)
5534 ("ghc-mtl" ,ghc-mtl)
5535 ("ghc-generic-deriving" ,ghc-generic-deriving)))
5536 (native-inputs
5537 `(("ghc-hspec" ,ghc-hspec)))
5538 (home-page "https://hackage.haskell.org/package/th-orphans")
5539 (synopsis "Orphan instances for TH datatypes")
5540 (description
5541 "This package provides orphan instances for Template Haskell datatypes. In particular,
5542 instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
5543 and @code{Eq} instances. These instances used to live in the haskell-src-meta
5544 package, and that's where the version number started.")
5545 (license license:bsd-3)))
5546
5547 (define-public ghc-haskell-src-meta
5548 (package
5549 (name "ghc-haskell-src-meta")
5550 (version "0.6.0.12")
5551 (source (origin
5552 (method url-fetch)
5553 (uri (string-append "https://hackage.haskell.org/package/"
5554 "haskell-src-meta/haskell-src-meta-"
5555 version ".tar.gz"))
5556 (sha256
5557 (base32
5558 "1mzbfrfvl6pj8068w3m6alzry1403ir1gmz3czg66n5z198l4dql"))))
5559 (build-system haskell-build-system)
5560 (inputs
5561 `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
5562 ("ghc-syb" ,ghc-syb)
5563 ("ghc-th-orphans" ,ghc-th-orphans)))
5564 (home-page "https://hackage.haskell.org/package/haskell-src-meta")
5565 (synopsis "Parse source to template-haskell abstract syntax")
5566 (description
5567 "This package provides tools to parse Haskell sources to the
5568 template-haskell abstract syntax.")
5569 (license license:bsd-3)))
5570
5571 (define-public ghc-aeson-qq
5572 (package
5573 (name "ghc-aeson-qq")
5574 (version "0.8.1")
5575 (source (origin
5576 (method url-fetch)
5577 (uri (string-append "https://hackage.haskell.org/package/"
5578 "aeson-qq/aeson-qq-" version ".tar.gz"))
5579 (sha256
5580 (base32
5581 "1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
5582 (build-system haskell-build-system)
5583 (inputs
5584 `(("ghc-base-compat" ,ghc-base-compat)
5585 ("ghc-text" ,ghc-text)
5586 ("ghc-attoparsec" ,ghc-attoparsec)
5587 ("ghc-scientific" ,ghc-scientific)
5588 ("ghc-vector" ,ghc-vector)
5589 ("ghc-aeson" ,ghc-aeson)
5590 ("ghc-parsec" ,ghc-parsec)
5591 ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
5592 (native-inputs
5593 `(("ghc-hspec" ,ghc-hspec)
5594 ("hspec-discover" ,hspec-discover)))
5595 (home-page "https://github.com/zalora/aeson-qq")
5596 (synopsis "JSON quasiquoter for Haskell")
5597 (description
5598 "aeson-qq provides a JSON quasiquoter for Haskell. This package exposes
5599 the function @code{aesonQQ} that compile-time converts a string representation
5600 of a JSON value into a @code{Data.Aeson.Value}.")
5601 (license license:expat)))
5602
5603 (define-public ghc-conduit
5604 (package
5605 (name "ghc-conduit")
5606 (version "1.2.5.1")
5607 (source (origin
5608 (method url-fetch)
5609 (uri (string-append "https://hackage.haskell.org/package/"
5610 "conduit/conduit-" version ".tar.gz"))
5611 (sha256
5612 (base32
5613 "0aq6wswd5dkhdmy7sjhd99mldpq33dqpgbdcwpm94ahvckqxs7v5"))))
5614 (build-system haskell-build-system)
5615 (inputs
5616 `(("ghc-exceptions" ,ghc-exceptions)
5617 ("ghc-lifted-base" ,ghc-lifted-base)
5618 ("ghc-mmorph" ,ghc-mmorph)
5619 ("ghc-mtl" ,ghc-mtl)
5620 ("ghc-resourcet" ,ghc-resourcet)
5621 ("ghc-transformers-base" ,ghc-transformers-base)
5622 ("ghc-void" ,ghc-void)))
5623 (native-inputs
5624 `(("ghc-quickcheck" ,ghc-quickcheck)
5625 ("ghc-hspec" ,ghc-hspec)
5626 ("ghc-safe" ,ghc-safe)))
5627 (home-page "https://github.com/snoyberg/conduit")
5628 (synopsis "Streaming data library ")
5629 (description
5630 "conduit is a solution to the streaming data problem, allowing for
5631 production, transformation, and consumption of streams of data in constant
5632 memory. It is an alternative to lazy I/O which guarantees deterministic
5633 resource handling, and fits in the same general solution space as
5634 enumerator/iteratee and pipes." )
5635 (license license:expat)))
5636
5637 (define-public ghc-logging-facade
5638 (package
5639 (name "ghc-logging-facade")
5640 (version "0.1.0")
5641 (source (origin
5642 (method url-fetch)
5643 (uri (string-append "https://hackage.haskell.org/package/"
5644 "logging-facade/logging-facade-"
5645 version ".tar.gz"))
5646 (sha256
5647 (base32
5648 "0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y"))))
5649 (build-system haskell-build-system)
5650 (native-inputs
5651 `(("ghc-hspec" ,ghc-hspec)
5652 ("hspec-discover" ,hspec-discover)))
5653 (home-page "https://hackage.haskell.org/package/logging-facade")
5654 (synopsis "Simple logging abstraction that allows multiple back-ends")
5655 (description
5656 "This package provides a simple logging abstraction that allows multiple
5657 back-ends.")
5658 (license license:expat)))
5659
5660 (define-public ghc-mockery
5661 (package
5662 (name "ghc-mockery")
5663 (version "0.3.2")
5664 (source (origin
5665 (method url-fetch)
5666 (uri (string-append "https://hackage.haskell.org/package/"
5667 "mockery/mockery-" version ".tar.gz"))
5668 (sha256
5669 (base32
5670 "0m0lp2z63sgkylz5318j53r5hnrkp705qh7nqbb149ir4gy7g1bg"))))
5671 (build-system haskell-build-system)
5672 (inputs
5673 `(("ghc-temporary" ,ghc-temporary)
5674 ("ghc-logging-facade" ,ghc-logging-facade)))
5675 (native-inputs
5676 `(("ghc-hspec" ,ghc-hspec)
5677 ("hspec-discover" ,hspec-discover)))
5678 (home-page "https://hackage.haskell.org/package/mockery")
5679 (synopsis "Support functions for automated testing")
5680 (description
5681 "The mockery package provides support functions for automated testing.")
5682 (license license:expat)))
5683
5684 (define-public ghc-yaml
5685 (package
5686 (name "ghc-yaml")
5687 (version "0.8.15.1")
5688 (source (origin
5689 (method url-fetch)
5690 (uri (string-append "https://hackage.haskell.org/package/"
5691 "yaml/yaml-" version ".tar.gz"))
5692 (sha256
5693 (base32
5694 "0v6c435xmgm99zxb30pqr7lhkb2a56wxqp70g4hjz8p7rj0vichx"))))
5695 (build-system haskell-build-system)
5696 (inputs
5697 `(("ghc-conduit" ,ghc-conduit)
5698 ("ghc-resourcet" ,ghc-resourcet)
5699 ("ghc-aeson" ,ghc-aeson)
5700 ("ghc-unordered-containers" ,ghc-unordered-containers)
5701 ("ghc-vector" ,ghc-vector)
5702 ("ghc-text" ,ghc-text)
5703 ("ghc-attoparsec" ,ghc-attoparsec)
5704 ("ghc-scientific" ,ghc-scientific)
5705 ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
5706 ("ghc-aeson-qq" ,ghc-aeson-qq)
5707 ("ghc-base-compat" ,ghc-base-compat)))
5708 (native-inputs
5709 `(("ghc-hspec" ,ghc-hspec)
5710 ("ghc-hunit" ,ghc-hunit)
5711 ("hspec-discover" ,hspec-discover)
5712 ("ghc-mockery" ,ghc-mockery)))
5713 (home-page "https://github.com/snoyberg/yaml/")
5714 (synopsis "Parsing and rendering YAML documents")
5715 (description
5716 "This package provides a library to parse and render YAML documents.")
5717 (license license:bsd-3)))
5718
5719 (define-public ghc-filemanip
5720 (package
5721 (name "ghc-filemanip")
5722 (version "0.3.6.3")
5723 (source (origin
5724 (method url-fetch)
5725 (uri (string-append "https://hackage.haskell.org/package/"
5726 "filemanip/filemanip-" version ".tar.gz"))
5727 (sha256
5728 (base32
5729 "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
5730 (build-system haskell-build-system)
5731 (inputs
5732 `(("ghc-mtl" ,ghc-mtl)
5733 ("ghc-unix-compat" ,ghc-unix-compat)))
5734 (home-page "https://github.com/bos/filemanip")
5735 (synopsis "File and directory manipulation for Haskell")
5736 (description
5737 "This package provides a Haskell library for working with files and
5738 directories. It includes code for pattern matching, finding files, modifying
5739 file contents, and more.")
5740 (license license:bsd-3)))
5741
5742 (define-public ghc-mmap
5743 (package
5744 (name "ghc-mmap")
5745 (version "0.5.9")
5746 (source (origin
5747 (method url-fetch)
5748 (uri (string-append "https://hackage.haskell.org/package/"
5749 "mmap/mmap-" version ".tar.gz"))
5750 (sha256
5751 (base32
5752 "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
5753 (build-system haskell-build-system)
5754 (home-page "https://hackage.haskell.org/package/mmap")
5755 (synopsis "Memory mapped files for Haskell")
5756 (description
5757 "This library provides a wrapper to @code{mmap}, allowing files or
5758 devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
5759 @code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
5760 do on-demand loading.")
5761 (license license:bsd-3)))
5762
5763 (define-public ghc-juicypixels
5764 (package
5765 (name "ghc-juicypixels")
5766 (version "3.2.6.2")
5767 (source (origin
5768 (method url-fetch)
5769 (uri (string-append "https://hackage.haskell.org/package/"
5770 "JuicyPixels/JuicyPixels-"
5771 version ".tar.gz"))
5772 (sha256
5773 (base32
5774 "0hxa57cdknz86zywpjwfbdhac5lmk7j0wd5hy4mcnb8mw6r2m592"))))
5775 (build-system haskell-build-system)
5776 (inputs
5777 `(("ghc-mtl" ,ghc-mtl)
5778 ("ghc-zlib" ,ghc-zlib)
5779 ("ghc-vector" ,ghc-vector)
5780 ("ghc-primitive" ,ghc-primitive)
5781 ("ghc-mmap" ,ghc-mmap)))
5782 (home-page "https://github.com/Twinside/Juicy.Pixels")
5783 (synopsis "Picture loading and serialization library")
5784 (description
5785 "This library can load and store images in PNG, Bitmap, JPEG, Radiance,
5786 TIFF and GIF formats.")
5787 (license license:bsd-3)))
5788
5789 (define-public ghc-sha
5790 (package
5791 (name "ghc-sha")
5792 (version "1.6.4.2")
5793 (source (origin
5794 (method url-fetch)
5795 (uri (string-append "https://hackage.haskell.org/package/"
5796 "SHA/SHA-" version ".tar.gz"))
5797 (sha256
5798 (base32
5799 "134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64"))))
5800 (build-system haskell-build-system)
5801 (native-inputs
5802 `(("ghc-quickcheck" ,ghc-quickcheck)
5803 ("ghc-test-framework" ,ghc-test-framework)
5804 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
5805 (home-page "https://hackage.haskell.org/package/SHA")
5806 (synopsis "SHA suite of message digest functions")
5807 (description
5808 "This library implements the SHA suite of message digest functions,
5809 according to NIST FIPS 180-2 (with the SHA-224 addendum), as well as the
5810 SHA-based HMAC routines. The functions have been tested against most of the
5811 NIST and RFC test vectors for the various functions. While some attention has
5812 been paid to performance, these do not presently reach the speed of well-tuned
5813 libraries, like OpenSSL.")
5814 (license license:bsd-3)))
5815
5816 (define-public ghc-hslua
5817 (package
5818 (name "ghc-hslua")
5819 (version "0.4.1")
5820 (source (origin
5821 (method url-fetch)
5822 (uri (string-append "https://hackage.haskell.org/package/"
5823 "hslua/hslua-" version ".tar.gz"))
5824 (sha256
5825 (base32
5826 "0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid"))))
5827 (build-system haskell-build-system)
5828 (arguments
5829 `(#:configure-flags '("-fsystem-lua")))
5830 (inputs
5831 `(("lua" ,lua-5.1)
5832 ("ghc-text" ,ghc-text)))
5833 (native-inputs
5834 `(("ghc-hspec" ,ghc-hspec)
5835 ("ghc-hspec-contrib" ,ghc-hspec-contrib)
5836 ("hspec-discover" ,hspec-discover)
5837 ("ghc-hunit" ,ghc-hunit)
5838 ("ghc-quickcheck" ,ghc-quickcheck)
5839 ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
5840 (home-page "https://hackage.haskell.org/package/hslua")
5841 (synopsis "Lua language interpreter embedding in Haskell")
5842 (description
5843 "The Scripting.Lua module is a wrapper of the Lua language interpreter as
5844 described in @url{http://www.lua.org/}.")
5845 (license license:expat)))
5846
5847 (define-public ghc-mime-types
5848 (package
5849 (name "ghc-mime-types")
5850 (version "0.1.0.6")
5851 (source (origin
5852 (method url-fetch)
5853 (uri (string-append "https://hackage.haskell.org/package/"
5854 "mime-types/mime-types-"
5855 version ".tar.gz"))
5856 (sha256
5857 (base32
5858 "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw"))))
5859 (build-system haskell-build-system)
5860 (inputs
5861 `(("ghc-text" ,ghc-text)))
5862 (home-page "https://github.com/yesodweb/wai")
5863 (synopsis "Basic MIME type handling types and functions")
5864 (description
5865 "This library provides basic MIME type handling types and functions.")
5866 (license license:expat)))
5867
5868 (define-public ghc-http-client
5869 (package
5870 (name "ghc-http-client")
5871 (version "0.4.24")
5872 (source (origin
5873 (method url-fetch)
5874 (uri (string-append "https://hackage.haskell.org/package/"
5875 "http-client/http-client-"
5876 version ".tar.gz"))
5877 (sha256
5878 (base32
5879 "0xz133kdfiyy2rm6z95bmvjj6y2540xzd86cfmdv9s6kz4p1ir4k"))))
5880 (build-system haskell-build-system)
5881 ;; Tests require access to the web.
5882 (arguments `(#:tests? #f))
5883 (inputs
5884 `(("ghc-text" ,ghc-text)
5885 ("ghc-http-types" ,ghc-http-types)
5886 ("ghc-blaze-builder" ,ghc-blaze-builder)
5887 ("ghc-data-default-class" ,ghc-data-default-class)
5888 ("ghc-network" ,ghc-network)
5889 ("ghc-streaming-commons" ,ghc-streaming-commons)
5890 ("ghc-case-insensitive" ,ghc-case-insensitive)
5891 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
5892 ("ghc-cookie" ,ghc-cookie)
5893 ("ghc-exceptions" ,ghc-exceptions)
5894 ("ghc-random" ,ghc-random)
5895 ("ghc-mime-types" ,ghc-mime-types)
5896 ("ghc-network-uri" ,ghc-network-uri)
5897 ("ghc-monad-control" ,ghc-monad-control)
5898 ("ghc-zlib" ,ghc-zlib)
5899 ("ghc-async" ,ghc-async)))
5900 (native-inputs
5901 `(("ghc-hspec" ,ghc-hspec)))
5902 (home-page "https://github.com/snoyberg/http-client")
5903 (synopsis "HTTP client engine")
5904 (description
5905 "This package provides an HTTP client engine, intended as a base layer
5906 for more user-friendly packages.")
5907 (license license:expat)))
5908
5909 (define-public ghc-byteable
5910 (package
5911 (name "ghc-byteable")
5912 (version "0.1.1")
5913 (source (origin
5914 (method url-fetch)
5915 (uri (string-append "https://hackage.haskell.org/package/"
5916 "byteable/byteable-" version ".tar.gz"))
5917 (sha256
5918 (base32
5919 "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4"))))
5920 (build-system haskell-build-system)
5921 (home-page "https://github.com/vincenthz/hs-byteable")
5922 (synopsis "Type class for sequence of bytes")
5923 (description
5924 "This package provides an abstract class to manipulate sequence of bytes.
5925 The use case of this class is abstracting manipulation of types that are just
5926 wrapping a bytestring with stronger and more meaniful name.")
5927 (license license:bsd-3)))
5928
5929 (define-public ghc-hourglass
5930 (package
5931 (name "ghc-hourglass")
5932 (version "0.2.9")
5933 (source (origin
5934 (method url-fetch)
5935 (uri (string-append "https://hackage.haskell.org/package/"
5936 "hourglass/hourglass-" version ".tar.gz"))
5937 (sha256
5938 (base32
5939 "1xha17nwzxdjizbcp63d2142c6q051y77facs7xribgcl5iz2m4v"))))
5940 (build-system haskell-build-system)
5941 (inputs
5942 `(("ghc-mtl" ,ghc-mtl)
5943 ("ghc-old-locale" ,ghc-old-locale)))
5944 (native-inputs
5945 `(("ghc-tasty" ,ghc-tasty)
5946 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
5947 ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
5948 (home-page "https://github.com/vincenthz/hs-hourglass")
5949 (synopsis "Simple time-related library for Haskell")
5950 (description
5951 "This is a simple time library providing a simple but powerful and
5952 performant API. The backbone of the library are the @code{Timeable} and
5953 @code{Time} type classes. Each @code{Timeable} instances can be converted to
5954 a type that has a @code{Time} instances, and thus are different
5955 representations of current time.")
5956 (license license:bsd-3)))
5957
5958 (define-public ghc-pem
5959 (package
5960 (name "ghc-pem")
5961 (version "0.2.2")
5962 (source (origin
5963 (method url-fetch)
5964 (uri (string-append "https://hackage.haskell.org/package/"
5965 "pem/pem-" version ".tar.gz"))
5966 (sha256
5967 (base32
5968 "162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p"))))
5969 (build-system haskell-build-system)
5970 (inputs
5971 `(("ghc-mtl" ,ghc-mtl)
5972 ("ghc-base64-bytestring" ,ghc-base64-bytestring)))
5973 (native-inputs
5974 `(("ghc-test-framework" ,ghc-test-framework)
5975 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
5976 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
5977 ("ghc-hunit" ,ghc-hunit)
5978 ("ghc-quickcheck" ,ghc-quickcheck)))
5979 (home-page "https://github.com/vincenthz/hs-pem")
5980 (synopsis "Privacy Enhanced Mail (PEM) format reader and writer")
5981 (description
5982 "This library provides readers and writers for the @dfn{Privacy Enhanced
5983 Mail} (PEM) format.")
5984 (license license:bsd-3)))
5985
5986 (define-public ghc-asn1-types
5987 (package
5988 (name "ghc-asn1-types")
5989 (version "0.3.1")
5990 (source (origin
5991 (method url-fetch)
5992 (uri (string-append "https://hackage.haskell.org/package/"
5993 "asn1-types/asn1-types-"
5994 version ".tar.gz"))
5995 (sha256
5996 (base32
5997 "1iif9yrh4mmj249gyvam0zb2vb3jnlz777gahh2z9sx00dsx9rja"))))
5998 (build-system haskell-build-system)
5999 (inputs
6000 `(("ghc-memory" ,ghc-memory)
6001 ("ghc-hourglass" ,ghc-hourglass)))
6002 (home-page "https://github.com/vincenthz/hs-asn1-types")
6003 (synopsis "ASN.1 types for Haskell")
6004 (description
6005 "The package provides the standard types for dealing with the ASN.1
6006 format.")
6007 (license license:bsd-3)))
6008
6009 (define-public ghc-asn1-encoding
6010 (package
6011 (name "ghc-asn1-encoding")
6012 (version "0.9.3")
6013 (source (origin
6014 (method url-fetch)
6015 (uri (string-append "https://hackage.haskell.org/package/"
6016 "asn1-encoding/asn1-encoding-"
6017 version ".tar.gz"))
6018 (sha256
6019 (base32
6020 "01ki5msrpccgdbdiaaa5a9zw0icp1hki4hca8qx6hzlp0rcf1mwh"))))
6021 (build-system haskell-build-system)
6022 (inputs
6023 `(("ghc-hourglass" ,ghc-hourglass)
6024 ("ghc-asn1-types" ,ghc-asn1-types)
6025 ("ghc-text" ,ghc-text)
6026 ("ghc-mtl" ,ghc-mtl)))
6027 (native-inputs
6028 `(("ghc-tasty" ,ghc-tasty)
6029 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
6030 (home-page "https://github.com/vincenthz/hs-asn1")
6031 (synopsis "ASN1 data reader and writer in RAW, BER and DER forms")
6032 (description
6033 "This package provides a reader and writer for ASN1 data in raw form with
6034 supports for high level forms of ASN1 (BER, and DER).")
6035 (license license:bsd-3)))
6036
6037 (define-public ghc-asn1-parse
6038 (package
6039 (name "ghc-asn1-parse")
6040 (version "0.9.4")
6041 (source (origin
6042 (method url-fetch)
6043 (uri (string-append "https://hackage.haskell.org/package/"
6044 "asn1-parse/asn1-parse-"
6045 version ".tar.gz"))
6046 (sha256
6047 (base32
6048 "025prsihk5g6rdv9xlfmj0zpa0wa3qjzj5i4ilzvg7f6f3sji8y6"))))
6049 (build-system haskell-build-system)
6050 (inputs
6051 `(("ghc-asn1-types" ,ghc-asn1-types)
6052 ("ghc-asn1-encoding" ,ghc-asn1-encoding)))
6053 (home-page "https://github.com/vincenthz/hs-asn1")
6054 (synopsis "Simple monadic parser for ASN1 stream types")
6055 (description
6056 "This package provides a simple monadic parser for ASN1 stream types,
6057 when ASN1 pattern matching is not convenient.")
6058 (license license:bsd-3)))
6059
6060 (define-public ghc-tasty-kat
6061 (package
6062 (name "ghc-tasty-kat")
6063 (version "0.0.3")
6064 (source (origin
6065 (method url-fetch)
6066 (uri (string-append "https://hackage.haskell.org/package/"
6067 "tasty-kat/tasty-kat-" version ".tar.gz"))
6068 (sha256
6069 (base32
6070 "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
6071 (build-system haskell-build-system)
6072 (inputs
6073 `(("ghc-tasty" ,ghc-tasty)
6074 ("ghc-mtl" ,ghc-mtl)
6075 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6076 ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
6077 (home-page "https://github.com/vincenthz/tasty-kat")
6078 (synopsis "Known Answer Tests (KAT) framework for tasty")
6079 (description
6080 "This package provides a @dfn{Known Answer Tests} (KAT) framework for
6081 tasty.")
6082 (license license:expat)))
6083
6084 (define-public ghc-cryptonite
6085 (package
6086 (name "ghc-cryptonite")
6087 (version "0.19")
6088 (source (origin
6089 (method url-fetch)
6090 (uri (string-append "https://hackage.haskell.org/package/"
6091 "cryptonite/cryptonite-"
6092 version ".tar.gz"))
6093 (sha256
6094 (base32
6095 "1rw5k34vpn4134yrzdhf0rsshsrkixfbv9ap18di2n00z2cw1shw"))))
6096 (build-system haskell-build-system)
6097 (inputs
6098 `(("ghc-memory" ,ghc-memory)
6099 ("ghc-byteable" ,ghc-byteable)))
6100 (native-inputs
6101 `(("ghc-tasty" ,ghc-tasty)
6102 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6103 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
6104 ("ghc-tasty-kat" ,ghc-tasty-kat)))
6105 (home-page "https://github.com/haskell-crypto/cryptonite")
6106 (synopsis "Cryptography primitives")
6107 (description
6108 "This package is a repository of cryptographic primitives for Haskell.
6109 It supports a wide range of symmetric ciphers, cryptographic hash functions,
6110 public key algorithms, key derivation numbers, cryptographic random number
6111 generators, and more.")
6112 (license license:bsd-3)))
6113
6114 (define-public ghc-memory
6115 (package
6116 (name "ghc-memory")
6117 (version "0.13")
6118 (source (origin
6119 (method url-fetch)
6120 (uri (string-append "https://hackage.haskell.org/package/"
6121 "memory/memory-" version ".tar.gz"))
6122 (sha256
6123 (base32
6124 "02l742qxjqy3jw1a347gb7sn7pn7a5qha1vzi2qqbvgafcjn0wyw"))))
6125 (build-system haskell-build-system)
6126 (native-inputs
6127 `(("ghc-tasty" ,ghc-tasty)
6128 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6129 ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
6130 (home-page "https://github.com/vincenthz/hs-memory")
6131 (synopsis "Memory abstractions for Haskell")
6132 (description
6133 "This package provides memory abstractions, such as chunk of memory,
6134 polymorphic byte array management and manipulation functions. It contains a
6135 polymorphic byte array abstraction and functions similar to strict ByteString,
6136 different type of byte array abstraction, raw memory IO operations (memory
6137 set, memory copy, ..) and more")
6138 (license license:bsd-3)))
6139
6140 (define-public ghc-x509
6141 (package
6142 (name "ghc-x509")
6143 (version "1.6.3")
6144 (source (origin
6145 (method url-fetch)
6146 (uri (string-append "https://hackage.haskell.org/package/"
6147 "x509/x509-" version ".tar.gz"))
6148 (sha256
6149 (base32
6150 "1pmsby29abn485fvnymsgipvb3p1ch9c591xj5ncszkf0ivjiiin"))))
6151 (build-system haskell-build-system)
6152 (inputs
6153 `(("ghc-memory" ,ghc-memory)
6154 ("ghc-mtl" ,ghc-mtl)
6155 ("ghc-hourglass" ,ghc-hourglass)
6156 ("ghc-pem" ,ghc-pem)
6157 ("ghc-asn1-types" ,ghc-asn1-types)
6158 ("ghc-asn1-encoding" ,ghc-asn1-encoding)
6159 ("ghc-asn1-parse" ,ghc-asn1-parse)
6160 ("ghc-cryptonite" ,ghc-cryptonite)))
6161 (native-inputs
6162 `(("ghc-tasty" ,ghc-tasty)
6163 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
6164 (home-page "https://github.com/vincenthz/hs-certificate")
6165 (synopsis "X509 reader and writer")
6166 (description
6167 "This library provides functions to read and write X509 certificates.")
6168 (license license:bsd-3)))
6169
6170 (define-public ghc-x509-store
6171 (package
6172 (name "ghc-x509-store")
6173 (version "1.6.1")
6174 (source (origin
6175 (method url-fetch)
6176 (uri (string-append "https://hackage.haskell.org/package/"
6177 "x509-store/x509-store-"
6178 version ".tar.gz"))
6179 (sha256
6180 (base32
6181 "01abx528i9f7djq2772xyna8x2mykrnwqkcfrapcx7z3bhprvml3"))))
6182 (build-system haskell-build-system)
6183 (inputs
6184 `(("ghc-mtl" ,ghc-mtl)
6185 ("ghc-pem" ,ghc-pem)
6186 ("ghc-asn1-types" ,ghc-asn1-types)
6187 ("ghc-asn1-encoding" ,ghc-asn1-encoding)
6188 ("ghc-cryptonite" ,ghc-cryptonite)
6189 ("ghc-x509" ,ghc-x509)))
6190 (home-page "https://github.com/vincenthz/hs-certificate")
6191 (synopsis "X.509 collection accessing and storing methods")
6192 (description
6193 "This package provides functions for accessing and storing X.509
6194 collections, certificates, revocation lists, and exception lists.")
6195 (license license:bsd-3)))
6196
6197 (define-public ghc-x509-validation
6198 (package
6199 (name "ghc-x509-validation")
6200 (version "1.6.3")
6201 (source (origin
6202 (method url-fetch)
6203 (uri (string-append "https://hackage.haskell.org/package/"
6204 "x509-validation/x509-validation-"
6205 version ".tar.gz"))
6206 (sha256
6207 (base32
6208 "1qr1v561hdlhjgqjv9pj9mbk0q1xf2mr1j67ghy93nlxxyzd7dw0"))))
6209 (build-system haskell-build-system)
6210 (inputs
6211 `(("ghc-memory" ,ghc-memory)
6212 ("ghc-byteable" ,ghc-byteable)
6213 ("ghc-mtl" ,ghc-mtl)
6214 ("ghc-hourglass" ,ghc-hourglass)
6215 ("ghc-data-default-class" ,ghc-data-default-class)
6216 ("ghc-pem" ,ghc-pem)
6217 ("ghc-asn1-types" ,ghc-asn1-types)
6218 ("ghc-asn1-encoding" ,ghc-asn1-encoding)
6219 ("ghc-x509" ,ghc-x509)
6220 ("ghc-x509-store" ,ghc-x509-store)
6221 ("ghc-cryptonite" ,ghc-cryptonite)))
6222 (home-page "https://github.com/vincenthz/hs-certificate")
6223 (synopsis "X.509 certificate and revocation list validation")
6224 (description
6225 "This package provides functions for X.509 certificate and revocation
6226 list validation.")
6227 (license license:bsd-3)))
6228
6229 (define-public ghc-x509-system
6230 (package
6231 (name "ghc-x509-system")
6232 (version "1.6.1")
6233 (source (origin
6234 (method url-fetch)
6235 (uri (string-append "https://hackage.haskell.org/package/"
6236 "x509-system/x509-system-"
6237 version ".tar.gz"))
6238 (sha256
6239 (base32
6240 "10qf60d2f9jqwnbrhsb2cwpi86xg66m6dxndlxw967v1cdb3h6gf"))))
6241 (build-system haskell-build-system)
6242 (inputs
6243 `(("ghc-mtl" ,ghc-mtl)
6244 ("ghc-pem" ,ghc-pem)
6245 ("ghc-x509" ,ghc-x509)
6246 ("ghc-x509-store" ,ghc-x509-store)))
6247 (home-page "https://github.com/vincenthz/hs-certificate")
6248 (synopsis "Handle system X.509 accessors and storage")
6249 (description
6250 "This package provides a library to handle system accessors and storage
6251 for X.509 certificates.")
6252 (license license:bsd-3)))
6253
6254 (define-public ghc-tls
6255 (package
6256 (name "ghc-tls")
6257 (version "1.3.8")
6258 (source (origin
6259 (method url-fetch)
6260 (uri (string-append "https://hackage.haskell.org/package/"
6261 "tls/tls-" version ".tar.gz"))
6262 (sha256
6263 (base32
6264 "1rdidf18i781c0vdvy9yn79yh08hmcacf6fp3sgghyiy3h0wyh5l"))))
6265 (build-system haskell-build-system)
6266 (inputs
6267 `(("ghc-mtl" ,ghc-mtl)
6268 ("ghc-cereal" ,ghc-cereal)
6269 ("ghc-data-default-class" ,ghc-data-default-class)
6270 ("ghc-memory" ,ghc-memory)
6271 ("ghc-cryptonite" ,ghc-cryptonite)
6272 ("ghc-asn1-types" ,ghc-asn1-types)
6273 ("ghc-asn1-encoding" ,ghc-asn1-encoding)
6274 ("ghc-x509" ,ghc-x509)
6275 ("ghc-x509-store" ,ghc-x509-store)
6276 ("ghc-x509-validation" ,ghc-x509-validation)
6277 ("ghc-async" ,ghc-async)
6278 ("ghc-network" ,ghc-network)
6279 ("ghc-hourglass" ,ghc-hourglass)))
6280 (native-inputs
6281 `(("ghc-tasty" ,ghc-tasty)
6282 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6283 ("ghc-quickcheck" ,ghc-quickcheck)))
6284 (home-page "https://github.com/vincenthz/hs-tls")
6285 (synopsis
6286 "TLS/SSL protocol native implementation (Server and Client)")
6287 (description
6288 "Native Haskell TLS and SSL protocol implementation for server and client.
6289 This provides a high-level implementation of a sensitive security protocol,
6290 eliminating a common set of security issues through the use of the advanced
6291 type system, high level constructions and common Haskell features. Currently
6292 implement the SSL3.0, TLS1.0, TLS1.1 and TLS1.2 protocol, and support RSA and
6293 Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many
6294 extensions.")
6295 (license license:bsd-3)))
6296
6297 (define-public ghc-socks
6298 (package
6299 (name "ghc-socks")
6300 (version "0.5.4")
6301 (source (origin
6302 (method url-fetch)
6303 (uri (string-append "https://hackage.haskell.org/package/"
6304 "socks/socks-" version ".tar.gz"))
6305 (sha256
6306 (base32
6307 "1nmldlwxqasmg359i2aa3a903gi3lmnlspvf12xk49jrg3mf3dg9"))))
6308 (build-system haskell-build-system)
6309 (inputs
6310 `(("ghc-cereal" ,ghc-cereal)
6311 ("ghc-network" ,ghc-network)))
6312 (home-page "https://github.com/vincenthz/hs-socks")
6313 (synopsis "SOCKS proxy (version 5) implementation")
6314 (description
6315 "This library provides a SOCKS proxy (version 5) implementation.")
6316 (license license:bsd-3)))
6317
6318 (define-public ghc-connection
6319 (package
6320 (name "ghc-connection")
6321 (version "0.2.5")
6322 (source (origin
6323 (method url-fetch)
6324 (uri (string-append "https://hackage.haskell.org/package/"
6325 "connection/connection-"
6326 version ".tar.gz"))
6327 (sha256
6328 (base32
6329 "090il95jnm7ihwvcx3s9v6iwnp37nnsdx15q7722l845g51d95c8"))))
6330 (build-system haskell-build-system)
6331 (inputs
6332 `(("ghc-byteable" ,ghc-byteable)
6333 ("ghc-data-default-class" ,ghc-data-default-class)
6334 ("ghc-network" ,ghc-network)
6335 ("ghc-tls" ,ghc-tls)
6336 ("ghc-socks" ,ghc-socks)
6337 ("ghc-x509" ,ghc-x509)
6338 ("ghc-x509-store" ,ghc-x509-store)
6339 ("ghc-x509-system" ,ghc-x509-system)
6340 ("ghc-x509-validation" ,ghc-x509-validation)))
6341 (home-page "https://github.com/vincenthz/hs-connection")
6342 (synopsis "Simple and easy network connections API")
6343 (description
6344 "This package provides a simple network library for all your connection
6345 needs. It provides a very simple API to create sockets to a destination with
6346 the choice of SSL/TLS, and SOCKS.")
6347 (license license:bsd-3)))
6348
6349 (define-public ghc-http-client-tls
6350 (package
6351 (name "ghc-http-client-tls")
6352 (version "0.2.2")
6353 (source (origin
6354 (method url-fetch)
6355 (uri (string-append "https://hackage.haskell.org/package/"
6356 "http-client-tls/http-client-tls-"
6357 version ".tar.gz"))
6358 (sha256
6359 (base32
6360 "0a01r05h5fxswyn6k6cgqgak4scqjan72hyy5wbdqzzhl4rmh7j5"))))
6361 (build-system haskell-build-system)
6362 ;; Tests require Internet access
6363 (arguments `(#:tests? #f))
6364 (inputs
6365 `(("ghc-data-default-class" ,ghc-data-default-class)
6366 ("ghc-http-client" ,ghc-http-client)
6367 ("ghc-connection" ,ghc-connection)
6368 ("ghc-network" ,ghc-network)
6369 ("ghc-tls" ,ghc-tls)
6370 ("ghc-http-types" ,ghc-http-types)))
6371 (native-inputs
6372 `(("ghc-hspec" ,ghc-hspec)))
6373 (home-page "https://github.com/snoyberg/http-client")
6374 (synopsis "Backend for http-client using the TLS library")
6375 (description
6376 "This package provides a backend for the http-client package using the
6377 connection and TLS libraries. It is intended for use by higher-level
6378 libraries, such as http-conduit.")
6379 (license license:expat)))
6380
6381 (define-public ghc-pandoc
6382 (package
6383 (name "ghc-pandoc")
6384 (version "1.17.2")
6385 (source
6386 (origin
6387 (method url-fetch)
6388 (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
6389 version ".tar.gz"))
6390 (sha256
6391 (base32
6392 "1v78zq12p71gq0pc24h08inxcq5gxd0xb7m5ds0xw9pv9l2pswl1"))))
6393 (build-system haskell-build-system)
6394 (inputs
6395 `(("ghc-syb" ,ghc-syb)
6396 ("ghc-unordered-containers" ,ghc-unordered-containers)
6397 ("ghc-parsec" ,ghc-parsec)
6398 ("ghc-mtl" ,ghc-mtl)
6399 ("ghc-text" ,ghc-text)
6400 ("ghc-zip-archive" ,ghc-zip-archive)
6401 ("ghc-http" ,ghc-http)
6402 ("ghc-texmath" ,ghc-texmath)
6403 ("ghc-xml" ,ghc-xml)
6404 ("ghc-random" ,ghc-random)
6405 ("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
6406 ("ghc-pandoc-types" ,ghc-pandoc-types)
6407 ("ghc-aeson" ,ghc-aeson)
6408 ("ghc-tagsoup" ,ghc-tagsoup)
6409 ("ghc-base64-bytestring" ,ghc-base64-bytestring)
6410 ("ghc-zlib" ,ghc-zlib)
6411 ("ghc-highlighting-kate" ,ghc-highlighting-kate)
6412 ("ghc-data-default" ,ghc-data-default)
6413 ("ghc-temporary" ,ghc-temporary)
6414 ("ghc-blaze-html" ,ghc-blaze-html)
6415 ("ghc-blaze-markup" ,ghc-blaze-markup)
6416 ("ghc-yaml" ,ghc-yaml)
6417 ("ghc-scientific" ,ghc-scientific)
6418 ("ghc-vector" ,ghc-vector)
6419 ("ghc-hslua" ,ghc-hslua)
6420 ("ghc-sha" ,ghc-sha)
6421 ("ghc-haddock-library" ,ghc-haddock-library)
6422 ("ghc-old-time" ,ghc-old-time)
6423 ("ghc-deepseq-generics" ,ghc-deepseq-generics)
6424 ("ghc-juicypixels" ,ghc-juicypixels)
6425 ("ghc-filemanip" ,ghc-filemanip)
6426 ("ghc-cmark" ,ghc-cmark)
6427 ("ghc-network-uri" ,ghc-network-uri)
6428 ("ghc-network" ,ghc-network)
6429 ("ghc-http-client" ,ghc-http-client)
6430 ("ghc-http-client-tls" ,ghc-http-client-tls)
6431 ("ghc-http-types" ,ghc-http-types)
6432 ("ghc-diff" ,ghc-diff)
6433 ("ghc-ansi-terminal" ,ghc-ansi-terminal)
6434 ("ghc-executable-path" ,ghc-executable-path)))
6435 (native-inputs
6436 `(("ghc-test-framework" ,ghc-test-framework)
6437 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
6438 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
6439 ("ghc-quickcheck" ,ghc-quickcheck)
6440 ("ghc-hunit" ,ghc-hunit)))
6441 (home-page "http://pandoc.org")
6442 (synopsis "Conversion between markup formats")
6443 (description
6444 "Pandoc is a Haskell library for converting from one markup format to
6445 another, and a command-line tool that uses this library. It can read and
6446 write Markdown and (subsets of) other formats, such as HTML, reStructuredText,
6447 LaTeX, DocBook, and many more.
6448
6449 Pandoc extends standard Markdown syntax with footnotes, embedded LaTeX,
6450 definition lists, tables, and other features. A compatibility mode is
6451 provided for those who need a drop-in replacement for Markdown.pl.")
6452 (license license:gpl2+)))
6453
6454 (define-public ghc-hs-bibutils
6455 (package
6456 (name "ghc-hs-bibutils")
6457 (version "5.5")
6458 (source
6459 (origin
6460 (method url-fetch)
6461 (uri (string-append
6462 "https://hackage.haskell.org/package/hs-bibutils/hs-bibutils-"
6463 version ".tar.gz"))
6464 (sha256
6465 (base32
6466 "0pf5lh179rw9jkmw16ss3kiwydlj6zgfk868mjl5s57kx55z7ycm"))))
6467 (build-system haskell-build-system)
6468 (inputs `(("ghc-syb" ,ghc-syb)))
6469 (home-page "https://hackage.haskell.org/package/hs-bibutils")
6470 (synopsis "Haskell bindings to bibutils")
6471 (description
6472 "This package provides Haskell bindings to @code{bibutils}, a library
6473 that interconverts between various bibliography formats using a common
6474 MODS-format XML intermediate.")
6475 (license license:gpl2+)))
6476
6477 (define-public ghc-rfc5051
6478 (package
6479 (name "ghc-rfc5051")
6480 (version "0.1.0.3")
6481 (source
6482 (origin
6483 (method url-fetch)
6484 (uri (string-append "https://hackage.haskell.org/package/rfc5051/"
6485 "rfc5051-" version ".tar.gz"))
6486 (sha256
6487 (base32
6488 "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3"))))
6489 (build-system haskell-build-system)
6490 (home-page "http://hackage.haskell.org/package/rfc5051")
6491 (synopsis "Simple unicode collation as per RFC5051")
6492 (description
6493 "This library implements @code{unicode-casemap}, the simple, non
6494 locale-sensitive unicode collation algorithm described in RFC 5051. Proper
6495 unicode collation can be done using @code{text-icu}, but that is a big
6496 dependency that depends on a large C library, and @code{rfc5051} might be
6497 better for some purposes.")
6498 (license license:bsd-3)))
6499
6500 (define-public ghc-conduit-extra
6501 (package
6502 (name "ghc-conduit-extra")
6503 (version "1.1.13.2")
6504 (source
6505 (origin
6506 (method url-fetch)
6507 (uri (string-append "https://hackage.haskell.org/package/"
6508 "conduit-extra/conduit-extra-"
6509 version ".tar.gz"))
6510 (sha256
6511 (base32
6512 "108vsn9dpsfwvar7nssw6wkqy26rxlf3p4ran6swa5xh8l6d5k4z"))))
6513 (build-system haskell-build-system)
6514 (inputs
6515 `(("ghc-conduit" ,ghc-conduit)
6516 ("ghc-exceptions" ,ghc-exceptions)
6517 ("ghc-monad-control" ,ghc-monad-control)
6518 ("ghc-text" ,ghc-text)
6519 ("ghc-transformers-base" ,ghc-transformers-base)
6520 ("ghc-async" ,ghc-async)
6521 ("ghc-attoparsec" ,ghc-attoparsec)
6522 ("ghc-blaze-builder" ,ghc-blaze-builder)
6523 ("ghc-network" ,ghc-network)
6524 ("ghc-primitive" ,ghc-primitive)
6525 ("ghc-resourcet" ,ghc-resourcet)
6526 ("ghc-stm" ,ghc-stm)
6527 ("ghc-streaming-commons" ,ghc-streaming-commons)
6528 ("ghc-hspec" ,ghc-hspec)
6529 ("ghc-bytestring-builder" ,ghc-bytestring-builder)
6530 ("ghc-quickcheck" ,ghc-quickcheck)))
6531 (native-inputs
6532 `(("hspec-discover" ,hspec-discover)))
6533 (home-page "http://github.com/snoyberg/conduit")
6534 (synopsis "Conduit adapters for common libraries")
6535 (description
6536 "The @code{conduit} package itself maintains relative small dependencies.
6537 The purpose of this package is to collect commonly used utility functions
6538 wrapping other library dependencies, without depending on heavier-weight
6539 dependencies. The basic idea is that this package should only depend on
6540 @code{haskell-platform} packages and @code{conduit}.")
6541 (license license:expat)))
6542
6543 (define-public ghc-xml-types
6544 (package
6545 (name "ghc-xml-types")
6546 (version "0.3.6")
6547 (source
6548 (origin
6549 (method url-fetch)
6550 (uri (string-append "https://hackage.haskell.org/package/xml-types/"
6551 "xml-types-" version ".tar.gz"))
6552 (sha256
6553 (base32
6554 "1jgqxsa9p2q3h6nymbfmvhldqrqlwrhrzmwadlyc0li50x0d8dwr"))))
6555 (build-system haskell-build-system)
6556 (inputs `(("ghc-text" ,ghc-text)))
6557 (home-page "https://john-millikin.com/software/haskell-xml/")
6558 (synopsis "Basic types for representing XML")
6559 (description "This package provides basic types for representing XML
6560 documents.")
6561 (license license:expat)))
6562
6563 (define-public ghc-xml-conduit
6564 (package
6565 (name "ghc-xml-conduit")
6566 (version "1.3.5")
6567 (source
6568 (origin
6569 (method url-fetch)
6570 (uri (string-append "https://hackage.haskell.org/package/xml-conduit/"
6571 "xml-conduit-" version ".tar.gz"))
6572 (sha256
6573 (base32
6574 "10yw8jiksw21jgwqjjd1ixflavcblisgkp9qq3ba05vadc35lqr5"))))
6575 (build-system haskell-build-system)
6576 (inputs
6577 `(("ghc-conduit" ,ghc-conduit)
6578 ("ghc-conduit-extra" ,ghc-conduit-extra)
6579 ("ghc-resourcet" ,ghc-resourcet)
6580 ("ghc-text" ,ghc-text)
6581 ("ghc-xml-types" ,ghc-xml-types)
6582 ("ghc-attoparsec" ,ghc-attoparsec)
6583 ("ghc-blaze-builder" ,ghc-blaze-builder)
6584 ("ghc-blaze-markup" ,ghc-blaze-markup)
6585 ("ghc-blaze-html" ,ghc-blaze-html)
6586 ("ghc-data-default" ,ghc-data-default)
6587 ("ghc-monad-control" ,ghc-monad-control)
6588 ("ghc-hspec" ,ghc-hspec)
6589 ("ghc-hunit" ,ghc-hunit)))
6590 (home-page "http://github.com/snoyberg/xml")
6591 (synopsis "Utilities for dealing with XML with the conduit package")
6592 (description
6593 "This package provides pure-Haskell utilities for dealing with XML with
6594 the @code{conduit} package.")
6595 (license license:expat)))
6596
6597 (define-public ghc-pandoc-citeproc
6598 (package
6599 (name "ghc-pandoc-citeproc")
6600 (version "0.10")
6601 (source
6602 (origin
6603 (method url-fetch)
6604 (uri (string-append "https://hackage.haskell.org/package/"
6605 "pandoc-citeproc/pandoc-citeproc-"
6606 version ".tar.gz"))
6607 (sha256
6608 (base32
6609 "00mprphppk51ylsrkg817mbk23f9fsfvkwzbys9qqbcjbrxi2r94"))))
6610 (build-system haskell-build-system)
6611 (arguments
6612 `(#:phases
6613 (modify-phases %standard-phases
6614 ;; Tests need to be run after installation.
6615 (delete 'check)
6616 (add-after 'install 'post-install-check
6617 (assoc-ref %standard-phases 'check)))))
6618 (inputs
6619 `(("ghc-mtl" ,ghc-mtl)
6620 ("ghc-pandoc-types" ,ghc-pandoc-types)
6621 ("ghc-pandoc" ,ghc-pandoc)
6622 ("ghc-tagsoup" ,ghc-tagsoup)
6623 ("ghc-aeson" ,ghc-aeson)
6624 ("ghc-text" ,ghc-text)
6625 ("ghc-vector" ,ghc-vector)
6626 ("ghc-xml-conduit" ,ghc-xml-conduit)
6627 ("ghc-unordered-containers" ,ghc-unordered-containers)
6628 ("ghc-data-default" ,ghc-data-default)
6629 ("ghc-setenv" ,ghc-setenv)
6630 ("ghc-split" ,ghc-split)
6631 ("ghc-yaml" ,ghc-yaml)
6632 ("ghc-hs-bibutils" ,ghc-hs-bibutils)
6633 ("ghc-rfc5051" ,ghc-rfc5051)
6634 ("ghc-syb" ,ghc-syb)
6635 ("ghc-parsec" ,ghc-parsec)
6636 ("ghc-old-locale" ,ghc-old-locale)
6637 ("ghc-aeson-pretty" ,ghc-aeson-pretty)
6638 ("ghc-attoparsec" ,ghc-attoparsec)
6639 ("ghc-temporary" ,ghc-temporary)))
6640 (home-page "https://github.com/jgm/pandoc-citeproc")
6641 (synopsis "Library for using pandoc with citeproc")
6642 (description
6643 "The @code{pandoc-citeproc} library exports functions for using the
6644 citeproc system with pandoc. It relies on @code{citeproc-hs}, a library for
6645 rendering bibliographic reference citations into a variety of styles using a
6646 macro language called @dfn{Citation Style Language} (CSL). This package also
6647 contains an executable @code{pandoc-citeproc}, which works as a pandoc filter,
6648 and also has a mode for converting bibliographic databases a YAML format
6649 suitable for inclusion in pandoc YAML metadata.")
6650 (license license:bsd-3)))
6651
6652 (define-public ghc-union-find
6653 (package
6654 (name "ghc-union-find")
6655 (version "0.2")
6656 (source (origin
6657 (method url-fetch)
6658 (uri (string-append
6659 "https://hackage.haskell.org/package/union-find/union-find-"
6660 version ".tar.gz"))
6661 (sha256
6662 (base32
6663 "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6"))))
6664 (build-system haskell-build-system)
6665 (home-page "https://github.com/nominolo/union-find")
6666 (synopsis "Efficient union and equivalence testing of sets")
6667 (description
6668 "The Union/Find algorithm implements these operations in (effectively)
6669 constant-time:
6670 @enumerate
6671 @item Check whether two elements are in the same equivalence class.
6672 @item Create a union of two equivalence classes.
6673 @item Look up the descriptor of the equivalence class.
6674 @end enumerate\n")
6675 (license license:bsd-3)))
6676
6677 (define-public ghc-base16-bytestring
6678 (package
6679 (name "ghc-base16-bytestring")
6680 (version "0.1.1.6")
6681 (source
6682 (origin
6683 (method url-fetch)
6684 (uri (string-append
6685 "https://hackage.haskell.org/package/base16-bytestring/"
6686 "base16-bytestring-" version ".tar.gz"))
6687 (sha256
6688 (base32
6689 "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs"))))
6690 (build-system haskell-build-system)
6691 (home-page "http://github.com/bos/base16-bytestring")
6692 (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings")
6693 (description
6694 "This package provides a Haskell library for working with base16-encoded
6695 data quickly and efficiently, using the ByteString type.")
6696 (license license:bsd-3)))
6697
6698 (define-public ghc-binary
6699 (package
6700 (name "ghc-binary")
6701 (version "0.8.4.1")
6702 (source
6703 (origin
6704 (method url-fetch)
6705 (uri (string-append
6706 "https://hackage.haskell.org/package/binary/binary-"
6707 version ".tar.gz"))
6708 (sha256
6709 (base32
6710 "1fp7wxnf57cjzhbb7rgqs6fgws4690zh0dxgl924dj4nzq0cf4wd"))))
6711 (build-system haskell-build-system)
6712 (inputs
6713 `(("ghc-random" ,ghc-random)
6714 ("ghc-test-framework" ,ghc-test-framework)
6715 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
6716 ("ghc-quickcheck" ,ghc-quickcheck)
6717 ("ghc-hunit" ,ghc-hunit)))
6718 (home-page "https://github.com/kolmodin/binary")
6719 (synopsis
6720 "Binary serialisation for Haskell values using lazy ByteStrings")
6721 (description
6722 "Efficient, pure binary serialisation using lazy ByteStrings. Haskell values
6723 may be encoded to and from binary formats, written to disk as binary, or sent over
6724 the network. The format used can be automatically generated, or you can choose to
6725 implement a custom format if needed. Serialisation speeds of over 1 G\\/sec have
6726 been observed, so this library should be suitable for high performance scenarios.")
6727 (license license:bsd-3)))
6728
6729 (define-public ghc-cryptohash
6730 (package
6731 (name "ghc-cryptohash")
6732 (version "0.11.9")
6733 (source
6734 (origin
6735 (method url-fetch)
6736 (uri (string-append
6737 "https://hackage.haskell.org/package/cryptohash/cryptohash-"
6738 version ".tar.gz"))
6739 (sha256
6740 (base32
6741 "1yr2iyb779znj79j3fq4ky8l1y8a600a2x1fx9p5pmpwq5zq93y2"))))
6742 (build-system haskell-build-system)
6743 (inputs
6744 `(("ghc-byteable" ,ghc-byteable)
6745 ("ghc-cryptonite" ,ghc-cryptonite)
6746 ("ghc-memory" ,ghc-memory)
6747 ("ghc-hunit" ,ghc-hunit)
6748 ("ghc-quickcheck" ,ghc-quickcheck)
6749 ("ghc-tasty" ,ghc-tasty)
6750 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6751 ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
6752 (home-page "http://github.com/vincenthz/hs-cryptohash")
6753 (synopsis "Collection of cryptographic hashes in Haskell")
6754 (description
6755 "A collection of crypto hashes, with a practical incremental and one-pass,
6756 pure APIs, with performance close to the fastest implementations available in
6757 other languages. The implementations are made in C with a haskell FFI wrapper
6758 that hides the C implementation.")
6759 (license license:bsd-3)))
6760
6761 (define-public ghc-data-ordlist
6762 (package
6763 (name "ghc-data-ordlist")
6764 (version "0.4.7.0")
6765 (source
6766 (origin
6767 (method url-fetch)
6768 (uri (string-append
6769 "https://hackage.haskell.org/package/data-ordlist/data-ordlist-"
6770 version ".tar.gz"))
6771 (sha256
6772 (base32
6773 "03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g"))))
6774 (build-system haskell-build-system)
6775 (home-page "http://hackage.haskell.org/package/data-ordlist")
6776 (synopsis "Set and bag operations on ordered lists")
6777 (description
6778 "This module provides set and multiset operations on ordered lists.")
6779 (license license:bsd-3)))
6780
6781 (define-public ghc-haskeline
6782 (package
6783 (name "ghc-haskeline")
6784 (version "0.7.2.3")
6785 (source
6786 (origin
6787 (method url-fetch)
6788 (uri (string-append
6789 "https://hackage.haskell.org/package/haskeline/haskeline-"
6790 version ".tar.gz"))
6791 (sha256
6792 (base32
6793 "09wd6sxgn65xxpk7dhy1cg3ywlbk0ccqq7xylycwk4zazy3gjgkd"))))
6794 (build-system haskell-build-system)
6795 (inputs
6796 `(("ncurses" ,ncurses)))
6797 (arguments
6798 `(#:configure-flags (list "-fterminfo")))
6799 (home-page "https://github.com/judah/haskeline")
6800 (synopsis "Command-line interface for user input")
6801 (description
6802 "Haskeline provides a user interface for line input in command-line
6803 programs. This library is similar in purpose to readline, but since it
6804 is written in Haskell it is (hopefully) more easily used in other Haskell
6805 programs.")
6806 (license license:bsd-3)))
6807
6808 (define-public ghc-regex-applicative
6809 (package
6810 (name "ghc-regex-applicative")
6811 (version "0.3.3")
6812 (source
6813 (origin
6814 (method url-fetch)
6815 (uri (string-append
6816 "https://hackage.haskell.org/package/regex-applicative/"
6817 "regex-applicative-" version ".tar.gz"))
6818 (sha256
6819 (base32
6820 "1riv7jqf26lbv4rm54sd6mrx8xdh4dvh4xbzymzdfdw13k6a4nb6"))))
6821 (build-system haskell-build-system)
6822 (inputs
6823 `(("ghc-smallcheck" ,ghc-smallcheck)
6824 ("ghc-tasty" ,ghc-tasty)
6825 ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
6826 ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
6827 (home-page "https://github.com/feuerbach/regex-applicative")
6828 (synopsis "Regex-based parsing with applicative interface")
6829 (description
6830 "@code{regex-applicative} is a Haskell library for parsing using
6831 regular expressions. Parsers can be built using Applicative interface.")
6832 (license license:expat)))
6833
6834 (define-public ghc-regex-tdfa
6835 (package
6836 (name "ghc-regex-tdfa")
6837 (version "1.2.2")
6838 (source
6839 (origin
6840 (method url-fetch)
6841 (uri (string-append
6842 "https://hackage.haskell.org/package/regex-tdfa/regex-tdfa-"
6843 version ".tar.gz"))
6844 (sha256
6845 (base32
6846 "0f8x8wyr6m21g8dnxvnvalz5bsq37l125l6qhs0fscbvprsxc4nb"))))
6847 (build-system haskell-build-system)
6848 (inputs
6849 `(("ghc-mtl" ,ghc-mtl)
6850 ("ghc-parsec" ,ghc-parsec)
6851 ("ghc-regex-base" ,ghc-regex-base)))
6852 (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
6853 (synopsis "POSIX extended regular expressions in Haskell.")
6854 (description
6855 "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
6856 extended regular expressions. It is a \"tagged\" DFA regex engine. It is
6857 inspired by libtre.")
6858 (license license:bsd-3)))
6859
6860 (define-public ghc-regex-compat-tdfa
6861 (package
6862 (name "ghc-regex-compat-tdfa")
6863 (version "0.95.1.4")
6864 (source
6865 (origin
6866 (method url-fetch)
6867 (uri (string-append
6868 "https://hackage.haskell.org/package/regex-compat-tdfa/regex-compat-tdfa-"
6869 version ".tar.gz"))
6870 (sha256
6871 (base32
6872 "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
6873 (build-system haskell-build-system)
6874 (inputs
6875 `(("ghc-regex-base" ,ghc-regex-base)
6876 ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
6877 (home-page "http://hub.darcs.net/shelarcy/regex-compat-tdfa")
6878 (synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
6879 (description
6880 "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
6881 @code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
6882 This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
6883 this problem.")
6884 (license license:bsd-3)))
6885
6886 (define-public ghc-tasty-th
6887 (package
6888 (name "ghc-tasty-th")
6889 (version "0.1.4")
6890 (source
6891 (origin
6892 (method url-fetch)
6893 (uri (string-append
6894 "https://hackage.haskell.org/package/tasty-th/tasty-th-"
6895 version ".tar.gz"))
6896 (sha256
6897 (base32
6898 "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
6899 (build-system haskell-build-system)
6900 (inputs
6901 `(("ghc-tasty" ,ghc-tasty)))
6902 (home-page "http://github.com/bennofs/tasty-th")
6903 (synopsis "Automatically generate tasty TestTrees")
6904 (description
6905 "Tasty-th automatically generates tasty TestTrees from functions of the
6906 current module, using TemplateHaskell. This is a fork the original
6907 test-framework-th package, modified to work with tasty instead of
6908 test-framework.")
6909 (license license:bsd-3)))
6910
6911 (define-public ghc-sandi
6912 (package
6913 (name "ghc-sandi")
6914 (version "0.4.0") ; darcs-2.12.4 needs == 0.4.*
6915 (source
6916 (origin
6917 (method url-fetch)
6918 (uri (string-append
6919 "https://hackage.haskell.org/package/sandi/sandi-"
6920 version ".tar.gz"))
6921 (sha256
6922 (base32
6923 "1smf3bq44qni4zbgxpw7cy7b9g95fbrr73j8njjf6139naj9bj20"))))
6924 (build-system haskell-build-system)
6925 (inputs
6926 `(("ghc-stringsearch" ,ghc-stringsearch)
6927 ("ghc-conduit" ,ghc-conduit)
6928 ("ghc-exceptions" ,ghc-exceptions)
6929 ("ghc-hunit" ,ghc-hunit)
6930 ("ghc-tasty" ,ghc-tasty)
6931 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
6932 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6933 ("ghc-tasty-th" ,ghc-tasty-th)))
6934 (home-page "http://hackage.haskell.org/package/sandi")
6935 (synopsis "Data encoding library")
6936 (description "Reasonably fast data encoding library.")
6937 (license license:bsd-3)))
6938
6939 (define-public ghc-bytestring-handle
6940 (package
6941 (name "ghc-bytestring-handle")
6942 (version "0.1.0.4")
6943 (source
6944 (origin
6945 (method url-fetch)
6946 (uri (string-append
6947 "https://hackage.haskell.org/package/bytestring-handle/bytestring-handle-"
6948 version ".tar.gz"))
6949 (sha256
6950 (base32
6951 "0q5yzx90ad9w7qvaix05bynxwlsbqjrgfc4hqb355ibf991wd0rh"))))
6952 (build-system haskell-build-system)
6953 (inputs
6954 `(("ghc-quickcheck" ,ghc-quickcheck)
6955 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
6956 ("ghc-hunit" ,ghc-hunit)
6957 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
6958 ("ghc-test-framework" ,ghc-test-framework)))
6959 (home-page "http://hub.darcs.net/ganesh/bytestring-handle")
6960 (synopsis "ByteString-backed Handles")
6961 (description "ByteString-backed Handles") ; There is no description
6962 (license license:bsd-3)))
6963
6964 (define-public ghc-tar
6965 (package
6966 (name "ghc-tar")
6967 (version "0.5.0.3")
6968 (source
6969 (origin
6970 (method url-fetch)
6971 (uri (string-append
6972 "https://hackage.haskell.org/package/tar/tar-"
6973 version ".tar.gz"))
6974 (sha256
6975 (base32
6976 "18qq94j9bm91iswnxq2dm5dws5c7wm4k01q2rpf8py35cf3svnfq"))))
6977 (build-system haskell-build-system)
6978 (inputs
6979 `(("ghc-bytestring-handle" ,ghc-bytestring-handle)
6980 ("ghc-quickcheck" ,ghc-quickcheck)
6981 ("ghc-tasty" ,ghc-tasty)
6982 ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
6983 ("ghc-array" ,ghc-array)))
6984 (home-page "http://hackage.haskell.org/package/tar")
6985 (synopsis "Reading, writing and manipulating \".tar\" archive files")
6986 (description
6987 "This library is for working with \\\"@.tar@\\\" archive files.
6988 It can read and write a range of common variations of the tar archive format
6989 including V7, POSIX USTAR and GNU formats. It provides support for packing and
6990 unpacking portable archives. This makes it suitable for distribution but not
6991 backup because details like file ownership and exact permissions are not
6992 preserved. It also provides features for random access to archive content using
6993 an index.")
6994 (license license:bsd-3)))
6995
6996 (define-public ghc-transformers
6997 (package
6998 (name "ghc-transformers")
6999 (version "0.5.2.0")
7000 (source
7001 (origin
7002 (method url-fetch)
7003 (uri (string-append
7004 "https://hackage.haskell.org/package/transformers/transformers-"
7005 version ".tar.gz"))
7006 (sha256
7007 (base32
7008 "1qkhi8ssf8c4jnmrw9dzym3igqbzq7h48iisaykdfzdsm09qfh3c"))))
7009 (build-system haskell-build-system)
7010 (home-page "http://hackage.haskell.org/package/transformers")
7011 (synopsis "Concrete functor and monad transformers")
7012 (description
7013 "A portable library of functor and monad transformers, inspired by the paper
7014 'Functional Programming with Overloading and Higher-Order Polymorphism',
7015 by Mark P Jones. This package contains the monad transformer class and IO monad class,
7016 concrete functor and monad transformers, each with associated operations and functions
7017 to lift operations associated with other transformers. The package can be used on
7018 its own in portable Haskell code, in which case operations need to be manually lifted
7019 through transformer stacks. Alternatively, it can be used with the
7020 non-portable monad classes in the @code{mtl} or @code{monads-tf} packages,
7021 which automatically lift operations introduced by monad transformers through
7022 other transformers.")
7023 (license license:bsd-3)))
7024
7025 ;; darcs-2.12.0 requires transformers-0.4.2.0
7026 (define-public ghc-transformers-0.4.2.0
7027 (package
7028 (inherit ghc-transformers)
7029 (version "0.4.2.0")
7030 (source (origin
7031 (method url-fetch)
7032 (uri (string-append "https://hackage.haskell.org/package/transformers/"
7033 "transformers-" version ".tar.gz"))
7034 (sha256
7035 (base32
7036 "0a364zfcm17mhpy0c4ms2j88sys4yvgd6071qsgk93la2wjm8mkr"))))))
7037
7038 (define-public ghc-findbin
7039 (package
7040 (name "ghc-findbin")
7041 (version "0.0.5")
7042 (source
7043 (origin
7044 (method url-fetch)
7045 (uri (string-append
7046 "https://hackage.haskell.org/package/FindBin/FindBin-"
7047 version ".tar.gz"))
7048 (sha256
7049 (base32
7050 "197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717"))))
7051 (build-system haskell-build-system)
7052 (home-page "https://github.com/audreyt/findbin")
7053 (synopsis "Get the absolute path of the running program")
7054 (description
7055 "This module locates the full directory of the running program, to allow
7056 the use of paths relative to it. FindBin supports invocation of Haskell
7057 programs via \"ghci\", via \"runhaskell/runghc\", as well as compiled as
7058 an executable.")
7059 (license license:bsd-3)))
7060
7061 (define-public ghc-patience
7062 (package
7063 (name "ghc-patience")
7064 (version "0.1.1")
7065 (source
7066 (origin
7067 (method url-fetch)
7068 (uri (string-append
7069 "https://hackage.haskell.org/package/patience/patience-"
7070 version ".tar.gz"))
7071 (sha256
7072 (base32
7073 "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
7074 (build-system haskell-build-system)
7075 (home-page "http://hackage.haskell.org/package/patience")
7076 (synopsis "Patience diff and longest increasing subsequence")
7077 (description
7078 "This library implements the 'patience diff' algorithm, as well as the
7079 patience algorithm for the longest increasing subsequence problem.
7080 Patience diff computes the difference between two lists, for example the lines
7081 of two versions of a source file. It provides a good balance between
7082 performance, nice output for humans, and simplicity of implementation.")
7083 (license license:bsd-3)))
7084
7085 (define-public ghc-monads-tf
7086 (package
7087 (name "ghc-monads-tf")
7088 (version "0.1.0.3")
7089 (source
7090 (origin
7091 (method url-fetch)
7092 (uri (string-append
7093 "https://hackage.haskell.org/package/monads-tf/monads-tf-"
7094 version ".tar.gz"))
7095 (sha256
7096 (base32
7097 "1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
7098 (build-system haskell-build-system)
7099 (home-page "http://hackage.haskell.org/package/monads-tf")
7100 (synopsis "Monad classes, using type families")
7101 (description
7102 "Monad classes using type families, with instances for various monad transformers,
7103 inspired by the paper 'Functional Programming with Overloading and Higher-Order
7104 Polymorphism', by Mark P Jones. This package is almost a compatible replacement for
7105 the @code{mtl-tf} package.")
7106 (license license:bsd-3)))
7107
7108 ;; Do not use this. Bytestring is a standard library and always included.
7109 (define-public ghc-bytestring
7110 (package
7111 (name "ghc-bytestring")
7112 (version "0.10.8.1")
7113 (source
7114 (origin
7115 (method url-fetch)
7116 (uri (string-append
7117 "https://hackage.haskell.org/package/bytestring/bytestring-"
7118 version ".tar.gz"))
7119 (sha256
7120 (base32
7121 "16zwb1p83z7vc5wlhvknpy80b5a2jxc5awx67rk52qnp9idmyq9d"))))
7122 (build-system haskell-build-system)
7123 (inputs
7124 `(("ghc-random" ,ghc-random)
7125 ("ghc-test-framework" ,ghc-test-framework)
7126 ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
7127 ("ghc-quickcheck" ,ghc-quickcheck)
7128 ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
7129 ("ghc-hunit" ,ghc-hunit)
7130 ("ghc-byteorder" ,ghc-byteorder)
7131 ("ghc-dlist" ,ghc-dlist)
7132 ("ghc-mtl" ,ghc-mtl)))
7133 (arguments
7134 `(#:tests? #f)) ; Test number two becomes non-responsive for 20+ minutes
7135 (home-page "https://github.com/haskell/bytestring")
7136 (synopsis "Fast, compact, strict and lazy byte strings with a list interface")
7137 (description
7138 "An efficient compact, immutable byte string type (both strict and lazy)
7139 suitable for binary or 8-bit character data. The 'ByteString' type represents
7140 sequences of bytes or 8-bit characters. It is suitable for high performance use,
7141 both in terms of large data quantities, or high speed requirements. The 'ByteString'
7142 functions follow the same style as ordinary lists, so it is easy to convert code
7143 from using 'String' to 'ByteString'.")
7144 (license license:bsd-3)))
7145
7146 (define-public ghc-colour
7147 (package
7148 (name "ghc-colour")
7149 (version "2.3.3")
7150 (source
7151 (origin
7152 (method url-fetch)
7153 (uri (string-append
7154 "https://hackage.haskell.org/package/colour/colour-"
7155 version ".tar.gz"))
7156 (sha256
7157 (base32
7158 "1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd"))))
7159 (build-system haskell-build-system)
7160 (home-page "http://www.haskell.org/haskellwiki/Colour")
7161 (synopsis "Model for human colour perception")
7162 (description
7163 "This package provides a data type for colours and transparency.
7164 Colours can be blended and composed. Various colour spaces are
7165 supported. A module of colour names (\"Data.Colour.Names\") is provided.")
7166 (license license:expat)))
7167
7168 (define-public ghc-directory
7169 (package
7170 (name "ghc-directory")
7171 (version "1.2.7.0")
7172 (source
7173 (origin
7174 (method url-fetch)
7175 (uri (string-append
7176 "https://hackage.haskell.org/package/directory/directory-"
7177 version ".tar.gz"))
7178 (sha256
7179 (base32
7180 "0h3hrqskadmbigaxbz2k5xxjjjlmfaq2zdn2g7jh1wv9k6yrxraa"))))
7181 (build-system haskell-build-system)
7182 (home-page "http://hackage.haskell.org/package/directory")
7183 (synopsis "Platform-agnostic library for filesystem operations")
7184 (description
7185 "This library provides a basic set of operations for manipulating
7186 files and directories in a portable way.")
7187 (license license:bsd-3)))
7188
7189 ;; Do not use this as an input. It is part of GHC.
7190 (define-public ghc-process
7191 (package
7192 (name "ghc-process")
7193 (version "1.4.2.0")
7194 (source
7195 (origin
7196 (method url-fetch)
7197 (uri (string-append
7198 "https://hackage.haskell.org/package/process/process-"
7199 version ".tar.gz"))
7200 (sha256
7201 (base32
7202 "1v1bav5isqxq9fc4lw714x94qbfsjbm2nn12kjp69r1ql8jaaaqw"))))
7203 (build-system haskell-build-system)
7204 (arguments
7205 `(#:phases
7206 (modify-phases %standard-phases
7207 (add-after 'unpack 'patch-reference-to-/bin/sh
7208 (lambda _
7209 (substitute* "System/Process/Posix.hs"
7210 (("/bin/sh") (which "sh")))
7211 #t)))))
7212 (home-page "http://hackage.haskell.org/package/process")
7213 (synopsis "System process libraries")
7214 (description
7215 "This package contains libraries for dealing with system processes.")
7216 (license license:bsd-3)))
7217
7218 (define-public ghc-wl-pprint-text
7219 (package
7220 (name "ghc-wl-pprint-text")
7221 (version "1.1.0.4")
7222 (source
7223 (origin
7224 (method url-fetch)
7225 (uri (string-append
7226 "https://hackage.haskell.org/package/wl-pprint-text/wl-pprint-text-"
7227 version ".tar.gz"))
7228 (sha256
7229 (base32
7230 "1xgizzimfw17mpmw2afvmnvyag976j8ggn7k5r564rkw9f0m6bgz"))))
7231 (build-system haskell-build-system)
7232 (inputs
7233 `(("ghc-text" ,ghc-text)))
7234 (home-page "http://hackage.haskell.org/package/wl-pprint-text")
7235 (synopsis "Wadler/Leijen Pretty Printer for Text values")
7236 (description
7237 "A clone of wl-pprint for use with the text library.")
7238 (license license:bsd-3)))
7239
7240 (define-public ghc-fgl-arbitrary
7241 (package
7242 (name "ghc-fgl-arbitrary")
7243 (version "0.2.0.2")
7244 (source
7245 (origin
7246 (method url-fetch)
7247 (uri (string-append
7248 "https://hackage.haskell.org/package/fgl-arbitrary/fgl-arbitrary-"
7249 version ".tar.gz"))
7250 (sha256
7251 (base32
7252 "12qbsla4vivffris6y3gj29vrafkpyazqdbdy2m55nggypqpf7ah"))))
7253 (build-system haskell-build-system)
7254 (inputs
7255 `(("ghc-fgl" ,ghc-fgl)
7256 ("ghc-quickcheck" ,ghc-quickcheck)
7257 ("ghc-hspec" ,ghc-hspec)))
7258 (home-page "http://hackage.haskell.org/package/fgl-arbitrary")
7259 (synopsis "QuickCheck support for fgl")
7260 (description
7261 "Provides Arbitrary instances for fgl graphs to avoid adding a
7262 QuickCheck dependency for fgl whilst still making the instances
7263 available to others. Also available are non-fgl-specific functions
7264 for generating graph-like data structures.")
7265 (license license:bsd-3)))
7266
7267 (define-public ghc-graphviz
7268 (package
7269 (name "ghc-graphviz")
7270 (version "2999.18.1.2")
7271 (source (origin
7272 (method url-fetch)
7273 (uri (string-append "https://hackage.haskell.org/package/"
7274 "graphviz/graphviz-" version ".tar.gz"))
7275 (sha256
7276 (base32
7277 "1z453is01v0rnxlv6xx4iyaqv5vrp3bpz829mpv1a341sck2135h"))))
7278 (build-system haskell-build-system)
7279 (inputs
7280 `(("ghc-quickcheck" ,ghc-quickcheck)
7281 ("ghc-colour" ,ghc-colour)
7282 ("ghc-dlist" ,ghc-dlist)
7283 ("ghc-fgl" ,ghc-fgl)
7284 ("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
7285 ("ghc-polyparse" ,ghc-polyparse)
7286 ("ghc-temporary" ,ghc-temporary)
7287 ("ghc-text" ,ghc-text)
7288 ("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
7289 (home-page "https://hackage.haskell.org/package/graphviz")
7290 (synopsis "Bindings to Graphviz for graph visualisation")
7291 (description
7292 "This library provides bindings for the Dot language used by
7293 the @uref{http://graphviz.org/, Graphviz} suite of programs for
7294 visualising graphs, as well as functions to call those programs.
7295 Main features of the graphviz library include:
7296
7297 @enumerate
7298 @item Almost complete coverage of all Graphviz attributes and syntax
7299 @item Support for specifying clusters
7300 @item The ability to use a custom node type
7301 @item Functions for running a Graphviz layout tool with all specified output types
7302 @item Generate and parse Dot code with two options: strict and liberal
7303 @item Functions to convert FGL graphs and other graph-like data structures
7304 @item Round-trip support for passing an FGL graph through Graphviz to augment node
7305 and edge labels with positional information, etc.
7306 @end enumerate\n")
7307 (license license:bsd-3)))
7308
7309 (define-public ghc-array
7310 (package
7311 (name "ghc-array")
7312 (version "0.5.1.1")
7313 (source
7314 (origin
7315 (method url-fetch)
7316 (uri (string-append
7317 "https://hackage.haskell.org/package/array/array-"
7318 version ".tar.gz"))
7319 (sha256
7320 (base32
7321 "08r2rq4blvc737mrg3xhlwiw13jmsz5dlf2fd0ghb9cdaxc6kjc9"))))
7322 (build-system haskell-build-system)
7323 (home-page
7324 "http://hackage.haskell.org/package/array")
7325 (synopsis "Mutable and immutable arrays")
7326 (description
7327 "In addition to providing the @code{Data.Array} module, this package also defines
7328 the classes @code{IArray} of immutable arrays and @code{MArray} of arrays mutable
7329 within appropriate monads, as well as some instances of these classes.")
7330 (license license:bsd-3)))
7331
7332 (define-public ghc-constraints
7333 (package
7334 (name "ghc-constraints")
7335 (version "0.8")
7336 (source
7337 (origin
7338 (method url-fetch)
7339 (uri (string-append
7340 "https://hackage.haskell.org/package/constraints/constraints-"
7341 version ".tar.gz"))
7342 (sha256
7343 (base32
7344 "120mmv9rwbahslisc1z8zx9lw7v6hl5fzid4l0hiy5as6ijqgl2c"))))
7345 (build-system haskell-build-system)
7346 (inputs
7347 `(("ghc-hashable" ,ghc-hashable)
7348 ("ghc-mtl" ,ghc-mtl)
7349 ("ghc-transformers-compat" ,ghc-transformers-compat)))
7350 (home-page "http://github.com/ekmett/constraints/")
7351 (synopsis "Constraint manipulation")
7352 (description
7353 "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
7354 They stopped crashing the compiler in GHC 7.6. This package provides
7355 a vocabulary for working with them.")
7356 (license license:bsd-3)))
7357
7358 (define-public ghc-lifted-async
7359 (package
7360 (name "ghc-lifted-async")
7361 (version "0.9.0")
7362 (source
7363 (origin
7364 (method url-fetch)
7365 (uri (string-append
7366 "https://hackage.haskell.org/package/lifted-async/lifted-async-"
7367 version ".tar.gz"))
7368 (sha256
7369 (base32
7370 "00fnwfcnc6niq9jbbb9rap9rkdgv5qhcglwanzc5fi8834j94c1r"))))
7371 (build-system haskell-build-system)
7372 (inputs
7373 `(("ghc-async" ,ghc-async)
7374 ("ghc-lifted-base" ,ghc-lifted-base)
7375 ("ghc-transformers-base" ,ghc-transformers-base)
7376 ("ghc-monad-control" ,ghc-monad-control)
7377 ("ghc-constraints" ,ghc-constraints)
7378 ("ghc-hunit" ,ghc-hunit)
7379 ("ghc-mtl" ,ghc-mtl)
7380 ("ghc-tasty" ,ghc-tasty)
7381 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
7382 ("ghc-tasty-th" ,ghc-tasty-th)))
7383 (home-page "https://github.com/maoe/lifted-async")
7384 (synopsis "Run lifted IO operations asynchronously and wait for their results")
7385 (description
7386 "This package provides IO operations from @code{async} package lifted to any
7387 instance of @code{MonadBase} or @code{MonadBaseControl}.")
7388 (license license:bsd-3)))
7389
7390 ;; Ghc-shelly depends on ghc-system-filepath and ghc-system-fileio, who in turn depend on
7391 ;; ghc-chell and ghc-chell-quickcheck for the test phase. Ghc-chell depends on ghc-options
7392 ;; which depends on ghc-chell and ghc-chell-quickcheck.
7393 ;; Therefore we bootstrap it with tests disabled.
7394 (define ghc-system-filepath-bootstrap
7395 (package
7396 (name "ghc-system-filepath-bootstrap")
7397 (version "0.4.13.4")
7398 (source
7399 (origin
7400 (method url-fetch)
7401 (uri (string-append
7402 "https://hackage.haskell.org/package/system-filepath/system-filepath-"
7403 version ".tar.gz"))
7404 (sha256
7405 (base32
7406 "1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l"))))
7407 (build-system haskell-build-system)
7408 (arguments
7409 `(#:tests? #f))
7410 (inputs
7411 `(("ghc-text" ,ghc-text)
7412 ("ghc-quickcheck" ,ghc-quickcheck)))
7413 (home-page "https://github.com/fpco/haskell-filesystem")
7414 (synopsis "High-level, byte-based file and directory path manipulations")
7415 (description
7416 "Provides a FilePath datatype and utility functions for operating on it.
7417 Unlike the filepath package, this package does not simply reuse String,
7418 increasing type safety.")
7419 (license license:expat)))
7420
7421 ;; See ghc-system-filepath-bootstrap. In addition this package depends on
7422 ;; ghc-system-filepath.
7423 (define ghc-system-fileio-bootstrap
7424 (package
7425 (name "ghc-system-fileio-bootstrap")
7426 (version "0.3.16.3")
7427 (source
7428 (origin
7429 (method url-fetch)
7430 (uri (string-append
7431 "https://hackage.haskell.org/package/system-fileio/system-fileio-"
7432 version ".tar.gz"))
7433 (sha256
7434 (base32
7435 "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
7436 (build-system haskell-build-system)
7437 (arguments
7438 `(#:tests? #f))
7439 (inputs
7440 `(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
7441 ("ghc-text" ,ghc-text)
7442 ("ghc-temporary" ,ghc-temporary)))
7443 (home-page "https://github.com/fpco/haskell-filesystem")
7444 (synopsis "Consistent filesystem interaction across GHC versions")
7445 (description
7446 "This is a small wrapper around the directory, unix, and Win32 packages,
7447 for use with system-filepath. It provides a consistent API to the various
7448 versions of these packages distributed with different versions of GHC.
7449 In particular, this library supports working with POSIX files that have paths
7450 which can't be decoded in the current locale encoding.")
7451 (license license:expat)))
7452
7453 (define-public ghc-shelly
7454 (package
7455 (name "ghc-shelly")
7456 (version "1.6.8")
7457 (source
7458 (origin
7459 (method url-fetch)
7460 (uri (string-append
7461 "https://hackage.haskell.org/package/shelly/shelly-"
7462 version ".tar.gz"))
7463 (sha256
7464 (base32
7465 "0bg1pj5bhswfgwfgz66xr82i8cmjgrnx5ljvjy37052zxb82imnk"))))
7466 (build-system haskell-build-system)
7467 (inputs
7468 `(("ghc-mtl" ,ghc-mtl)
7469 ("ghc-unix-compat" ,ghc-unix-compat)
7470 ("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
7471 ("ghc-system-fileio-bootstrap" ,ghc-system-fileio-bootstrap)
7472 ("ghc-monad-control" ,ghc-monad-control)
7473 ("ghc-lifted-base" ,ghc-lifted-base)
7474 ("ghc-lifted-async" ,ghc-lifted-async)
7475 ("ghc-exceptions" ,ghc-exceptions)
7476 ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
7477 ("ghc-text" ,ghc-text)
7478 ("ghc-async" ,ghc-async)
7479 ("ghc-transformers-base" ,ghc-transformers-base)
7480 ("ghc-hunit" ,ghc-hunit)
7481 ("ghc-hspec" ,ghc-hspec)))
7482 (home-page "https://github.com/yesodweb/Shelly.hs")
7483 (synopsis "Shell-like (systems) programming in Haskell")
7484 (description
7485 "Shelly provides convenient systems programming in Haskell, similar in
7486 spirit to POSIX shells. Shelly is originally forked from the Shellish package.")
7487 (license license:bsd-3)))
7488
7489 ;; See ghc-system-filepath-bootstrap, chell and chell-quickcheck are required for tests.
7490 (define ghc-options-bootstrap
7491 (package
7492 (name "ghc-options-bootstrap")
7493 (version "1.2.1.1")
7494 (source
7495 (origin
7496 (method url-fetch)
7497 (uri (string-append
7498 "https://hackage.haskell.org/package/options/options-"
7499 version ".tar.gz"))
7500 (sha256
7501 (base32
7502 "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
7503 (build-system haskell-build-system)
7504 (arguments
7505 `(#:tests? #f))
7506 (inputs
7507 `(("ghc-monads-tf" ,ghc-monads-tf)))
7508 (home-page "https://john-millikin.com/software/haskell-options/")
7509 (synopsis "Powerful and easy-to-use command-line option parser")
7510 (description
7511 "The @code{options} package lets library and application developers
7512 easily work with command-line options.")
7513 (license license:expat)))
7514
7515 (define-public ghc-chell
7516 (package
7517 (name "ghc-chell")
7518 (version "0.4.0.1")
7519 (source
7520 (origin
7521 (method url-fetch)
7522 (uri (string-append
7523 "https://hackage.haskell.org/package/chell/chell-"
7524 version ".tar.gz"))
7525 (sha256
7526 (base32
7527 "0lb95abzxl4a87nfqxsxpb3a39pd52cci43hcvj8615hyhqvs2jz"))))
7528 (build-system haskell-build-system)
7529 (inputs
7530 `(("ghc-options-bootstrap" ,ghc-options-bootstrap)
7531 ("ghc-patience" ,ghc-patience)
7532 ("ghc-random" ,ghc-random)
7533 ("ghc-text" ,ghc-text)
7534 ("ghc-ansi-terminal" ,ghc-ansi-terminal)))
7535 (home-page "https://john-millikin.com/software/chell/")
7536 (synopsis "Simple and intuitive library for automated testing")
7537 (description
7538 "Chell is a simple and intuitive library for automated testing.
7539 It natively supports assertion-based testing, and can use companion
7540 libraries such as @code{chell-quickcheck} to support more complex
7541 testing strategies.")
7542 (license license:expat)))
7543
7544 (define ghc-chell-quickcheck-bootstrap
7545 (package
7546 (name "ghc-chell-quickcheck-bootstrap")
7547 (version "0.2.5")
7548 (source
7549 (origin
7550 (method url-fetch)
7551 (uri (string-append
7552 "https://hackage.haskell.org/package/chell-quickcheck/chell-quickcheck-"
7553 version ".tar.gz"))
7554 (sha256
7555 (base32
7556 "02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs"))))
7557 (build-system haskell-build-system)
7558 (inputs
7559 `(("ghc-chell" ,ghc-chell)
7560 ("ghc-random" ,ghc-random)
7561 ("ghc-quickcheck" ,ghc-quickcheck)))
7562 (arguments
7563 `(#:tests? #f))
7564 (home-page "https://john-millikin.com/software/chell/")
7565 (synopsis "QuickCheck support for the Chell testing library")
7566 (description "More complex tests for @code{chell}.")
7567 (license license:expat)))
7568
7569 (define-public ghc-chell-quickcheck
7570 (package
7571 (name "ghc-chell-quickcheck")
7572 (version "0.2.5")
7573 (source
7574 (origin
7575 (method url-fetch)
7576 (uri (string-append
7577 "https://hackage.haskell.org/package/chell-quickcheck/chell-quickcheck-"
7578 version ".tar.gz"))
7579 (sha256
7580 (base32
7581 "02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs"))))
7582 (build-system haskell-build-system)
7583 (inputs
7584 `(("ghc-chell" ,ghc-chell)
7585 ("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap)
7586 ("ghc-random" ,ghc-random)
7587 ("ghc-quickcheck" ,ghc-quickcheck)))
7588 (home-page "https://john-millikin.com/software/chell/")
7589 (synopsis "QuickCheck support for the Chell testing library")
7590 (description "More complex tests for @code{chell}.")
7591 (license license:expat)))
7592
7593 (define-public ghc-options
7594 (package
7595 (name "ghc-options")
7596 (version "1.2.1.1")
7597 (source
7598 (origin
7599 (method url-fetch)
7600 (uri (string-append
7601 "https://hackage.haskell.org/package/options/options-"
7602 version ".tar.gz"))
7603 (sha256
7604 (base32
7605 "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
7606 (build-system haskell-build-system)
7607 (inputs
7608 `(("ghc-monads-tf" ,ghc-monads-tf)
7609 ("ghc-chell" ,ghc-chell)
7610 ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)))
7611 (home-page "https://john-millikin.com/software/haskell-options/")
7612 (synopsis "Powerful and easy-to-use command-line option parser")
7613 (description
7614 "The @code{options} package lets library and application developers
7615 easily work with command-line options.")
7616 (license license:expat)))
7617
7618 (define-public ghc-system-filepath
7619 (package
7620 (name "ghc-system-filepath")
7621 (version "0.4.13.4")
7622 (source
7623 (origin
7624 (method url-fetch)
7625 (uri (string-append
7626 "https://hackage.haskell.org/package/system-filepath/system-filepath-"
7627 version ".tar.gz"))
7628 (sha256
7629 (base32
7630 "1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l"))))
7631 (build-system haskell-build-system)
7632 (inputs
7633 `(("ghc-text" ,ghc-text)
7634 ("ghc-chell" ,ghc-chell)
7635 ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
7636 ("ghc-quickcheck" ,ghc-quickcheck)))
7637 (home-page "https://github.com/fpco/haskell-filesystem")
7638 (synopsis "High-level, byte-based file and directory path manipulations")
7639 (description
7640 "Provides a FilePath datatype and utility functions for operating on it.
7641 Unlike the filepath package, this package does not simply reuse String,
7642 increasing type safety.")
7643 (license license:expat)))
7644
7645 (define-public ghc-system-fileio
7646 (package
7647 (name "ghc-system-fileio")
7648 (version "0.3.16.3")
7649 (source
7650 (origin
7651 (method url-fetch)
7652 (uri (string-append
7653 "https://hackage.haskell.org/package/system-fileio/system-fileio-"
7654 version ".tar.gz"))
7655 (sha256
7656 (base32
7657 "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
7658 (build-system haskell-build-system)
7659 (inputs
7660 `(("ghc-system-filepath" ,ghc-system-filepath)
7661 ("ghc-text" ,ghc-text)
7662 ("ghc-chell" ,ghc-chell)
7663 ("ghc-temporary" ,ghc-temporary)))
7664 (home-page "https://github.com/fpco/haskell-filesystem")
7665 (synopsis "Consistent filesystem interaction across GHC versions")
7666 (description
7667 "This is a small wrapper around the directory, unix, and Win32 packages,
7668 for use with system-filepath. It provides a consistent API to the various
7669 versions of these packages distributed with different versions of GHC.
7670 In particular, this library supports working with POSIX files that have paths
7671 which can't be decoded in the current locale encoding.")
7672 (license license:expat)))
7673
7674 (define-public ghc-storable-complex
7675 (package
7676 (name "ghc-storable-complex")
7677 (version "0.2.2")
7678 (source
7679 (origin
7680 (method url-fetch)
7681 (uri (string-append
7682 "http://hackage.haskell.org/package/storable-complex/storable-complex-"
7683 version ".tar.gz"))
7684 (sha256
7685 (base32 "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb"))))
7686 (build-system haskell-build-system)
7687 (home-page "https://github.com/cartazio/storable-complex")
7688 (synopsis "Haskell Storable instance for Complex")
7689 (description "This package provides a Haskell library including a
7690 Storable instance for Complex which is binary compatible with C99, C++
7691 and Fortran complex data types.")
7692 (license license:bsd-3)))
7693
7694 (define-public ghc-hmatrix
7695 (package
7696 (name "ghc-hmatrix")
7697 (version "0.17.0.2")
7698 (source
7699 (origin
7700 (method url-fetch)
7701 (uri (string-append
7702 "http://hackage.haskell.org/package/hmatrix/hmatrix-"
7703 version ".tar.gz"))
7704 (sha256
7705 (base32 "1fgsrh2y9y971pzrd3767rg97bjr1ghpdvwmn1nn65s90rc9bv98"))))
7706 (build-system haskell-build-system)
7707 (inputs
7708 `(("ghc-random" ,ghc-random)
7709 ("ghc-split" ,ghc-split)
7710 ("ghc-storable-complex" ,ghc-storable-complex)
7711 ("ghc-vector" ,ghc-vector)
7712 ;;("openblas" ,openblas)
7713 ("lapack" ,lapack)))
7714 ;; Guix's OpenBLAS is built with the flag "NO_LAPACK=1" which
7715 ;; disables inclusion of the LAPACK functions.
7716 ;; (arguments `(#:configure-flags '("--flags=openblas")))
7717 (home-page "https://github.com/albertoruiz/hmatrix")
7718 (synopsis "Haskell numeric linear algebra library")
7719 (description "The HMatrix package provices a Haskell library for
7720 dealing with linear systems, matrix decompositions, and other
7721 numerical computations based on BLAS and LAPACK.")
7722 (license license:bsd-3)))
7723
7724 (define-public ghc-hmatrix-gsl
7725 (package
7726 (name "ghc-hmatrix-gsl")
7727 (version "0.17.0.0")
7728 (source
7729 (origin
7730 (method url-fetch)
7731 (uri (string-append
7732 "http://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-"
7733 version ".tar.gz"))
7734 (sha256
7735 (base32 "1jbqwn9d2nldc4klhy0n8gcxr889h0daw2mjfhwgksfy1bwfjl7w"))))
7736 (build-system haskell-build-system)
7737 (inputs
7738 `(("ghc-hmatrix" ,ghc-hmatrix)
7739 ("ghc-vector" ,ghc-vector)
7740 ("ghc-random" ,ghc-random)
7741 ("gsl" ,gsl)))
7742 (native-inputs `(("pkg-config" ,pkg-config)))
7743 (home-page "https://github.com/albertoruiz/hmatrix")
7744 (synopsis "Haskell GSL binding")
7745 (description "This Haskell library provides a purely functional
7746 interface to selected numerical computations, internally implemented
7747 using GSL.")
7748 (license license:gpl3+)))
7749
7750 (define-public ghc-hmatrix-special
7751 (package
7752 (name "ghc-hmatrix-special")
7753 (version "0.4.0.0")
7754 (source
7755 (origin
7756 (method url-fetch)
7757 (uri
7758 (string-append
7759 "http://hackage.haskell.org/package/hmatrix-special/hmatrix-special-"
7760 version ".tar.gz"))
7761 (sha256
7762 (base32 "0cr9y3swzj7slrd84g1nhdkp1kpq4q5ihwapmiaidpr2bv3hrfhz"))))
7763 (build-system haskell-build-system)
7764 (inputs
7765 `(("ghc-hmatrix" ,ghc-hmatrix)
7766 ("ghc-hmatrix-gsl" ,ghc-hmatrix-gsl)))
7767 (home-page "https://github.com/albertoruiz/hmatrix")
7768 (synopsis "Haskell interface to GSL special functions")
7769 (description "This library provides an interface to GSL special
7770 functions for Haskell.")
7771 (license license:gpl3+)))
7772
7773 (define-public ghc-hmatrix-gsl-stats
7774 (package
7775 (name "ghc-hmatrix-gsl-stats")
7776 (version "0.4.1.3")
7777 (source
7778 (origin
7779 (method url-fetch)
7780 (uri
7781 (string-append
7782 "http://hackage.haskell.org/package/hmatrix-gsl-stats/hmatrix-gsl-stats-"
7783 version ".tar.gz"))
7784 (sha256
7785 (base32 "0f3pzi494n4js0xiq5b38n07cnby0h9da6gmwywf8plvxm9271fl"))))
7786 (build-system haskell-build-system)
7787 (inputs
7788 `(("ghc-vector" ,ghc-vector)
7789 ("ghc-storable-complex" ,ghc-storable-complex)
7790 ("ghc-hmatrix" ,ghc-hmatrix)
7791 ("gsl" ,gsl)))
7792 (native-inputs `(("pkg-config" ,pkg-config)))
7793 (home-page "http://code.haskell.org/hmatrix-gsl-stats")
7794 (synopsis "GSL Statistics interface for Haskell")
7795 (description "This Haskell library provides a purely functional
7796 interface for statistics based on hmatrix and GSL.")
7797 (license license:bsd-3)))
7798
7799 (define-public ghc-easyplot
7800 (package
7801 (name "ghc-easyplot")
7802 (version "1.0")
7803 (source
7804 (origin
7805 (method url-fetch)
7806 (uri (string-append
7807 "http://hackage.haskell.org/package/easyplot/easyplot-"
7808 version ".tar.gz"))
7809 (sha256
7810 (base32 "18kndgvdj2apjpfga6fp7m16y1gx8zrwp3c5vfj03sx4v6jvciqk"))))
7811 (build-system haskell-build-system)
7812 (propagated-inputs `(("gnuplot" ,gnuplot)))
7813 (arguments
7814 `(#:phases (modify-phases %standard-phases
7815 (add-after 'unpack 'fix-setup-suffix
7816 (lambda _ (rename-file "Setup.lhs" "Setup.hs") #t)))))
7817 (home-page "http://hub.darcs.net/scravy/easyplot")
7818 (synopsis "Haskell plotting library based on gnuplot")
7819 (description "This package provides a plotting library for
7820 Haskell, using gnuplot for rendering.")
7821 (license license:expat)))
7822
7823 (define-public ghc-hashtables
7824 (package
7825 (name "ghc-hashtables")
7826 (version "1.2.1.0")
7827 (source
7828 (origin
7829 (method url-fetch)
7830 (uri (string-append
7831 "http://hackage.haskell.org/package/hashtables/hashtables-"
7832 version ".tar.gz"))
7833 (sha256
7834 (base32 "1b6w9xznk42732vpd8ili60k12yq190xnajgga0iwbdpyg424lgg"))))
7835 (build-system haskell-build-system)
7836 (inputs
7837 `(("ghc-hashable" ,ghc-hashable)
7838 ("ghc-primitive" ,ghc-primitive)
7839 ("ghc-vector" ,ghc-vector)))
7840 (home-page "http://github.com/gregorycollins/hashtables")
7841 (synopsis "Haskell Mutable hash tables in the ST monad")
7842 (description "This package provides a Haskell library including a
7843 couple of different implementations of mutable hash tables in the ST
7844 monad, as well as a typeclass abstracting their common operations, and
7845 a set of wrappers to use the hash tables in the IO monad.")
7846 (license license:bsd-3)))
7847
7848 (define-public ghc-data-accessor
7849 (package
7850 (name "ghc-data-accessor")
7851 (version "0.2.2.7")
7852 (source
7853 (origin
7854 (method url-fetch)
7855 (uri (string-append
7856 "mirror://hackage/package/data-accessor/data-accessor-"
7857 version ".tar.gz"))
7858 (sha256
7859 (base32 "1vf2g1gac3rm32g97rl0fll51m88q7ry4m6khnl5j47qsmx24r9l"))))
7860 (build-system haskell-build-system)
7861 (home-page "http://www.haskell.org/haskellwiki/Record_access")
7862 (synopsis
7863 "Haskell utilities for accessing and manipulating fields of records")
7864 (description "This package provides Haskell modules for accessing and
7865 manipulating fields of records.")
7866 (license license:bsd-3)))
7867
7868 (define-public ghc-data-accessor-transformers
7869 (package
7870 (name "ghc-data-accessor-transformers")
7871 (version "0.2.1.7")
7872 (source
7873 (origin
7874 (method url-fetch)
7875 (uri (string-append
7876 "mirror://hackage/package/data-accessor-transformers/"
7877 "data-accessor-transformers-" version ".tar.gz"))
7878 (sha256
7879 (base32 "0yp030vafbpddl27m606aibbbr5ar5j5bsv4bksscz3cq4yq5j10"))))
7880 (build-system haskell-build-system)
7881 (inputs `(("ghc-data-accessor" ,ghc-data-accessor)))
7882 (home-page "http://www.haskell.org/haskellwiki/Record_access")
7883 (synopsis "Use Accessor to access state in transformers State monad")
7884 (description "This package provides Haskell modules to allow use of
7885 Accessor to access state in transformers State monad.")
7886 (license license:bsd-3)))
7887
7888 (define-public ghc-utility-ht
7889 (package
7890 (name "ghc-utility-ht")
7891 (version "0.0.12")
7892 (home-page "https://hackage.haskell.org/package/utility-ht")
7893 (source
7894 (origin
7895 (method url-fetch)
7896 (uri (string-append home-page "/utility-ht-" version ".tar.gz"))
7897 (sha256
7898 (base32 "1vq5bd51rl9l5lgfmaqxgiggddk38hzgngcj7qgrqnalcd1myi54"))))
7899 (build-system haskell-build-system)
7900 (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
7901 (synopsis "Haskell helper functions for Lists, Maybes, Tuples, Functions")
7902 (description "This package includes Hakell modules providing various
7903 helper functions for Lists, Maybes, Tuples, Functions.")
7904 (license license:bsd-3)))
7905
7906 (define-public ghc-gnuplot
7907 (package
7908 (name "ghc-gnuplot")
7909 (version "0.5.4.1")
7910 (source
7911 (origin
7912 (method url-fetch)
7913 (uri (string-append
7914 "mirror://hackage/package/gnuplot/gnuplot-"
7915 version ".tar.gz"))
7916 (sha256
7917 (base32 "1xz8prw9xjk0rsyrkp9bsmxykzrbhpv9qhhkdapy75mdbmgwjm7s"))))
7918 (build-system haskell-build-system)
7919 (inputs
7920 `(("ghc-temporary" ,ghc-temporary)
7921 ("ghc-utility-ht" ,ghc-utility-ht)
7922 ("ghc-data-accessor-transformers" ,ghc-data-accessor-transformers)
7923 ("ghc-data-accessor" ,ghc-data-accessor)
7924 ("gnuplot" ,gnuplot)))
7925 (arguments
7926 `(#:phases
7927 (modify-phases %standard-phases
7928 (add-before 'configure 'fix-path-to-gnuplot
7929 (lambda* (#:key inputs #:allow-other-keys)
7930 (let ((gnuplot (assoc-ref inputs "gnuplot")))
7931 (substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
7932 (("(gnuplotName = ).*$" all cmd)
7933 (string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
7934 (home-page "http://www.haskell.org/haskellwiki/Gnuplot")
7935 (synopsis "2D and 3D plots using gnuplot")
7936 (description "This package provides a Haskell module for creating 2D and
7937 3D plots using gnuplot.")
7938 (license license:bsd-3)))
7939
7940 (define-public ghc-hinotify
7941 (package
7942 (name "ghc-hinotify")
7943 (version "0.3.8.1")
7944 (source (origin
7945 (method url-fetch)
7946 (uri (string-append
7947 "https://hackage.haskell.org/package/hinotify/"
7948 "hinotify-" version ".tar.gz"))
7949 (sha256
7950 (base32
7951 "03c1f4d7x805zdiq2w26kl09xrfjw19saycdkhnixzv2qcr6xm1p"))))
7952 (build-system haskell-build-system)
7953 (home-page "https://github.com/kolmodin/hinotify.git")
7954 (synopsis "Haskell binding to inotify")
7955 (description "This library provides a wrapper to the Linux kernel's inotify
7956 feature, allowing applications to subscribe to notifications when a file is
7957 accessed or modified.")
7958 (license license:bsd-3)))
7959
7960 (define-public ghc-fsnotify
7961 (package
7962 (name "ghc-fsnotify")
7963 (version "0.2.1")
7964 (source (origin
7965 (method url-fetch)
7966 (uri (string-append
7967 "https://hackage.haskell.org/package/fsnotify/"
7968 "fsnotify-" version ".tar.gz"))
7969 (sha256
7970 (base32
7971 "0asl313a52qx2w6dw25g845683xsl840bwjh118nkwi5v1xipkzb"))))
7972 (build-system haskell-build-system)
7973 (inputs
7974 `(("ghc-text" ,ghc-text)
7975 ("ghc-async" ,ghc-async)
7976 ("ghc-unix-compat" ,ghc-unix-compat)
7977 ("ghc-hinotify" ,ghc-hinotify)
7978 ("ghc-tasty" ,ghc-tasty)
7979 ("ghc-tasty-hunit" ,ghc-tasty-hunit)
7980 ("ghc-temporary-rc" ,ghc-temporary-rc)))
7981 (home-page "https://github.com/haskell-fswatch/hfsnotify")
7982 (synopsis "Cross platform library for file change notification.")
7983 (description "Cross platform library for file creation, modification, and
7984 deletion notification. This library builds upon existing libraries for platform
7985 specific Windows, Mac, and Linux filesystem event notification.")
7986 (license license:bsd-3)))
7987
7988 (define-public ghc-tasty-rerun
7989 (package
7990 (name "ghc-tasty-rerun")
7991 (version "1.1.6")
7992 (source (origin
7993 (method url-fetch)
7994 (uri (string-append
7995 "https://hackage.haskell.org/package/tasty-rerun/"
7996 "tasty-rerun-" version ".tar.gz"))
7997 (sha256
7998 (base32
7999 "0ycxg7whabgcxyzy6gr536x8ykzx45whh1wrbsc7c58zi862fczd"))))
8000 (build-system haskell-build-system)
8001 (inputs
8002 `(("ghc-mtl" ,ghc-mtl)
8003 ("ghc-optparse-applicative" ,ghc-optparse-applicative)
8004 ("ghc-reducers" ,ghc-reducers)
8005 ("ghc-split" ,ghc-split)
8006 ("ghc-stm" ,ghc-stm)
8007 ("ghc-tagged" ,ghc-tagged)
8008 ("ghc-tasty" ,ghc-tasty)))
8009 (home-page "http://github.com/ocharles/tasty-rerun")
8010 (synopsis "Run tests by filtering the test tree")
8011 (description "This package adds the ability to run tests by filtering the
8012 test tree based on the result of a previous test run. You can use this to run
8013 only those tests that failed in the last run, or to only run the tests that have
8014 been added since previous test run.")
8015 (license license:bsd-3)))
8016
8017 (define-public ghc-ieee754
8018 (package
8019 (name "ghc-ieee754")
8020 (version "0.7.8")
8021 (source (origin
8022 (method url-fetch)
8023 (uri (string-append
8024 "https://hackage.haskell.org/package/ieee754/"
8025 "ieee754-" version ".tar.gz"))
8026 (sha256
8027 (base32
8028 "1zvfnnd5nm5kgr60214cdyks0kqdqyzpwk5sdh0s60yr8b7fyjny"))))
8029 (build-system haskell-build-system)
8030 (home-page "http://github.com/patperry/hs-ieee754")
8031 (synopsis "Utilities for dealing with IEEE floating point numbers")
8032 (description "Utilities for dealing with IEEE floating point numbers,
8033 ported from the Tango math library; approximate and exact equality comparisons
8034 for general types.")
8035 (license license:bsd-3)))
8036
8037 (define-public ghc-terminal-size
8038 (package
8039 (name "ghc-terminal-size")
8040 (version "0.3.2.1")
8041 (source (origin
8042 (method url-fetch)
8043 (uri (string-append
8044 "https://hackage.haskell.org/package/terminal-size/"
8045 "terminal-size-" version ".tar.gz"))
8046 (sha256
8047 (base32
8048 "0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm"))))
8049 (build-system haskell-build-system)
8050 (home-page "http://hackage.haskell.org/package/terminal-size")
8051 (synopsis "Get terminal window height and width")
8052 (description "Get terminal window height and width without ncurses
8053 dependency.")
8054 (license license:bsd-3)))
8055
8056 (define-public ghc-language-c
8057 (package
8058 (name "ghc-language-c")
8059 (version "0.5.0")
8060 (source
8061 (origin
8062 (method url-fetch)
8063 (uri (string-append "https://hackage.haskell.org/package/"
8064 "language-c/language-c-" version ".tar.gz"))
8065 (sha256
8066 (base32
8067 "08i2bl7jmmymn2sldzlbz6ig7lx3wfwhlpadzibs3fx72z08pmc6"))))
8068 (build-system haskell-build-system)
8069 (inputs `(("ghc-syb" ,ghc-syb)))
8070 (native-inputs
8071 `(("ghc-happy" ,ghc-happy)
8072 ("ghc-alex" ,ghc-alex)))
8073 (home-page "http://visq.github.io/language-c/")
8074 (synopsis "Analysis and generation of C code")
8075 (description
8076 "Language C is a Haskell library for the analysis and generation of C code.
8077 It features a complete, well-tested parser and pretty printer for all of C99
8078 and a large set of GNU extensions.")
8079 (license license:bsd-3)))
8080
8081 (define-public ghc-markdown-unlit
8082 (package
8083 (name "ghc-markdown-unlit")
8084 (version "0.4.0")
8085 (source (origin
8086 (method url-fetch)
8087 (uri (string-append
8088 "mirror://hackage/package/markdown-unlit/"
8089 "markdown-unlit-" version ".tar.gz"))
8090 (sha256
8091 (base32
8092 "1kj2bffl7ndd8ygwwa3r1mbpwbxbfhyfgnbla8k8g9i6ffp0qrbw"))))
8093 (build-system haskell-build-system)
8094 (inputs
8095 `(("ghc-base-compat" ,ghc-base-compat)
8096 ("ghc-hspec" ,ghc-hspec)
8097 ("ghc-quickcheck" ,ghc-quickcheck)
8098 ("ghc-silently" ,ghc-silently)
8099 ("ghc-stringbuilder" ,ghc-stringbuilder)
8100 ("ghc-temporary" ,ghc-temporary)
8101 ("hspec-discover" ,hspec-discover)))
8102 (home-page "https://github.com/sol/markdown-unlit#readme")
8103 (synopsis "Literate Haskell support for Markdown")
8104 (description "This package allows you to have a README.md that at the
8105 same time is a literate Haskell program.")
8106 (license license:expat)))
8107
8108 (define-public corrode
8109 (let ((commit "b6699fb2fa552a07c6091276285a44133e5c9789"))
8110 (package
8111 (name "corrode")
8112 (version (string-append "0.0.1-" (string-take commit 7)))
8113 (source
8114 (origin
8115 (method git-fetch)
8116 (uri (git-reference
8117 (url "https://github.com/jameysharp/corrode.git")
8118 (commit "b6699fb2fa552a07c6091276285a44133e5c9789")))
8119 (file-name
8120 (string-append name "-" version "-checkout"))
8121 (sha256
8122 (base32 "02v0yyj6sk4gpg2222wzsdqjxn8w66scbnf6b20x0kbmc69qcz4r"))))
8123 (build-system haskell-build-system)
8124 (inputs
8125 `(("ghc-language-c" ,ghc-language-c)
8126 ("ghc-markdown-unlit" ,ghc-markdown-unlit)))
8127 (home-page "https://github.com/jameysharp/corrode")
8128 (synopsis "Automatic semantics-preserving translation from C to Rust")
8129 (description
8130 "This program reads a C source file and prints an equivalent module in
8131 Rust syntax. It is intended to be useful for two different purposes:
8132
8133 @enumerate
8134 @item Partial automation for migrating legacy code that was implemented in C.
8135 @item A new, complementary approach to static analysis for C programs.
8136 @end enumerate\n")
8137 (license license:gpl2+))))
8138
8139 (define-public ghc-wave
8140 (package
8141 (name "ghc-wave")
8142 (version "0.1.4")
8143 (source (origin
8144 (method url-fetch)
8145 (uri (string-append
8146 "https://hackage.haskell.org/package/wave/wave-"
8147 version
8148 ".tar.gz"))
8149 (sha256
8150 (base32
8151 "1g5nmqfk6p25v9ismwz4i66ay91bd1qh39xwj0hm4z6a5mw8frk8"))))
8152 (build-system haskell-build-system)
8153 (inputs
8154 `(("ghc-cereal" ,ghc-cereal)
8155 ("ghc-data-default-class"
8156 ,ghc-data-default-class)
8157 ("ghc-quickcheck" ,ghc-quickcheck)
8158 ("ghc-temporary" ,ghc-temporary)))
8159 (native-inputs
8160 `(("hspec-discover" ,hspec-discover)
8161 ("ghc-hspec" ,ghc-hspec)))
8162 (home-page "https://github.com/mrkkrp/wave")
8163 (synopsis "Work with WAVE and RF64 files in Haskell")
8164 (description "This package allows you to work with WAVE and RF64
8165 files in Haskell.")
8166 (license license:bsd-3)))
8167
8168 (define-public ghc-hslogger
8169 (package
8170 (name "ghc-hslogger")
8171 (version "1.2.10")
8172 (source
8173 (origin
8174 (method url-fetch)
8175 (uri (string-append "https://hackage.haskell.org/package/"
8176 "hslogger-" version "/" "hslogger-"
8177 version ".tar.gz"))
8178 (sha256 (base32
8179 "0as5gvlh6pi2gflakp695qnlizyyp059dqrhvjl4gjxalja6xjnp"))))
8180 (build-system haskell-build-system)
8181 (inputs
8182 `(("ghc-mtl" ,ghc-mtl)
8183 ("ghc-network" ,ghc-network)
8184 ("ghc-directory", ghc-directory)
8185 ("ghc-old-locale" ,ghc-old-locale)
8186 ("ghc-process" ,ghc-process)))
8187 (native-inputs
8188 `(("ghc-hunit" ,ghc-hunit)))
8189 (home-page "http://software.complete.org/hslogger")
8190 (synopsis "Logging framework for Haskell, similar to Python's logging module")
8191 (description "Hslogger lets each log message have a priority and source be
8192 associated with it. The programmer can then define global handlers that route
8193 or filter messages based on the priority and source. It also has a syslog
8194 handler built in.")
8195 (license license:bsd-3)))
8196
8197 ;;; haskell.scm ends here