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