aboutsummaryrefslogtreecommitdiff
path: root/gnu/packages/haskell.scm
diff options
context:
space:
mode:
Diffstat (limited to 'gnu/packages/haskell.scm')
-rw-r--r--gnu/packages/haskell.scm1028
1 files changed, 1009 insertions, 19 deletions
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 87628b559d..3bd3e1476d 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -6,6 +6,7 @@
;;; Copyright © 2016 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2016 ng0 <ng0@we.make.ritual.n0.is>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
+;;; Copyright © 2015, 2016 Ricardo Wurmus <rekado@elephly.net>
;;;
;;; This file is part of GNU Guix.
;;;
@@ -3032,7 +3033,7 @@ variety of traversals.")
(define-public ghc-fgl
(package
(name "ghc-fgl")
- (version "5.5.1.0")
+ (version "5.5.3.0")
(outputs '("out" "doc"))
(source
(origin
@@ -3043,9 +3044,12 @@ variety of traversals.")
".tar.gz"))
(sha256
(base32
- "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga"))))
+ "0fbyb6jxy9whgrv6dgnkzz70cmy98arx3q2gnkhgl4a3d7idh36p"))))
(build-system haskell-build-system)
- (inputs `(("ghc-mtl" ,ghc-mtl)))
+ (inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
(synopsis
"Martin Erwig's Functional Graph Library")
@@ -4287,7 +4291,7 @@ indexed variants.")
(define-public ghc-tagsoup
(package
(name "ghc-tagsoup")
- (version "0.13.3")
+ (version "0.14")
(source
(origin
(method url-fetch)
@@ -4297,7 +4301,7 @@ indexed variants.")
".tar.gz"))
(sha256
(base32
- "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j"))))
+ "07pax7i0bl79dmqqz58zy09yrgpnyyr2ya0z183hv96kp65jv0lh"))))
(build-system haskell-build-system)
(inputs `(("ghc-text" ,ghc-text)))
(home-page
@@ -5112,7 +5116,7 @@ providing an 'rnf' implementation.")
(define-public ghc-pandoc-types
(package
(name "ghc-pandoc-types")
- (version "1.12.4.7")
+ (version "1.16.1.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
@@ -5120,7 +5124,7 @@ providing an 'rnf' implementation.")
version ".tar.gz"))
(sha256
(base32
- "108n11kbdaj2ii3cyf0xczhsx90p1gjbxwqp1f0wyn2m3cls632n"))))
+ "094mzgdxva84kcpjf9m8b5n3chm1wm44bzflh5x6xhddz6pb7zpq"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-syb" ,ghc-syb)
@@ -5137,14 +5141,14 @@ building up, manipulating and serialising @code{Pandoc} structures.")
(define-public ghc-texmath
(package
(name "ghc-texmath")
- (version "0.8.4")
+ (version "0.8.6.5")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"texmath/texmath-" version ".tar.gz"))
(sha256
(base32
- "15821jg64fbr4rwaglp5ksah6q8qqz1vkjxlqp6d3bbb1rj8v2ri"))))
+ "143c8k7dyhwa9blpa8svy23ybx7i4xzb9jnfcimj8iigizbw7y1k"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-syb" ,ghc-syb)
@@ -5212,7 +5216,7 @@ and utilities for pretty printing.")
(define-public ghc-highlighting-kate
(package
(name "ghc-highlighting-kate")
- (version "0.6")
+ (version "0.6.3")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
@@ -5220,7 +5224,7 @@ and utilities for pretty printing.")
version ".tar.gz"))
(sha256
(base32
- "16334fbiyq6017zbgc59qc00h0bk24xh4dcrbqx63dvf72ac37dk"))))
+ "03c4flh4h1jd48bx0qmplax3q8w6wj1dhbh6j0xhaf5h95fbinki"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-diff" ,ghc-diff)
@@ -5244,14 +5248,14 @@ descriptions.")
(define-public ghc-cmark
(package
(name "ghc-cmark")
- (version "0.4.1")
+ (version "0.5.3.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"cmark/cmark-" version ".tar.gz"))
(sha256
(base32
- "0c134qh65viaq4q6pv7bnnr5wchzivg94nv0dj8pc1326sx0dw12"))))
+ "09515h9b26az9c2mbl6l7azimaixa6yff8w359k0ml8jwykjvqaa"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-text" ,ghc-text)))
@@ -5979,7 +5983,7 @@ tasty.")
(define-public ghc-cryptonite
(package
(name "ghc-cryptonite")
- (version "0.9")
+ (version "0.19")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
@@ -5987,7 +5991,7 @@ tasty.")
version ".tar.gz"))
(sha256
(base32
- "1h22x22lq2m8h456v5j50xm0l25bcm3h1pchsk83br909hjxql4z"))))
+ "1rw5k34vpn4134yrzdhf0rsshsrkixfbv9ap18di2n00z2cw1shw"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-memory" ,ghc-memory)
@@ -6149,14 +6153,14 @@ for X.509 certificates.")
(define-public ghc-tls
(package
(name "ghc-tls")
- (version "1.3.3")
+ (version "1.3.8")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"tls/tls-" version ".tar.gz"))
(sha256
(base32
- "096ay54bwy6qi9z8ypncww3ls853zj37yaficvcg7qcqj42zn0wz"))))
+ "1rdidf18i781c0vdvy9yn79yh08hmcacf6fp3sgghyiy3h0wyh5l"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-mtl" ,ghc-mtl)
@@ -6276,7 +6280,7 @@ libraries, such as http-conduit.")
(define-public ghc-pandoc
(package
(name "ghc-pandoc")
- (version "1.15.2.1")
+ (version "1.17.2")
(source
(origin
(method url-fetch)
@@ -6284,7 +6288,7 @@ libraries, such as http-conduit.")
version ".tar.gz"))
(sha256
(base32
- "0nfzwsdvrvg9zypgyqk0246p10yzlpqsqnkds8yraqybbvkb1g30"))))
+ "1v78zq12p71gq0pc24h08inxcq5gxd0xb7m5ds0xw9pv9l2pswl1"))))
(build-system haskell-build-system)
(propagated-inputs
`(("ghc-syb" ,ghc-syb)
@@ -6432,4 +6436,990 @@ can be specified precisely in the type. The language is closely related to
Epigram and Agda.")
(license license:bsd-3)))
+(define-public ghc-base16-bytestring
+ (package
+ (name "ghc-base16-bytestring")
+ (version "0.1.1.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/base16-bytestring/"
+ "base16-bytestring-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs"))))
+ (build-system haskell-build-system)
+ (home-page "http://github.com/bos/base16-bytestring")
+ (synopsis "Fast base16 (hex) encoding and decoding for ByteStrings")
+ (description
+ "This package provides a Haskell library for working with base16-encoded
+data quickly and efficiently, using the ByteString type.")
+ (license license:bsd-3)))
+
+(define-public ghc-binary
+ (package
+ (name "ghc-binary")
+ (version "0.8.4.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/binary/binary-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1fp7wxnf57cjzhbb7rgqs6fgws4690zh0dxgl924dj4nzq0cf4wd"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/kolmodin/binary")
+ (synopsis
+ "Binary serialisation for Haskell values using lazy ByteStrings")
+ (description
+ "Efficient, pure binary serialisation using lazy ByteStrings. Haskell values
+may be encoded to and from binary formats, written to disk as binary, or sent over
+the network. The format used can be automatically generated, or you can choose to
+implement a custom format if needed. Serialisation speeds of over 1 G\\/sec have
+been observed, so this library should be suitable for high performance scenarios.")
+ (license license:bsd-3)))
+
+(define-public ghc-cryptohash
+ (package
+ (name "ghc-cryptohash")
+ (version "0.11.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/cryptohash/cryptohash-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1yr2iyb779znj79j3fq4ky8l1y8a600a2x1fx9p5pmpwq5zq93y2"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-memory" ,ghc-memory)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "http://github.com/vincenthz/hs-cryptohash")
+ (synopsis "Collection of cryptographic hashes in Haskell")
+ (description
+ "A collection of crypto hashes, with a practical incremental and one-pass,
+pure APIs, with performance close to the fastest implementations available in
+other languages. The implementations are made in C with a haskell FFI wrapper
+that hides the C implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-data-ordlist
+ (package
+ (name "ghc-data-ordlist")
+ (version "0.4.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/data-ordlist/data-ordlist-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/data-ordlist")
+ (synopsis "Set and bag operations on ordered lists")
+ (description
+ "This module provides set and multiset operations on ordered lists.")
+ (license license:bsd-3)))
+
+(define-public ghc-haskeline
+ (package
+ (name "ghc-haskeline")
+ (version "0.7.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haskeline/haskeline-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "09wd6sxgn65xxpk7dhy1cg3ywlbk0ccqq7xylycwk4zazy3gjgkd"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ncurses" ,ncurses)))
+ (arguments
+ `(#:configure-flags (list "-fterminfo")))
+ (home-page "https://github.com/judah/haskeline")
+ (synopsis "Command-line interface for user input")
+ (description
+ "Haskeline provides a user interface for line input in command-line
+programs. This library is similar in purpose to readline, but since it
+is written in Haskell it is (hopefully) more easily used in other Haskell
+programs.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-applicative
+ (package
+ (name "ghc-regex-applicative")
+ (version "0.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-applicative/"
+ "regex-applicative-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1riv7jqf26lbv4rm54sd6mrx8xdh4dvh4xbzymzdfdw13k6a4nb6"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/feuerbach/regex-applicative")
+ (synopsis "Regex-based parsing with applicative interface")
+ (description
+ "@code{regex-applicative} is a Haskell library for parsing using
+regular expressions. Parsers can be built using Applicative interface.")
+ (license license:expat)))
+
+(define-public ghc-regex-tdfa
+ (package
+ (name "ghc-regex-tdfa")
+ (version "1.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-tdfa/regex-tdfa-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0f8x8wyr6m21g8dnxvnvalz5bsq37l125l6qhs0fscbvprsxc4nb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-regex-base" ,ghc-regex-base)))
+ (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
+ (synopsis "POSIX extended regular expressions in Haskell.")
+ (description
+ "Regex-tdfa is a pure Haskell regular expression library implementing POSIX
+extended regular expressions. It is a \"tagged\" DFA regex engine. It is
+inspired by libtre.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-compat-tdfa
+ (package
+ (name "ghc-regex-compat-tdfa")
+ (version "0.95.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/regex-compat-tdfa/regex-compat-tdfa-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-tdfa" ,ghc-regex-tdfa)))
+ (home-page "http://hub.darcs.net/shelarcy/regex-compat-tdfa")
+ (synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
+ (description
+ "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
+@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
+This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
+this problem.")
+ (license license:bsd-3)))
+
+(define-public ghc-tasty-th
+ (package
+ (name "ghc-tasty-th")
+ (version "0.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tasty-th/tasty-th-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-tasty" ,ghc-tasty)))
+ (home-page "http://github.com/bennofs/tasty-th")
+ (synopsis "Automatically generate tasty TestTrees")
+ (description
+ "Tasty-th automatically generates tasty TestTrees from functions of the
+current module, using TemplateHaskell. This is a fork the original
+test-framework-th package, modified to work with tasty instead of
+test-framework.")
+ (license license:bsd-3)))
+
+(define-public ghc-sandi
+ (package
+ (name "ghc-sandi")
+ (version "0.4.0") ; darcs-2.12.4 needs == 0.4.*
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/sandi/sandi-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1smf3bq44qni4zbgxpw7cy7b9g95fbrr73j8njjf6139naj9bj20"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-stringsearch" ,ghc-stringsearch)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-th" ,ghc-tasty-th)))
+ (home-page "http://hackage.haskell.org/package/sandi")
+ (synopsis "Data encoding library")
+ (description "Reasonably fast data encoding library.")
+ (license license:bsd-3)))
+
+(define-public ghc-bytestring-handle
+ (package
+ (name "ghc-bytestring-handle")
+ (version "0.1.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/bytestring-handle/bytestring-handle-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0q5yzx90ad9w7qvaix05bynxwlsbqjrgfc4hqb355ibf991wd0rh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)))
+ (home-page "http://hub.darcs.net/ganesh/bytestring-handle")
+ (synopsis "ByteString-backed Handles")
+ (description "ByteString-backed Handles") ; There is no description
+ (license license:bsd-3)))
+
+(define-public ghc-tar
+ (package
+ (name "ghc-tar")
+ (version "0.5.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/tar/tar-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "18qq94j9bm91iswnxq2dm5dws5c7wm4k01q2rpf8py35cf3svnfq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-bytestring-handle" ,ghc-bytestring-handle)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-array" ,ghc-array)))
+ (home-page "http://hackage.haskell.org/package/tar")
+ (synopsis "Reading, writing and manipulating \".tar\" archive files")
+ (description
+ "This library is for working with \\\"@.tar@\\\" archive files.
+It can read and write a range of common variations of the tar archive format
+including V7, POSIX USTAR and GNU formats. It provides support for packing and
+unpacking portable archives. This makes it suitable for distribution but not
+backup because details like file ownership and exact permissions are not
+preserved. It also provides features for random access to archive content using
+an index.")
+ (license license:bsd-3)))
+
+(define-public ghc-transformers
+ (package
+ (name "ghc-transformers")
+ (version "0.5.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/transformers/transformers-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1qkhi8ssf8c4jnmrw9dzym3igqbzq7h48iisaykdfzdsm09qfh3c"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/transformers")
+ (synopsis "Concrete functor and monad transformers")
+ (description
+ "A portable library of functor and monad transformers, inspired by the paper
+'Functional Programming with Overloading and Higher-Order Polymorphism',
+by Mark P Jones. This package contains the monad transformer class and IO monad class,
+concrete functor and monad transformers, each with associated operations and functions
+to lift operations associated with other transformers. The package can be used on
+its own in portable Haskell code, in which case operations need to be manually lifted
+through transformer stacks. Alternatively, it can be used with the
+non-portable monad classes in the @code{mtl} or @code{monads-tf} packages,
+which automatically lift operations introduced by monad transformers through
+other transformers.")
+ (license license:bsd-3)))
+
+;; darcs-2.12.0 requires transformers-0.4.2.0
+(define-public ghc-transformers-0.4.2.0
+ (package
+ (inherit ghc-transformers)
+ (version "0.4.2.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/transformers/"
+ "transformers-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0a364zfcm17mhpy0c4ms2j88sys4yvgd6071qsgk93la2wjm8mkr"))))))
+
+(define-public ghc-findbin
+ (package
+ (name "ghc-findbin")
+ (version "0.0.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/FindBin/FindBin-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/audreyt/findbin")
+ (synopsis "Get the absolute path of the running program")
+ (description
+ "This module locates the full directory of the running program, to allow
+the use of paths relative to it. FindBin supports invocation of Haskell
+programs via \"ghci\", via \"runhaskell/runghc\", as well as compiled as
+an executable.")
+ (license license:bsd-3)))
+
+(define-public ghc-patience
+ (package
+ (name "ghc-patience")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/patience/patience-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/patience")
+ (synopsis "Patience diff and longest increasing subsequence")
+ (description
+ "This library implements the 'patience diff' algorithm, as well as the
+patience algorithm for the longest increasing subsequence problem.
+Patience diff computes the difference between two lists, for example the lines
+of two versions of a source file. It provides a good balance between
+performance, nice output for humans, and simplicity of implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-monads-tf
+ (package
+ (name "ghc-monads-tf")
+ (version "0.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/monads-tf/monads-tf-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/monads-tf")
+ (synopsis "Monad classes, using type families")
+ (description
+ "Monad classes using type families, with instances for various monad transformers,
+inspired by the paper 'Functional Programming with Overloading and Higher-Order
+Polymorphism', by Mark P Jones. This package is almost a compatible replacement for
+the @code{mtl-tf} package.")
+ (license license:bsd-3)))
+
+(define-public ghc-bytestring
+ (package
+ (name "ghc-bytestring")
+ (version "0.10.8.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/bytestring/bytestring-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "16zwb1p83z7vc5wlhvknpy80b5a2jxc5awx67rk52qnp9idmyq9d"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-byteorder" ,ghc-byteorder)
+ ("ghc-dlist" ,ghc-dlist)
+ ("ghc-mtl" ,ghc-mtl)))
+ (arguments
+ `(#:tests? #f)) ; Test number two becomes non-responsive for 20+ minutes
+ (home-page "https://github.com/haskell/bytestring")
+ (synopsis "Fast, compact, strict and lazy byte strings with a list interface")
+ (description
+ "An efficient compact, immutable byte string type (both strict and lazy)
+suitable for binary or 8-bit character data. The 'ByteString' type represents
+sequences of bytes or 8-bit characters. It is suitable for high performance use,
+both in terms of large data quantities, or high speed requirements. The 'ByteString'
+functions follow the same style as ordinary lists, so it is easy to convert code
+from using 'String' to 'ByteString'.")
+ (license license:bsd-3)))
+
+(define-public ghc-colour
+(package
+ (name "ghc-colour")
+ (version "2.3.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/colour/colour-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd"))))
+ (build-system haskell-build-system)
+ (home-page "http://www.haskell.org/haskellwiki/Colour")
+ (synopsis "Model for human colour perception")
+ (description
+ "This package provides a data type for colours and transparency.
+Colours can be blended and composed. Various colour spaces are
+supported. A module of colour names (\"Data.Colour.Names\") is provided.")
+ (license license:expat)))
+
+(define-public ghc-directory
+ (package
+ (name "ghc-directory")
+ (version "1.2.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/directory/directory-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0h3hrqskadmbigaxbz2k5xxjjjlmfaq2zdn2g7jh1wv9k6yrxraa"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/directory")
+ (synopsis "Platform-agnostic library for filesystem operations")
+ (description
+ "This library provides a basic set of operations for manipulating
+files and directories in a portable way.")
+ (license license:bsd-3)))
+
+(define-public ghc-process
+ (package
+ (name "ghc-process")
+ (version "1.4.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/process/process-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1v1bav5isqxq9fc4lw714x94qbfsjbm2nn12kjp69r1ql8jaaaqw"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/process")
+ (synopsis "System process libraries")
+ (description
+ "This package contains libraries for dealing with system processes.")
+ (license license:bsd-3)))
+
+(define-public ghc-wl-pprint-text
+ (package
+ (name "ghc-wl-pprint-text")
+ (version "1.1.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/wl-pprint-text/wl-pprint-text-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1xgizzimfw17mpmw2afvmnvyag976j8ggn7k5r564rkw9f0m6bgz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-text" ,ghc-text)))
+ (home-page "http://hackage.haskell.org/package/wl-pprint-text")
+ (synopsis "Wadler/Leijen Pretty Printer for Text values")
+ (description
+ "A clone of wl-pprint for use with the text library.")
+ (license license:bsd-3)))
+
+(define-public ghc-fgl-arbitrary
+ (package
+ (name "ghc-fgl-arbitrary")
+ (version "0.2.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/fgl-arbitrary/fgl-arbitrary-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "12qbsla4vivffris6y3gj29vrafkpyazqdbdy2m55nggypqpf7ah"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-fgl" ,ghc-fgl)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "http://hackage.haskell.org/package/fgl-arbitrary")
+ (synopsis "QuickCheck support for fgl")
+ (description
+ "Provides Arbitrary instances for fgl graphs to avoid adding a
+QuickCheck dependency for fgl whilst still making the instances
+available to others. Also available are non-fgl-specific functions
+for generating graph-like data structures.")
+ (license license:bsd-3)))
+
+(define-public ghc-graphviz
+ (package
+ (name "ghc-graphviz")
+ (version "2999.18.1.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "graphviz/graphviz-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1z453is01v0rnxlv6xx4iyaqv5vrp3bpz829mpv1a341sck2135h"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-dlist" ,ghc-dlist)
+ ("ghc-fgl" ,ghc-fgl)
+ ("ghc-fgl-arbitrary" ,ghc-fgl-arbitrary)
+ ("ghc-polyparse" ,ghc-polyparse)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-text" ,ghc-text)
+ ("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
+ (home-page "https://hackage.haskell.org/package/graphviz")
+ (synopsis "Bindings to Graphviz for graph visualisation")
+ (description
+ "This library provides bindings for the Dot language used by
+the @uref{http://graphviz.org/, Graphviz} suite of programs for
+visualising graphs, as well as functions to call those programs.
+Main features of the graphviz library include:
+
+@enumerate
+@item Almost complete coverage of all Graphviz attributes and syntax
+@item Support for specifying clusters
+@item The ability to use a custom node type
+@item Functions for running a Graphviz layout tool with all specified output types
+@item Generate and parse Dot code with two options: strict and liberal
+@item Functions to convert FGL graphs and other graph-like data structures
+@item Round-trip support for passing an FGL graph through Graphviz to augment node
+and edge labels with positional information, etc.
+@end enumerate\n")
+ (license license:bsd-3)))
+
+(define-public ghc-array
+ (package
+ (name "ghc-array")
+ (version "0.5.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/array/array-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "08r2rq4blvc737mrg3xhlwiw13jmsz5dlf2fd0ghb9cdaxc6kjc9"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/array")
+ (synopsis "Mutable and immutable arrays")
+ (description
+ "In addition to providing the @code{Data.Array} module, this package also defines
+the classes @code{IArray} of immutable arrays and @code{MArray} of arrays mutable
+within appropriate monads, as well as some instances of these classes.")
+ (license license:bsd-3)))
+
+(define-public ghc-constraints
+ (package
+ (name "ghc-constraints")
+ (version "0.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/constraints/constraints-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "120mmv9rwbahslisc1z8zx9lw7v6hl5fzid4l0hiy5as6ijqgl2c"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "http://github.com/ekmett/constraints/")
+ (synopsis "Constraint manipulation")
+ (description
+ "GHC 7.4 gave us the ability to talk about @code{ConstraintKinds}.
+They stopped crashing the compiler in GHC 7.6. This package provides
+a vocabulary for working with them.")
+ (license license:bsd-3)))
+
+(define-public ghc-lifted-async
+ (package
+ (name "ghc-lifted-async")
+ (version "0.9.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/lifted-async/lifted-async-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "00fnwfcnc6niq9jbbb9rap9rkdgv5qhcglwanzc5fi8834j94c1r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-constraints" ,ghc-constraints)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-th" ,ghc-tasty-th)))
+ (home-page "https://github.com/maoe/lifted-async")
+ (synopsis "Run lifted IO operations asynchronously and wait for their results")
+ (description
+ "This package provides IO operations from @code{async} package lifted to any
+instance of @code{MonadBase} or @code{MonadBaseControl}.")
+ (license license:bsd-3)))
+
+;; Ghc-shelly depends on ghc-system-filepath and ghc-system-fileio, who in turn depend on
+;; ghc-chell and ghc-chell-quickcheck for the test phase. Ghc-chell depends on ghc-options
+;; which depends on ghc-chell and ghc-chell-quickcheck.
+;; Therefore we bootstrap it with tests disabled.
+(define ghc-system-filepath-bootstrap
+ (package
+ (name "ghc-system-filepath-bootstrap")
+ (version "0.4.13.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-filepath/system-filepath-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f))
+ (inputs
+ `(("ghc-text" ,ghc-text)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "High-level, byte-based file and directory path manipulations")
+ (description
+ "Provides a FilePath datatype and utility functions for operating on it.
+Unlike the filepath package, this package does not simply reuse String,
+increasing type safety.")
+ (license license:expat)))
+
+;; See ghc-system-filepath-bootstrap. In addition this package depends on
+;; ghc-system-filepath.
+(define ghc-system-fileio-bootstrap
+ (package
+ (name "ghc-system-fileio-bootstrap")
+ (version "0.3.16.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-fileio/system-fileio-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f))
+ (inputs
+ `(("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
+ ("ghc-text" ,ghc-text)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "Consistent filesystem interaction across GHC versions")
+ (description
+ "This is a small wrapper around the directory, unix, and Win32 packages,
+for use with system-filepath. It provides a consistent API to the various
+versions of these packages distributed with different versions of GHC.
+In particular, this library supports working with POSIX files that have paths
+which can't be decoded in the current locale encoding.")
+ (license license:expat)))
+
+(define-public ghc-shelly
+ (package
+ (name "ghc-shelly")
+ (version "1.6.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/shelly/shelly-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0bg1pj5bhswfgwfgz66xr82i8cmjgrnx5ljvjy37052zxb82imnk"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-system-filepath-bootstrap" ,ghc-system-filepath-bootstrap)
+ ("ghc-system-fileio-bootstrap" ,ghc-system-fileio-bootstrap)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-lifted-async" ,ghc-lifted-async)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
+ ("ghc-text" ,ghc-text)
+ ("ghc-async" ,ghc-async)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/yesodweb/Shelly.hs")
+ (synopsis "Shell-like (systems) programming in Haskell")
+ (description
+ "Shelly provides convenient systems programming in Haskell, similar in
+spirit to POSIX shells. Shelly is originally forked from the Shellish package.")
+ (license license:bsd-3)))
+
+;; See ghc-system-filepath-bootstrap, chell and chell-quickcheck are required for tests.
+(define ghc-options-bootstrap
+ (package
+ (name "ghc-options-bootstrap")
+ (version "1.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/options/options-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f))
+ (inputs
+ `(("ghc-monads-tf" ,ghc-monads-tf)))
+ (home-page "https://john-millikin.com/software/haskell-options/")
+ (synopsis "Powerful and easy-to-use command-line option parser")
+ (description
+ "The @code{options} package lets library and application developers
+easily work with command-line options.")
+ (license license:expat)))
+
+(define-public ghc-chell
+ (package
+ (name "ghc-chell")
+ (version "0.4.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/chell/chell-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0lb95abzxl4a87nfqxsxpb3a39pd52cci43hcvj8615hyhqvs2jz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-options-bootstrap" ,ghc-options-bootstrap)
+ ("ghc-patience" ,ghc-patience)
+ ("ghc-random" ,ghc-random)
+ ("ghc-text" ,ghc-text)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)))
+ (home-page "https://john-millikin.com/software/chell/")
+ (synopsis "Simple and intuitive library for automated testing")
+ (description
+ "Chell is a simple and intuitive library for automated testing.
+It natively supports assertion-based testing, and can use companion
+libraries such as @code{chell-quickcheck} to support more complex
+testing strategies.")
+ (license license:expat)))
+
+(define ghc-chell-quickcheck-bootstrap
+ (package
+ (name "ghc-chell-quickcheck-bootstrap")
+ (version "0.2.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/chell-quickcheck/chell-quickcheck-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-chell" ,ghc-chell)
+ ("ghc-random" ,ghc-random)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:tests? #f))
+ (home-page "https://john-millikin.com/software/chell/")
+ (synopsis "QuickCheck support for the Chell testing library")
+ (description "More complex tests for @code{chell}.")
+ (license license:expat)))
+
+(define-public ghc-chell-quickcheck
+ (package
+ (name "ghc-chell-quickcheck")
+ (version "0.2.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/chell-quickcheck/chell-quickcheck-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-chell" ,ghc-chell)
+ ("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap)
+ ("ghc-random" ,ghc-random)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://john-millikin.com/software/chell/")
+ (synopsis "QuickCheck support for the Chell testing library")
+ (description "More complex tests for @code{chell}.")
+ (license license:expat)))
+
+(define-public ghc-options
+ (package
+ (name "ghc-options")
+ (version "1.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/options/options-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-monads-tf" ,ghc-monads-tf)
+ ("ghc-chell" ,ghc-chell)
+ ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)))
+ (home-page "https://john-millikin.com/software/haskell-options/")
+ (synopsis "Powerful and easy-to-use command-line option parser")
+ (description
+ "The @code{options} package lets library and application developers
+easily work with command-line options.")
+ (license license:expat)))
+
+(define-public ghc-system-filepath
+ (package
+ (name "ghc-system-filepath")
+ (version "0.4.13.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-filepath/system-filepath-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-text" ,ghc-text)
+ ("ghc-chell" ,ghc-chell)
+ ("ghc-chell-quickcheck" ,ghc-chell-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "High-level, byte-based file and directory path manipulations")
+ (description
+ "Provides a FilePath datatype and utility functions for operating on it.
+Unlike the filepath package, this package does not simply reuse String,
+increasing type safety.")
+ (license license:expat)))
+
+(define-public ghc-system-fileio
+ (package
+ (name "ghc-system-fileio")
+ (version "0.3.16.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/system-fileio/system-fileio-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-system-filepath" ,ghc-system-filepath)
+ ("ghc-text" ,ghc-text)
+ ("ghc-chell" ,ghc-chell)
+ ("ghc-temporary" ,ghc-temporary)))
+ (home-page "https://github.com/fpco/haskell-filesystem")
+ (synopsis "Consistent filesystem interaction across GHC versions")
+ (description
+ "This is a small wrapper around the directory, unix, and Win32 packages,
+for use with system-filepath. It provides a consistent API to the various
+versions of these packages distributed with different versions of GHC.
+In particular, this library supports working with POSIX files that have paths
+which can't be decoded in the current locale encoding.")
+ (license license:expat)))
;;; haskell.scm ends here
generated by cgit v1.2.3 (git 2.45.0) at 2024-11-15 12:11:00 +0000