gnu/packages/haskell.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
   3 ;;;
   4 ;;; This file is part of GNU Guix.
   5 ;;;
   6 ;;; GNU Guix is free software; you can redistribute it and/or modify it
   7 ;;; under the terms of the GNU General Public License as published by
   8 ;;; the Free Software Foundation; either version 3 of the License, or (at
   9 ;;; your option) any later version.
  10 ;;;
  11 ;;; GNU Guix is distributed in the hope that it will be useful, but
  12 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ;;; GNU General Public License for more details.
  15 ;;;
  16 ;;; You should have received a copy of the GNU General Public License
  17 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 (define-module (gnu packages haskell)
  20   #:use-module (ice-9 regex)
  21   #:use-module ((guix licenses) #:select (bsd-3))
  22   #:use-module (guix packages)
  23   #:use-module (guix download)
  24   #:use-module (guix utils)
  25   #:use-module (guix build-system gnu)
  26   #:use-module (guix build-system haskell)
  27   #:use-module (gnu packages perl)
  28   #:use-module (gnu packages compression)
  29   #:use-module (gnu packages elf)
  30   #:use-module (gnu packages bootstrap)
  31   #:use-module (gnu packages ghostscript)
  32   #:use-module (gnu packages libffi)
  33   #:use-module (gnu packages libedit)
  34   #:use-module (gnu packages multiprecision)
  35   #:use-module (gnu packages ncurses)
  36   #:use-module (gnu packages python))
  37
  38 (define ghc-bootstrap-x86_64-7.8.4
  39   (origin
  40     (method url-fetch)
  41     (uri
  42      "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-x86_64-unknown-linux-deb7.tar.xz")
  43     (sha256
  44      (base32
  45       "13azsl53xgj20mi1hj9x0xb32vvcvs6cpmvwx6znxhas7blh0bpn"))))
  46
  47 (define ghc-bootstrap-i686-7.8.4
  48   (origin
  49     (method url-fetch)
  50     (uri
  51      "https://www.haskell.org/ghc/dist/7.8.4/ghc-7.8.4-i386-unknown-linux-deb7.tar.xz")
  52     (sha256
  53      (base32
  54       "0wj5s435j0zgww70bj1d3f6wvnnpzlxwvwcyh2qv4qjq5z8j64kg"))))
  55
  56 ;; 43 tests out of 3965 fail.
  57 ;;
  58 ;; Most of them do not appear to be serious:
  59 ;;
  60 ;; - some tests generate files referring to "/bin/sh" and "/bin/ls". I've not
  61 ;;   figured out how these references are generated.
  62 ;;
  63 ;; - Some tests allocate more memory than expected (ca. 3% above upper limit)
  64 ;;
  65 ;; - Some tests try to load unavailable libriries: Control.Concurrent.STM,
  66 ;;   Data.Vector, Control.Monad.State.
  67 ;;
  68 ;; - Test posix010 tries to check the existence of a user on the system:
  69 ;;   getUserEntryForName: does not exist (no such user)
  70 (define-public ghc
  71   (package
  72     (name "ghc")
  73     (version "7.8.4")
  74     (source
  75      (origin
  76       (method url-fetch)
  77       (uri (string-append "https://www.haskell.org/ghc/dist/"
  78                           version "/" name "-" version "-src.tar.xz"))
  79       (sha256
  80        (base32
  81         "1i4254akbb4ym437rf469gc0m40bxm31blp6s1z1g15jmnacs6f3"))))
  82     (build-system gnu-build-system)
  83     (supported-systems '("i686-linux" "x86_64-linux"))
  84     (outputs '("out" "doc"))
  85     (inputs
  86      `(("gmp" ,gmp)
  87        ("ncurses" ,ncurses)
  88        ("libffi" ,libffi)
  89        ("libedit" ,libedit)
  90        ("ghc-testsuite"
  91         ,(origin
  92            (method url-fetch)
  93            (uri (string-append
  94                  "https://www.haskell.org/ghc/dist/"
  95                  version "/" name "-" version "-testsuite.tar.xz"))
  96            (sha256
  97             (base32
  98              "0q95whf87y4mxjzwzy899g7z7l9pazq4si6iciyhxkcdhqq2ycyh"))))))
  99     (native-inputs
 100      `(("perl" ,perl)
 101        ("python" ,python-2)                ; for tests (fails with python-3)
 102        ("ghostscript" ,ghostscript)        ; for tests
 103        ("patchelf" ,patchelf)
 104        ;; GHC is built with GHC. Therefore we need bootstrap binaries.
 105        ("ghc-binary"
 106         ,(if (string-match "x86_64" (or (%current-target-system) (%current-system)))
 107              ghc-bootstrap-x86_64-7.8.4
 108              ghc-bootstrap-i686-7.8.4))))
 109     (arguments
 110      `(#:test-target "test"
 111        ;; We get a smaller number of test failures by disabling parallel test
 112        ;; execution.
 113        #:parallel-tests? #f
 114
 115        ;; The DSOs use $ORIGIN to refer to each other, but (guix build
 116        ;; gremlin) doesn't support it yet, so skip this phase.
 117        #:validate-runpath? #f
 118
 119        #:modules ((guix build gnu-build-system)
 120                   (guix build utils)
 121                   (guix build rpath)
 122                   (srfi srfi-26)
 123                   (srfi srfi-1))
 124        #:imported-modules (,@%gnu-build-system-modules
 125                            (guix build rpath))
 126        #:configure-flags
 127        (list
 128         (string-append "--with-gmp-libraries="
 129                        (assoc-ref %build-inputs "gmp") "/lib")
 130         (string-append "--with-gmp-includes="
 131                        (assoc-ref %build-inputs "gmp") "/include")
 132         "--with-system-libffi"
 133         (string-append "--with-ffi-libraries="
 134                        (assoc-ref %build-inputs "libffi") "/lib")
 135         (string-append "--with-ffi-includes="
 136                        (assoc-ref %build-inputs "libffi") "/include"))
 137        ;; FIXME: The user-guide needs dblatex, docbook-xsl and docbook-utils.
 138        ;; Currently we do not have the last one.
 139        ;; #:make-flags
 140        ;; (list "BUILD_DOCBOOK_HTML = YES")
 141        #:phases
 142        (let* ((ghc-bootstrap-path
 143                (string-append (getcwd) "/" ,name "-" ,version "/ghc-bin"))
 144               (ghc-bootstrap-prefix
 145                (string-append ghc-bootstrap-path "/usr" )))
 146          (alist-cons-after
 147           'unpack-bin 'unpack-testsuite-and-fix-bins
 148           (lambda* (#:key inputs outputs #:allow-other-keys)
 149             (with-directory-excursion ".."
 150               (copy-file (assoc-ref inputs "ghc-testsuite")
 151                          "ghc-testsuite.tar.xz")
 152               (system* "tar" "xvf" "ghc-testsuite.tar.xz"))
 153             (substitute*
 154                 (list "testsuite/timeout/Makefile"
 155                       "testsuite/timeout/timeout.py"
 156                       "testsuite/timeout/timeout.hs"
 157                       "testsuite/tests/rename/prog006/Setup.lhs"
 158                       "testsuite/tests/programs/life_space_leak/life.test"
 159                       "libraries/process/System/Process/Internals.hs"
 160                       "libraries/unix/cbits/execvpe.c")
 161               (("/bin/sh") (which "sh"))
 162               (("/bin/rm") "rm"))
 163             #t)
 164           (alist-cons-after
 165            'unpack 'unpack-bin
 166            (lambda* (#:key inputs outputs #:allow-other-keys)
 167              (mkdir-p ghc-bootstrap-prefix)
 168              (with-directory-excursion ghc-bootstrap-path
 169                (copy-file (assoc-ref inputs "ghc-binary")
 170                           "ghc-bin.tar.xz")
 171                (zero? (system* "tar" "xvf" "ghc-bin.tar.xz"))))
 172            (alist-cons-before
 173             'install-bin 'configure-bin
 174             (lambda* (#:key inputs outputs #:allow-other-keys)
 175               (let* ((binaries
 176                       (list
 177                        "./utils/ghc-pwd/dist-install/build/tmp/ghc-pwd"
 178                        "./utils/hpc/dist-install/build/tmp/hpc"
 179                        "./utils/haddock/dist/build/tmp/haddock"
 180                        "./utils/hsc2hs/dist-install/build/tmp/hsc2hs"
 181                        "./utils/runghc/dist-install/build/tmp/runghc"
 182                        "./utils/ghc-cabal/dist-install/build/tmp/ghc-cabal"
 183                        "./utils/hp2ps/dist/build/tmp/hp2ps"
 184                        "./utils/ghc-pkg/dist-install/build/tmp/ghc-pkg"
 185                        "./utils/unlit/dist/build/tmp/unlit"
 186                        "./ghc/stage2/build/tmp/ghc-stage2"))
 187                      (gmp (assoc-ref inputs "gmp"))
 188                      (gmp-lib (string-append gmp "/lib"))
 189                      (gmp-include (string-append gmp "/include"))
 190                      (ncurses-lib
 191                       (string-append (assoc-ref inputs "ncurses") "/lib"))
 192                      (ld-so (string-append (assoc-ref inputs "libc")
 193                                            ,(glibc-dynamic-linker)))
 194                      (libtinfo-dir
 195                       (string-append ghc-bootstrap-prefix
 196                                      "/lib/ghc-7.8.4/terminfo-0.4.0.0")))
 197                 (with-directory-excursion
 198                     (string-append ghc-bootstrap-path "/" ,name "-" ,version)
 199                   (setenv "CONFIG_SHELL" (which "bash"))
 200                   (setenv "LD_LIBRARY_PATH" gmp-lib)
 201                   ;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded.
 202                   (for-each
 203                    (cut system* "patchelf" "--set-interpreter" ld-so <>)
 204                    binaries)
 205                   ;; The binaries include a reference to libtinfo.so.5 which
 206                   ;; is a subset of libncurses.so.5.  We create a symlink in a
 207                   ;; directory included in the bootstrap binaries rpath.
 208                   (mkdir-p libtinfo-dir)
 209                   (symlink
 210                    (string-append ncurses-lib "/libncursesw.so."
 211                                   ,(version-major+minor
 212                                     (package-version ncurses)))
 213                    (string-append libtinfo-dir "/libtinfo.so.5"))
 214                   (setenv "PATH"
 215                           (string-append (getenv "PATH") ":"
 216                                          ghc-bootstrap-prefix "/bin"))
 217                   (system*
 218                    (string-append (getcwd) "/configure")
 219                    (string-append "--prefix=" ghc-bootstrap-prefix)
 220                    (string-append "--with-gmp-libraries=" gmp-lib)
 221                    (string-append "--with-gmp-includes=" gmp-include)))))
 222             (alist-cons-before
 223              'configure 'install-bin
 224              (lambda* (#:key inputs outputs #:allow-other-keys)
 225                (with-directory-excursion
 226                    (string-append ghc-bootstrap-path "/" ,name "-" ,version)
 227                  (zero? (system* "make" "install"))))
 228              %standard-phases)))))))
 229     (home-page "https://www.haskell.org/ghc")
 230     (synopsis "The Glasgow Haskell Compiler")
 231     (description
 232      "The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and
 233 interactive environment for the functional language Haskell.")
 234     (license bsd-3)))
 235
 236 (define-public ghc-mtl
 237   (package
 238     (name "ghc-mtl")
 239     (version "2.1.3.1")
 240     (outputs '("out" "doc"))
 241     (source
 242      (origin
 243        (method url-fetch)
 244        (uri (string-append
 245              "http://hackage.haskell.org/package/mtl/mtl-"
 246              version
 247              ".tar.gz"))
 248        (sha256
 249         (base32
 250          "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp"))))
 251     (build-system haskell-build-system)
 252     (home-page "http://github.com/ekmett/mtl")
 253     (synopsis
 254      "Monad classes, using functional dependencies")
 255     (description
 256      "Monad classes using functional dependencies, with instances
 257 for various monad transformers, inspired by the paper
 258 'Functional Programming with Overloading and Higher-Order Polymorphism',
 259 by Mark P Jones, in 'Advanced School of Functional Programming', 1995
 260 http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.")
 261   (license bsd-3)))
 262
 263 (define-public ghc-paths
 264   (package
 265     (name "ghc-paths")
 266     (version "0.1.0.9")
 267     (outputs '("out" "doc"))
 268     (source
 269      (origin
 270        (method url-fetch)
 271        (uri (string-append
 272              "http://hackage.haskell.org/package/ghc-paths/ghc-paths-"
 273              version
 274              ".tar.gz"))
 275        (sha256
 276         (base32
 277          "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
 278     (build-system haskell-build-system)
 279     (home-page "https://github.com/simonmar/ghc-paths")
 280     (synopsis
 281      "Knowledge of GHC's installation directories")
 282     (description
 283      "Knowledge of GHC's installation directories.")
 284     (license bsd-3)))
 285
 286 (define-public ghc-zlib
 287   (package
 288     (name "ghc-zlib")
 289     (version "0.5.4.2")
 290     (outputs '("out" "doc"))
 291     (source
 292      (origin
 293        (method url-fetch)
 294        (uri (string-append
 295              "http://hackage.haskell.org/package/zlib/zlib-"
 296              version
 297              ".tar.gz"))
 298        (sha256
 299         (base32
 300          "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
 301     (build-system haskell-build-system)
 302     (inputs `(("zlib" ,zlib)))
 303     (home-page "http://hackage.haskell.org/package/zlib")
 304     (synopsis
 305      "Compression and decompression in the gzip and zlib formats")
 306     (description
 307      "This package provides a pure interface for compressing and decompressing
 308 streams of data represented as lazy 'ByteString's.  It uses the zlib C library
 309 so it has high performance.  It supports the 'zlib', 'gzip' and 'raw'
 310 compression formats.  It provides a convenient high level API suitable for
 311 most tasks and for the few cases where more control is needed it provides
 312 access to the full zlib feature set.")
 313     (license bsd-3)))
 314
 315 (define-public ghc-stm
 316   (package
 317     (name "ghc-stm")
 318     (version "2.4.4")
 319     (outputs '("out" "doc"))
 320     (source
 321      (origin
 322        (method url-fetch)
 323        (uri (string-append
 324              "http://hackage.haskell.org/package/stm/stm-"
 325              version
 326              ".tar.gz"))
 327        (sha256
 328         (base32
 329          "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
 330     (build-system haskell-build-system)
 331     (home-page "http://hackage.haskell.org/package/stm")
 332     (synopsis "Software Transactional Memory")
 333     (description
 334      "A modular composable concurrency abstraction.")
 335     (license bsd-3)))
 336
 337 (define-public ghc-parallel
 338   (package
 339     (name "ghc-parallel")
 340     (version "3.2.0.6")
 341     (outputs '("out" "doc"))
 342     (source
 343      (origin
 344        (method url-fetch)
 345        (uri (string-append
 346              "http://hackage.haskell.org/package/parallel/parallel-"
 347              version
 348              ".tar.gz"))
 349        (sha256
 350         (base32
 351          "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
 352     (build-system haskell-build-system)
 353     (home-page "http://hackage.haskell.org/package/parallel")
 354     (synopsis "Parallel programming library")
 355     (description
 356      "This package provides a library for parallel programming.")
 357     (license bsd-3)))
 358
 359 (define-public ghc-text
 360   (package
 361     (name "ghc-text")
 362     (version "1.2.0.4")
 363     (outputs '("out" "doc"))
 364     (source
 365      (origin
 366        (method url-fetch)
 367        (uri (string-append
 368              "http://hackage.haskell.org/package/text/text-"
 369              version
 370              ".tar.gz"))
 371        (sha256
 372         (base32
 373          "004p1c74crs8wmjafwsmw3mmycspq1j8fpm1lvfpq6acha7bnpc6"))))
 374     (build-system haskell-build-system)
 375     (arguments
 376      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 377     (home-page "https://github.com/bos/text")
 378     (synopsis "Efficient packed Unicode text type library")
 379     (description
 380      "An efficient packed, immutable Unicode text type (both strict and
 381 lazy), with a powerful loop fusion optimization framework.
 382
 383 The 'Text' type represents Unicode character strings, in a time and
 384 space-efficient manner.  This package provides text processing
 385 capabilities that are optimized for performance critical use, both
 386 in terms of large data quantities and high speed.")
 387     (license bsd-3)))
 388
 389 (define-public ghc-hashable
 390   (package
 391     (name "ghc-hashable")
 392     (version "1.2.3.2")
 393     (outputs '("out" "doc"))
 394     (source
 395      (origin
 396        (method url-fetch)
 397        (uri (string-append
 398              "http://hackage.haskell.org/package/hashable/hashable-"
 399              version
 400              ".tar.gz"))
 401        (sha256
 402         (base32
 403          "0h9295pv2sgbaqlwpwbx2bap6nngm0jcdhkqham1wpjwyxqgqrlc"))))
 404     (build-system haskell-build-system)
 405     (arguments
 406      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 407     ;; these inputs are necessary to use this library
 408     (propagated-inputs
 409      `(("ghc-text" ,ghc-text)))
 410     (home-page "http://github.com/tibbe/hashable")
 411     (synopsis
 412      "Class for types that can be converted to a hash value")
 413     (description
 414      "This package defines a class, 'Hashable', for types that can be
 415 converted to a hash value.  This class exists for the benefit of hashing-based
 416 data structures.  The package provides instances for basic types and a way to
 417 combine hash values.")
 418     (license bsd-3)))
 419
 420 (define-public ghc-hunit
 421   (package
 422     (name "ghc-hunit")
 423     (version "1.2.5.2")
 424     (outputs '("out" "doc"))
 425     (source
 426      (origin
 427        (method url-fetch)
 428        (uri (string-append
 429              "http://hackage.haskell.org/package/HUnit/HUnit-"
 430              version
 431              ".tar.gz"))
 432        (sha256
 433         (base32
 434          "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
 435     (build-system haskell-build-system)
 436     (home-page "http://hunit.sourceforge.net/")
 437     (synopsis "Unit testing framework for Haskell")
 438     (description
 439      "HUnit is a unit testing framework for Haskell, inspired by the
 440 JUnit tool for Java.")
 441     (license bsd-3)))
 442
 443 (define-public ghc-random
 444   (package
 445     (name "ghc-random")
 446     (version "1.1")
 447     (outputs '("out" "doc"))
 448     (source
 449      (origin
 450        (method url-fetch)
 451        (uri (string-append
 452              "http://hackage.haskell.org/package/random/random-"
 453              version
 454              ".tar.gz"))
 455        (sha256
 456         (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
 457     (build-system haskell-build-system)
 458     (home-page "http://hackage.haskell.org/package/random")
 459     (synopsis "Random number library")
 460     (description "This package provides a basic random number generation
 461 library, including the ability to split random number generators.")
 462     (license bsd-3)))
 463
 464 (define-public ghc-primitive
 465   (package
 466     (name "ghc-primitive")
 467     (version "0.5.4.0")
 468     (outputs '("out" "doc"))
 469     (source
 470      (origin
 471        (method url-fetch)
 472        (uri (string-append
 473              "http://hackage.haskell.org/package/primitive/primitive-"
 474              version
 475              ".tar.gz"))
 476        (sha256
 477         (base32
 478          "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10"))))
 479     (build-system haskell-build-system)
 480     (home-page
 481      "https://github.com/haskell/primitive")
 482     (synopsis "Primitive memory-related operations")
 483     (description
 484      "This package provides various primitive memory-related operations.")
 485     (license bsd-3)))
 486
 487 (define-public ghc-tf-random
 488   (package
 489     (name "ghc-tf-random")
 490     (version "0.5")
 491     (outputs '("out" "doc"))
 492     (source
 493      (origin
 494        (method url-fetch)
 495        (uri (string-append
 496              "http://hackage.haskell.org/package/tf-random/tf-random-"
 497              version
 498              ".tar.gz"))
 499        (sha256
 500         (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
 501     (build-system haskell-build-system)
 502     ;; these inputs are necessary to use this package
 503     (propagated-inputs
 504      `(("ghc-primitive" ,ghc-primitive)
 505        ("ghc-random" ,ghc-random)))
 506     (home-page "http://hackage.haskell.org/package/tf-random")
 507     (synopsis "High-quality splittable pseudorandom number generator")
 508     (description "This package contains an implementation of a high-quality
 509 splittable pseudorandom number generator.  The generator is based on a
 510 cryptographic hash function built on top of the ThreeFish block cipher.  See
 511 the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
 512 Hashing\" by Claessen, Pałka for details and the rationale of the design.")
 513     (license bsd-3)))
 514
 515 (define-public ghc-quickcheck
 516   (package
 517     (name "ghc-quickcheck")
 518     (version "2.8")
 519     (outputs '("out" "doc"))
 520     (source
 521      (origin
 522        (method url-fetch)
 523        (uri (string-append
 524              "http://hackage.haskell.org/package/QuickCheck/QuickCheck-"
 525              version
 526              ".tar.gz"))
 527        (sha256
 528         (base32
 529          "04xs6mq22bcnkpi616qrbm7jlivh9csnhmvjgp1ifq52an1wr4rx"))))
 530     (build-system haskell-build-system)
 531     (arguments
 532      `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
 533        #:configure-flags '("-f base4")))
 534     ;; these inputs are necessary to use this package
 535     (propagated-inputs
 536      `(("ghc-tf-random" ,ghc-tf-random)))
 537     (home-page
 538      "https://github.com/nick8325/quickcheck")
 539     (synopsis
 540      "Automatic testing of Haskell programs")
 541     (description
 542      "QuickCheck is a library for random testing of program properties.")
 543     (license bsd-3)))
 544
 545 (define-public ghc-case-insensitive
 546   (package
 547     (name "ghc-case-insensitive")
 548     (version "1.2.0.4")
 549     (outputs '("out" "doc"))
 550     (source
 551      (origin
 552        (method url-fetch)
 553        (uri (string-append
 554              "http://hackage.haskell.org/package/case-insensitive/case-insensitive-"
 555              version
 556              ".tar.gz"))
 557        (sha256
 558         (base32
 559          "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
 560     (build-system haskell-build-system)
 561     (inputs
 562      `(("ghc-hunit" ,ghc-hunit)))
 563     ;; these inputs are necessary to use this library
 564     (propagated-inputs
 565      `(("ghc-text" ,ghc-text)
 566        ("ghc-hashable" ,ghc-hashable)))
 567     (arguments
 568      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 569     (home-page
 570      "https://github.com/basvandijk/case-insensitive")
 571     (synopsis "Case insensitive string comparison")
 572     (description
 573      "The module 'Data.CaseInsensitive' provides the 'CI' type constructor
 574 which can be parameterised by a string-like type like: 'String', 'ByteString',
 575 'Text', etc..  Comparisons of values of the resulting type will be insensitive
 576 to cases.")
 577     (license bsd-3)))
 578
 579 (define-public ghc-syb
 580   (package
 581     (name "ghc-syb")
 582     (version "0.4.4")
 583     (outputs '("out" "doc"))
 584     (source
 585      (origin
 586        (method url-fetch)
 587        (uri (string-append
 588              "http://hackage.haskell.org/package/syb/syb-"
 589              version
 590              ".tar.gz"))
 591        (sha256
 592         (base32
 593          "11sc9kmfvcn9bfxf227fgmny502z2h9xs3z0m9ak66lk0dw6f406"))))
 594     (build-system haskell-build-system)
 595     (inputs
 596      `(("ghc-hunit" ,ghc-hunit)
 597        ("ghc-mtl" ,ghc-mtl)))
 598     (home-page
 599      "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
 600     (synopsis "Scrap Your Boilerplate")
 601     (description
 602      "This package contains the generics system described in the
 603 /Scrap Your Boilerplate/ papers (see
 604 <http://www.cs.uu.nl/wiki/GenericProgramming/SYB>).
 605 It defines the 'Data' class of types permitting folding and unfolding
 606 of constructor applications, instances of this class for primitive
 607 types, and a variety of traversals.")
 608     (license bsd-3)))
 609
 610 (define-public ghc-containers
 611   (package
 612     (name "ghc-containers")
 613     (version "0.5.6.3")
 614     (outputs '("out" "doc"))
 615     (source
 616      (origin
 617        (method url-fetch)
 618        (uri (string-append
 619              "http://hackage.haskell.org/package/containers/containers-"
 620              version
 621              ".tar.gz"))
 622        (sha256
 623         (base32
 624          "1kcd55nl0vzi99i8sr8fmc5j25fv7m0a9hd3nihnq1pd64pfciqn"))))
 625     (build-system haskell-build-system)
 626     (inputs
 627      `(("ghc-hunit" ,ghc-hunit)
 628        ("ghc-quickcheck" ,ghc-quickcheck)))
 629     (arguments
 630      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 631     (home-page "http://hackage.haskell.org/package/containers")
 632     (synopsis "Assorted concrete container types")
 633     (description
 634      "This package contains efficient general-purpose implementations of
 635 various basic immutable container types.  The declared cost of each operation
 636 is either worst-case or amortized, but remains valid even if structures are
 637 shared.")
 638     (license bsd-3)))
 639
 640 (define-public ghc-fgl
 641   (package
 642     (name "ghc-fgl")
 643     (version "5.5.1.0")
 644     (outputs '("out" "doc"))
 645     (source
 646      (origin
 647        (method url-fetch)
 648        (uri (string-append
 649              "http://hackage.haskell.org/package/fgl/fgl-"
 650              version
 651              ".tar.gz"))
 652        (sha256
 653         (base32
 654          "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga"))))
 655     (build-system haskell-build-system)
 656     (inputs `(("ghc-mtl" ,ghc-mtl)))
 657     (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
 658     (synopsis
 659      "Martin Erwig's Functional Graph Library")
 660     (description "The functional graph library, FGL, is a collection of type
 661 and function definitions to address graph problems.  The basis of the library
 662 is an inductive definition of graphs in the style of algebraic data types that
 663 encourages inductive, recursive definitions of graph algorithms.")
 664     (license bsd-3)))
 665
 666 (define-public ghc-unordered-containers
 667   (package
 668     (name "ghc-unordered-containers")
 669     (version "0.2.5.1")
 670     (outputs '("out" "doc"))
 671     (source
 672      (origin
 673        (method url-fetch)
 674        (uri (string-append
 675              "http://hackage.haskell.org/package/unordered-containers/unordered-containers-"
 676              version
 677              ".tar.gz"))
 678        (sha256
 679         (base32
 680          "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
 681     (build-system haskell-build-system)
 682     (inputs
 683      `(("ghc-hunit" ,ghc-hunit)
 684        ("ghc-quickcheck" ,ghc-quickcheck)))
 685     ;; these inputs are necessary to use this library
 686     (propagated-inputs `(("ghc-hashable" ,ghc-hashable)))
 687     (arguments
 688      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 689     (home-page
 690      "https://github.com/tibbe/unordered-containers")
 691     (synopsis
 692      "Efficient hashing-based container types")
 693     (description
 694      "Efficient hashing-based container types.  The containers have been
 695 optimized for performance critical use, both in terms of large data quantities
 696 and high speed.")
 697     (license bsd-3)))
 698
 699 (define-public ghc-split
 700   (package
 701     (name "ghc-split")
 702     (version "0.2.2")
 703     (outputs '("out" "doc"))
 704     (source
 705      (origin
 706        (method url-fetch)
 707        (uri (string-append
 708              "http://hackage.haskell.org/package/split/split-"
 709              version
 710              ".tar.gz"))
 711        (sha256
 712         (base32
 713          "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))))
 714     (build-system haskell-build-system)
 715     (inputs
 716      `(("ghc-quickcheck" ,ghc-quickcheck)))
 717     (home-page "http://hackage.haskell.org/package/split")
 718     (synopsis
 719      "Combinator library for splitting lists")
 720     (description "A collection of various methods for splitting lists into
 721 parts, akin to the 'split' function found in several mainstream languages.")
 722     (license bsd-3)))
 723
 724 (define-public ghc-parsec
 725   (package
 726     (name "ghc-parsec")
 727     (version "3.1.9")
 728     (outputs '("out" "doc"))
 729     (source
 730      (origin
 731        (method url-fetch)
 732        (uri (string-append
 733              "http://hackage.haskell.org/package/parsec/parsec-"
 734              version
 735              ".tar.gz"))
 736        (sha256
 737         (base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
 738     (build-system haskell-build-system)
 739     (inputs
 740      `(("ghc-hunit" ,ghc-hunit)))
 741     ;; these inputs are necessary to use this library
 742     (propagated-inputs
 743      `(("ghc-text" ,ghc-text)
 744        ("ghc-mtl" ,ghc-mtl)))
 745     (arguments
 746      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 747     (home-page
 748      "https://github.com/aslatter/parsec")
 749     (synopsis "Monadic parser combinators")
 750     (description "Parsec is a parser library.  It is simple, safe, well
 751 documented, has extensive libraries, good error messages, and is fast.  It is
 752 defined as a monad transformer that can be stacked on arbitrary monads, and it
 753 is also parametric in the input stream type.")
 754     (license bsd-3)))
 755
 756 (define-public ghc-vector
 757   (package
 758     (name "ghc-vector")
 759     (version "0.10.12.2")
 760     (outputs '("out" "doc"))
 761     (source
 762      (origin
 763        (method url-fetch)
 764        (uri (string-append
 765              "http://hackage.haskell.org/package/vector/vector-"
 766              version
 767              ".tar.gz"))
 768        (sha256
 769         (base32
 770          "01hc71k1z9m0g0dv4zsvq5d2dvbgyc5p01hryw5c53792yi2fm25"))))
 771     (build-system haskell-build-system)
 772     (inputs
 773      `(("ghc-quickcheck" ,ghc-quickcheck)))
 774     ;; these inputs are necessary to use this library
 775     (propagated-inputs
 776      `(("ghc-primitive" ,ghc-primitive)))
 777     (arguments
 778      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 779     (home-page "https://github.com/haskell/vector")
 780     (synopsis "Efficient Arrays")
 781     (description "An efficient implementation of Int-indexed arrays (both
 782 mutable and immutable), with a powerful loop optimisation framework.")
 783   (license bsd-3)))
 784
 785 (define-public ghc-network
 786   (package
 787     (name "ghc-network")
 788     (version "2.6.0.2")
 789     (outputs '("out" "doc"))
 790     (source
 791      (origin
 792        (method url-fetch)
 793        (uri (string-append
 794              "http://hackage.haskell.org/package/network/network-"
 795              version
 796              ".tar.gz"))
 797        (sha256
 798         (base32
 799          "12b7saam5ga6l4cplgkad49xa4vkynz2ri9jxidx1cxiqjcl0vc4"))))
 800     (build-system haskell-build-system)
 801     (inputs
 802      `(("ghc-hunit" ,ghc-hunit)))
 803     (arguments
 804      `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
 805        #:phases
 806        (modify-phases %standard-phases
 807          (add-before 'configure 'set-sh
 808                      (lambda _ (setenv "CONFIG_SHELL" "sh"))))))
 809     (home-page "https://github.com/haskell/network")
 810     (synopsis "Low-level networking interface")
 811     (description
 812      "This package provides a low-level networking interface.")
 813     (license bsd-3)))
 814
 815 (define-public ghc-network-uri
 816   (package
 817     (name "ghc-network-uri")
 818     (version "2.6.0.1")
 819     (outputs '("out" "doc"))
 820     (source
 821      (origin
 822        (method url-fetch)
 823        (uri (string-append
 824              "http://hackage.haskell.org/package/network-uri/network-uri-"
 825              version
 826              ".tar.gz"))
 827        (sha256
 828         (base32
 829          "09ymamb128jgqghpda4nixncr73all8qc6q53976aricm6a27p37"))))
 830     (build-system haskell-build-system)
 831     (inputs
 832      `(("ghc-hunit" ,ghc-hunit)
 833        ("ghc-network" ,ghc-network)))
 834     (arguments
 835      `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
 836     (propagated-inputs
 837      `(("ghc-parsec" ,ghc-parsec)))
 838     (home-page
 839      "https://github.com/haskell/network-uri")
 840     (synopsis "Labrary for URI manipulation")
 841     (description "This package provides an URI manipulation inteface.  In
 842 'network-2.6' the 'Network.URI' module was split off from the 'network'
 843 package into this package.")
 844     (license bsd-3)))
 845
 846 (define-public ghc-http
 847   (package
 848     (name "ghc-http")
 849     (version "4000.2.19")
 850     (outputs '("out" "doc"))
 851     (source
 852      (origin
 853        (method url-fetch)
 854        (uri (string-append
 855              "http://hackage.haskell.org/package/HTTP/HTTP-"
 856              version
 857              ".tar.gz"))
 858        (sha256
 859         (base32
 860          "1yzm8gimh8g0wwbixcbxg60v4l3vgi63w9v55ms0x9qnm6vrgysz"))))
 861     (build-system haskell-build-system)
 862     (inputs
 863      `(("ghc-hunit" ,ghc-hunit)))
 864     (propagated-inputs
 865      `(("ghc-parsec" ,ghc-parsec)
 866        ("ghc-mtl" ,ghc-mtl)
 867        ("ghc-network" ,ghc-network)
 868        ("ghc-network-uri" ,ghc-network-uri)))
 869     (arguments
 870      `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
 871     (home-page "https://github.com/haskell/HTTP")
 872     (synopsis "Library for client-side HTTP")
 873     (description
 874      "The HTTP package supports client-side web programming in Haskell.  It
 875 lets you set up HTTP connections, transmitting requests and processing the
 876 responses coming back.")
 877     (license bsd-3)))
 878
 879 ;;; haskell.scm ends here