Merge branch 'master' into core-updates

1 files changed, 647 insertions, 1 deletions

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 05622ca068..e6b8e07be7 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -18,12 +18,14 @@
 
 (define-module (gnu packages haskell)
   #:use-module (ice-9 regex)
-  #:use-module (guix licenses)
+  #:use-module ((guix licenses) #:select (bsd-3))
   #:use-module (guix packages)
   #:use-module (guix download)
   #:use-module (guix utils)
   #:use-module (guix build-system gnu)
+  #:use-module (guix build-system haskell)
   #:use-module (gnu packages perl)
+  #:use-module (gnu packages compression)
   #:use-module (gnu packages elf)
   #:use-module (gnu packages bootstrap)
   #:use-module (gnu packages ghostscript)
@@ -224,4 +226,648 @@
 interactive environment for the functional language Haskell.")
     (license bsd-3)))
 
+(define-public ghc-mtl
+  (package
+    (name "ghc-mtl")
+    (version "2.1.3.1")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/mtl/mtl-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp"))))
+    (build-system haskell-build-system)
+    (home-page "http://github.com/ekmett/mtl")
+    (synopsis
+     "Monad classes, using functional dependencies")
+    (description
+     "Monad classes using functional dependencies, with instances
+for various monad transformers, inspired by the paper
+'Functional Programming with Overloading and Higher-Order Polymorphism',
+by Mark P Jones, in 'Advanced School of Functional Programming', 1995
+http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.")
+  (license bsd-3)))
+
+(define-public ghc-paths
+  (package
+    (name "ghc-paths")
+    (version "0.1.0.9")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/ghc-paths/ghc-paths-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/simonmar/ghc-paths")
+    (synopsis
+     "Knowledge of GHC's installation directories")
+    (description
+     "Knowledge of GHC's installation directories.")
+    (license bsd-3)))
+
+(define-public ghc-zlib
+  (package
+    (name "ghc-zlib")
+    (version "0.5.4.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/zlib/zlib-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
+    (build-system haskell-build-system)
+    (inputs `(("zlib" ,zlib)))
+    (home-page "http://hackage.haskell.org/package/zlib")
+    (synopsis
+     "Compression and decompression in the gzip and zlib formats")
+    (description
+     "This package provides a pure interface for compressing and decompressing
+streams of data represented as lazy 'ByteString's.  It uses the zlib C library
+so it has high performance.  It supports the 'zlib', 'gzip' and 'raw'
+compression formats.  It provides a convenient high level API suitable for
+most tasks and for the few cases where more control is needed it provides
+access to the full zlib feature set.")
+    (license bsd-3)))
+
+(define-public ghc-stm
+  (package
+    (name "ghc-stm")
+    (version "2.4.4")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/stm/stm-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/stm")
+    (synopsis "Software Transactional Memory")
+    (description
+     "A modular composable concurrency abstraction.")
+    (license bsd-3)))
+
+(define-public ghc-parallel
+  (package
+    (name "ghc-parallel")
+    (version "3.2.0.6")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/parallel/parallel-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/parallel")
+    (synopsis "Parallel programming library")
+    (description
+     "This package provides a library for parallel programming.")
+    (license bsd-3)))
+
+(define-public ghc-text
+  (package
+    (name "ghc-text")
+    (version "1.2.0.4")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/text/text-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "004p1c74crs8wmjafwsmw3mmycspq1j8fpm1lvfpq6acha7bnpc6"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page "https://github.com/bos/text")
+    (synopsis
+     "Efficient packed Unicode text type library.")
+    (description
+     "An efficient packed, immutable Unicode text type (both strict and
+lazy), with a powerful loop fusion optimization framework.
+
+The 'Text' type represents Unicode character strings, in a time and
+space-efficient manner. This package provides text processing
+capabilities that are optimized for performance critical use, both
+in terms of large data quantities and high speed.")
+    (license bsd-3)))
+
+(define-public ghc-hashable
+  (package
+    (name "ghc-hashable")
+    (version "1.2.3.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/hashable/hashable-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0h9295pv2sgbaqlwpwbx2bap6nngm0jcdhkqham1wpjwyxqgqrlc"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    ;; these inputs are necessary to use this library
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)))
+    (home-page "http://github.com/tibbe/hashable")
+    (synopsis
+     "Class for types that can be converted to a hash value")
+    (description
+     "This package defines a class, 'Hashable', for types that can be
+converted to a hash value.  This class exists for the benefit of hashing-based
+data structures.  The package provides instances for basic types and a way to
+combine hash values.")
+    (license bsd-3)))
+
+(define-public ghc-hunit
+  (package
+    (name "ghc-hunit")
+    (version "1.2.5.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/HUnit/HUnit-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
+    (build-system haskell-build-system)
+    (home-page "http://hunit.sourceforge.net/")
+    (synopsis "Unit testing framework for Haskell")
+    (description
+     "HUnit is a unit testing framework for Haskell, inspired by the
+JUnit tool for Java.")
+    (license bsd-3)))
+
+(define-public ghc-random
+  (package
+    (name "ghc-random")
+    (version "1.1")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/random/random-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
+    (build-system haskell-build-system)
+    (home-page "http://hackage.haskell.org/package/random")
+    (synopsis "Random number library")
+    (description "This package provides a basic random number generation
+library, including the ability to split random number generators.")
+    (license bsd-3)))
+
+(define-public ghc-primitive
+  (package
+    (name "ghc-primitive")
+    (version "0.5.4.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/primitive/primitive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10"))))
+    (build-system haskell-build-system)
+    (home-page
+     "https://github.com/haskell/primitive")
+    (synopsis "Primitive memory-related operations")
+    (description
+     "This package provides various primitive memory-related operations.")
+    (license bsd-3)))
+
+(define-public ghc-tf-random
+  (package
+    (name "ghc-tf-random")
+    (version "0.5")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/tf-random/tf-random-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
+    (build-system haskell-build-system)
+    ;; these inputs are necessary to use this package
+    (propagated-inputs
+     `(("ghc-primitive" ,ghc-primitive)
+       ("ghc-random" ,ghc-random)))
+    (home-page "http://hackage.haskell.org/package/tf-random")
+    (synopsis "High-quality splittable pseudorandom number generator")
+    (description "This package contains an implementation of a high-quality
+splittable pseudorandom number generator.  The generator is based on a
+cryptographic hash function built on top of the ThreeFish block cipher.  See
+the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
+Hashing\" by Claessen, Pałka for details and the rationale of the design.")
+    (license bsd-3)))
+
+(define-public ghc-quickcheck
+  (package
+    (name "ghc-quickcheck")
+    (version "2.8")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/QuickCheck/QuickCheck-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "04xs6mq22bcnkpi616qrbm7jlivh9csnhmvjgp1ifq52an1wr4rx"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
+       #:configure-flags '("-f base4")))
+    ;; these inputs are necessary to use this package
+    (propagated-inputs
+     `(("ghc-tf-random" ,ghc-tf-random)))
+    (home-page
+     "https://github.com/nick8325/quickcheck")
+    (synopsis
+     "Automatic testing of Haskell programs")
+    (description
+     "QuickCheck is a library for random testing of program properties.")
+    (license bsd-3)))
+
+(define-public ghc-case-insensitive
+  (package
+    (name "ghc-case-insensitive")
+    (version "1.2.0.4")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/case-insensitive/case-insensitive-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    ;; these inputs are necessary to use this library
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-hashable" ,ghc-hashable)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page
+     "https://github.com/basvandijk/case-insensitive")
+    (synopsis "Case insensitive string comparison")
+    (description
+     "The module 'Data.CaseInsensitive' provides the 'CI' type constructor
+which can be parameterised by a string-like type like: 'String', 'ByteString',
+'Text', etc..  Comparisons of values of the resulting type will be insensitive
+to cases.")
+    (license bsd-3)))
+
+(define-public ghc-syb
+  (package
+    (name "ghc-syb")
+    (version "0.4.4")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/syb/syb-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "11sc9kmfvcn9bfxf227fgmny502z2h9xs3z0m9ak66lk0dw6f406"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-mtl" ,ghc-mtl)))
+    (home-page
+     "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
+    (synopsis "Scrap Your Boilerplate")
+    (description
+     "This package contains the generics system described in the
+/Scrap Your Boilerplate/ papers (see
+<http://www.cs.uu.nl/wiki/GenericProgramming/SYB>).
+It defines the 'Data' class of types permitting folding and unfolding
+of constructor applications, instances of this class for primitive
+types, and a variety of traversals.")
+    (license bsd-3)))
+
+(define-public ghc-containers
+  (package
+    (name "ghc-containers")
+    (version "0.5.6.3")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/containers/containers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1kcd55nl0vzi99i8sr8fmc5j25fv7m0a9hd3nihnq1pd64pfciqn"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page "http://hackage.haskell.org/package/containers")
+    (synopsis "Assorted concrete container types")
+    (description
+     "This package contains efficient general-purpose implementations of
+various basic immutable container types.  The declared cost of each operation
+is either worst-case or amortized, but remains valid even if structures are
+shared.")
+    (license bsd-3)))
+
+(define-public ghc-fgl
+  (package
+    (name "ghc-fgl")
+    (version "5.5.1.0")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/fgl/fgl-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-mtl" ,ghc-mtl)))
+    (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
+    (synopsis
+     "Martin Erwig's Functional Graph Library")
+    (description "The functional graph library, FGL, is a collection of type
+and function definitions to address graph problems.  The basis of the library
+is an inductive definition of graphs in the style of algebraic data types that
+encourages inductive, recursive definitions of graph algorithms.")
+    (license bsd-3)))
+
+(define-public ghc-unordered-containers
+  (package
+    (name "ghc-unordered-containers")
+    (version "0.2.5.1")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/unordered-containers/unordered-containers-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    ;; these inputs are necessary to use this library
+    (propagated-inputs `(("ghc-hashable" ,ghc-hashable)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page
+     "https://github.com/tibbe/unordered-containers")
+    (synopsis
+     "Efficient hashing-based container types")
+    (description
+     "Efficient hashing-based container types.  The containers have been
+optimized for performance critical use, both in terms of large data quantities
+and high speed.")
+    (license bsd-3)))
+
+(define-public ghc-split
+  (package
+    (name "ghc-split")
+    (version "0.2.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/split/split-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))))
+    (build-system haskell-build-system)
+    (inputs 
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "http://hackage.haskell.org/package/split")
+    (synopsis
+     "Combinator library for splitting lists")
+    (description "A collection of various methods for splitting lists into
+parts, akin to the 'split' function found in several mainstream languages.")
+    (license bsd-3)))
+
+(define-public ghc-parsec
+  (package
+    (name "ghc-parsec")
+    (version "3.1.9")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/parsec/parsec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    ;; these inputs are necessary to use this library
+    (propagated-inputs
+     `(("ghc-text" ,ghc-text)
+       ("ghc-mtl" ,ghc-mtl)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page
+     "https://github.com/aslatter/parsec")
+    (synopsis "Monadic parser combinators")
+    (description "Parsec is a parser library.  It is simple, safe, well
+documented, has extensive libraries, good error messages, and is fast.  It is
+defined as a monad transformer that can be stacked on arbitrary monads, and it
+is also parametric in the input stream type.")
+    (license bsd-3)))
+
+(define-public ghc-vector
+  (package
+    (name "ghc-vector")
+    (version "0.10.12.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/vector/vector-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "01hc71k1z9m0g0dv4zsvq5d2dvbgyc5p01hryw5c53792yi2fm25"))))
+    (build-system haskell-build-system)
+    (inputs 
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    ;; these inputs are necessary to use this library
+    (propagated-inputs
+     `(("ghc-primitive" ,ghc-primitive)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+    (home-page "https://github.com/haskell/vector")
+    (synopsis "Efficient Arrays")
+    (description "An efficient implementation of Int-indexed arrays (both
+mutable and immutable), with a powerful loop optimisation framework.")
+  (license bsd-3)))
+
+(define-public ghc-network
+  (package
+    (name "ghc-network")
+    (version "2.6.0.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/network/network-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "12b7saam5ga6l4cplgkad49xa4vkynz2ri9jxidx1cxiqjcl0vc4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (arguments
+     `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
+       #:phases
+       (modify-phases %standard-phases
+         (add-before configure set-sh
+                     (lambda _ (setenv "CONFIG_SHELL" "sh"))))))
+    (home-page "https://github.com/haskell/network")
+    (synopsis "Low-level networking interface")
+    (description
+     "This package provides a low-level networking interface.")
+    (license bsd-3)))
+
+(define-public ghc-network-uri
+  (package
+    (name "ghc-network-uri")
+    (version "2.6.0.1")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/network-uri/network-uri-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "09ymamb128jgqghpda4nixncr73all8qc6q53976aricm6a27p37"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-network" ,ghc-network)))
+    (arguments
+     `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
+    (propagated-inputs
+     `(("ghc-parsec" ,ghc-parsec)))
+    (home-page
+     "https://github.com/haskell/network-uri")
+    (synopsis "Labrary for URI manipulation")
+    (description "This package provides an URI manipulation inteface.  In
+'network-2.6' the 'Network.URI' module was split off from the 'network'
+package into this package.")
+    (license bsd-3)))
+
+(define-public ghc-http
+  (package
+    (name "ghc-http")
+    (version "4000.2.19")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "http://hackage.haskell.org/package/HTTP/HTTP-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1yzm8gimh8g0wwbixcbxg60v4l3vgi63w9v55ms0x9qnm6vrgysz"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hunit" ,ghc-hunit)))
+    (propagated-inputs
+     `(("ghc-parsec" ,ghc-parsec)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-network" ,ghc-network)
+       ("ghc-network-uri" ,ghc-network-uri)))
+    (arguments
+     `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
+    (home-page "https://github.com/haskell/HTTP")
+    (synopsis "Library for client-side HTTP")
+    (description
+     "The HTTP package supports client-side web programming in Haskell. It
+lets you set up HTTP connections, transmitting requests and processing the
+responses coming back.")
+    (license bsd-3)))
+
 ;;; haskell.scm ends here