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