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