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