;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Tonton <tonton@riseup.net>
;;; Copyright © 2018 Timothy Sample <samplet@ngyro.com>
+;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
;;;
;;; This file is part of GNU Guix.
;;;
(define-module (gnu packages haskell)
#:use-module (gnu packages)
+ #:use-module (gnu packages base)
#:use-module (gnu packages bootstrap)
#:use-module (gnu packages check)
#:use-module (gnu packages compression)
#:use-module (gnu packages gcc)
#:use-module (gnu packages ghostscript)
#:use-module (gnu packages gl)
+ #:use-module (gnu packages graphviz)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
#:use-module (gnu packages haskell-web)
interactive environment for the functional language Haskell.")
(license license:bsd-3)))
-(define-public ghc-8
+(define-public ghc-8.0
(package
(name "ghc")
(version "8.0.2")
interactive environment for the functional language Haskell.")
(license license:bsd-3)))
+(define-public ghc-8
+ (package (inherit ghc-8.0)
+ (name "ghc")
+ (version "8.4.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://www.haskell.org/ghc/dist/"
+ version "/" name "-" version "-src.tar.xz"))
+ (sha256
+ (base32 "1mk046vb561j75saz05rghhbkps46ym5aci4264dwc2qk3dayixf"))))
+ (inputs
+ `(("gmp" ,gmp)
+ ("ncurses" ,ncurses)
+ ("libffi" ,libffi)
+ ("target-binutils" ,binutils)
+ ("target-gcc" ,gcc)
+ ("target-ld-wrapper" ,(make-ld-wrapper "ld-wrapper"
+ #:binutils binutils))))
+ (native-inputs
+ `(("perl" ,perl)
+ ("python" ,python) ; for tests
+ ("ghostscript" ,ghostscript) ; for tests
+ ;; GHC 8.4.3 is built with GHC 8.
+ ("ghc-bootstrap" ,ghc-8.0)
+ ("ghc-testsuite"
+ ,(origin
+ (method url-fetch)
+ (uri (string-append
+ "https://www.haskell.org/ghc/dist/"
+ version "/" name "-" version "-testsuite.tar.xz"))
+ (sha256
+ (base32
+ "1z55b1z0m3plqd2d1ks6w5wvx7igm7zsk3i4v7cms003z0as0hzz"))))))
+ (arguments
+ `(#:test-target "test"
+ ;; We get a smaller number of test failures by disabling parallel test
+ ;; execution.
+ #:parallel-tests? #f
+
+ ;; The DSOs use $ORIGIN to refer to each other, but (guix build
+ ;; gremlin) doesn't support it yet, so skip this phase.
+ #:validate-runpath? #f
+
+ ;; Don't pass --build=<triplet>, because the configure script
+ ;; auto-detects slightly different triplets for --host and --target and
+ ;; then complains that they don't match.
+ #:build #f
+
+ #:configure-flags
+ (list
+ (string-append "--with-gmp-libraries="
+ (assoc-ref %build-inputs "gmp") "/lib")
+ (string-append "--with-gmp-includes="
+ (assoc-ref %build-inputs "gmp") "/include")
+ "--with-system-libffi"
+ (string-append "--with-ffi-libraries="
+ (assoc-ref %build-inputs "libffi") "/lib")
+ (string-append "--with-ffi-includes="
+ (assoc-ref %build-inputs "libffi") "/include")
+ (string-append "--with-curses-libraries="
+ (assoc-ref %build-inputs "ncurses") "/lib")
+ (string-append "--with-curses-includes="
+ (assoc-ref %build-inputs "ncurses") "/include"))
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'unpack-testsuite
+ (lambda* (#:key inputs #:allow-other-keys)
+ (invoke "tar" "xvf"
+ (assoc-ref inputs "ghc-testsuite")
+ "--strip-components=1")
+ #t))
+ (add-after 'unpack-testsuite 'fix-shell-wrappers
+ (lambda _
+ (substitute* '("driver/ghci/ghc.mk"
+ "utils/mkdirhier/ghc.mk"
+ "rules/shell-wrapper.mk")
+ (("echo '#!/bin/sh'")
+ (format #f "echo '#!~a'" (which "sh"))))
+ #t))
+ ;; This is necessary because the configure system no longer uses
+ ;; “AC_PATH_” but “AC_CHECK_”, setting the variables to just the
+ ;; plain command names.
+ (add-before 'configure 'set-target-programs
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((binutils (assoc-ref inputs "target-binutils"))
+ (gcc (assoc-ref inputs "target-gcc"))
+ (ld-wrapper (assoc-ref inputs "target-ld-wrapper")))
+ (setenv "CC" (string-append gcc "/bin/gcc"))
+ (setenv "CXX" (string-append gcc "/bin/g++"))
+ (setenv "LD" (string-append ld-wrapper "/bin/ld"))
+ (setenv "NM" (string-append binutils "/bin/nm"))
+ (setenv "RANLIB" (string-append binutils "/bin/ranlib"))
+ (setenv "STRIP" (string-append binutils "/bin/strip"))
+ ;; The 'ar' command does not follow the same pattern.
+ (setenv "fp_prog_ar" (string-append binutils "/bin/ar"))
+ #t)))
+ (add-before 'build 'fix-references
+ (lambda _
+ (substitute* '("testsuite/timeout/Makefile"
+ "testsuite/timeout/timeout.py"
+ "testsuite/timeout/timeout.hs"
+ "testsuite/tests/programs/life_space_leak/life.test"
+ ;; libraries
+ "libraries/process/System/Process/Posix.hs"
+ "libraries/process/tests/process001.hs"
+ "libraries/process/tests/process002.hs"
+ "libraries/unix/cbits/execvpe.c")
+ (("/bin/sh") (which "sh"))
+ (("/bin/ls") (which "ls"))
+ (("/bin/rm") "rm"))
+ #t))
+ (add-before 'build 'fix-environment
+ (lambda _
+ (unsetenv "GHC_PACKAGE_PATH")
+ (setenv "CONFIG_SHELL" (which "bash"))
+ #t)))))
+ (native-search-paths (list (search-path-specification
+ (variable "GHC_PACKAGE_PATH")
+ (files (list
+ (string-append "lib/ghc-" version)))
+ (file-pattern ".*\\.conf\\.d$")
+ (file-type 'directory))))))
+
(define-public ghc ghc-8)
(define-public ghc-hostname
determine the hostname.")
(license license:bsd-3)))
+(define-public ghc-convertible
+ (package
+ (name "ghc-convertible")
+ (version "1.1.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/convertible/"
+ "convertible-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-time" ,ghc-old-time)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-text" ,ghc-text)))
+ (home-page "https://hackage.haskell.org/package/convertible")
+ (synopsis "Typeclasses and instances for converting between types")
+ (description
+ "This package provides a typeclass with a single function that is
+designed to help convert between different types: numeric values, dates and
+times, and the like. The conversions perform bounds checking and return a
+pure @code{Either} value. This means that you need not remember which specific
+function performs the conversion you desire.")
+ (license license:bsd-3)))
+
+(define-public ghc-double-conversion
+ (package
+ (name "ghc-double-conversion")
+ (version "2.0.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "double-conversion/double-conversion-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0sx2kc1gw72mjvd8vph8bbjw5whfxfv92rsdhjg1c0al75rf3ka4"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-text" ,ghc-text)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "https://github.com/bos/double-conversion")
+ (synopsis "Fast conversion between double precision floating point and text")
+ (description
+ "This package provides a library that performs fast, accurate conversion
+between double precision floating point and text.")
+ (license license:bsd-3)))
+
(define-public ghc-libxml
(package
(name "ghc-libxml")
"01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("libxml2" ,libxml2)))
+ `(("libxml2" ,libxml2)))
(arguments
`(#:configure-flags
`(,(string-append "--extra-include-dirs="
("ghc-exceptions" ,ghc-exceptions)
("ghc-multipart" ,ghc-multipart)
("ghc-network-uri" ,ghc-network-uri)
- ("ghc-network" ,ghc-network)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-network" ,ghc-network)))
(native-inputs
`(("ghc-doctest" ,ghc-doctest)
("ghc-quickcheck" ,ghc-quickcheck)))
(define-public ghc-cmdargs
(package
(name "ghc-cmdargs")
- (version "0.10.18")
+ (version "0.10.20")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1lnmcsf6p9yrwwz1zvrw5lbc32xpff7b70yz4ylawaflnlz6wrlh"))))
+ "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf"))))
(build-system haskell-build-system)
(home-page
"http://community.haskell.org/~ndm/cmdargs/")
(base32
"186ky3bly0i3cc56qk3r7j7pxh2108aackq4n2lli7jmbnb3kxsd"))))
(build-system haskell-build-system)
- (inputs
- `(("ghc-mtl" ,ghc-mtl)))
(home-page "https://hackage.haskell.org/package/happy")
(synopsis "Parser generator for Haskell")
(description "Happy is a parser generator for Haskell. Given a grammar
(inputs
`(("cpphs" ,cpphs)
("ghc-happy" ,ghc-happy)
- ("ghc-mtl" ,ghc-mtl)
("ghc-pretty-show" ,ghc-pretty-show-for-haskell-src-exts)))
(native-inputs
`(("ghc-smallcheck" ,ghc-smallcheck)
`(("ghc-transformers-base" ,ghc-transformers-base)
("ghc-monad-control" ,ghc-monad-control)
("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-mtl" ,ghc-mtl)
("ghc-mmorph" ,ghc-mmorph)
("ghc-exceptions" ,ghc-exceptions)
("ghc-unliftio-core" ,ghc-unliftio-core)))
(build-system haskell-build-system)
(inputs
`(("ghc-http" ,ghc-http)
- ("ghc-mtl" ,ghc-mtl)
("ghc-network-uri" ,ghc-network-uri)
("ghc-network" ,ghc-network)
("ghc-random" ,ghc-random)
(base32
"0bgd4jdmzxq5y465r4sf4jv2ix73yvblnr4c9wyazazafddamjny"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "1bk85avgc93yvcggwbk01fy8nvg6753wgmaanhkry0hz55h7mpld")))
(home-page "https://github.com/phadej/cabal-doctest")
(synopsis "Setup.hs helper for running doctests")
(description
@file{Setup.hs} files.")
(license license:bsd-3)))
-(define-public ghc-mtl
- (package
- (name "ghc-mtl")
- (version "2.2.1")
- (outputs '("out" "doc"))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/mtl/mtl-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
- (build-system haskell-build-system)
- ;; This is an official revision, relaxing the requirement transformers ==
- ;; 0.4 to transformers >= 0.4 && < 0.6; see
- ;; https://hackage.haskell.org/package/mtl-2.2.1/revision/1.cabal
- (arguments
- `(#:configure-flags (list "--allow-newer=transformers")))
- (home-page "https://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. See
-@uref{https://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
- (license license:bsd-3)))
-
(define-public ghc-parsec-numbers
(package
(name "ghc-parsec-numbers")
(define-public ghc-zlib
(package
(name "ghc-zlib")
- (version "0.6.1.1")
+ (version "0.6.2")
(outputs '("out" "doc"))
(source
(origin
".tar.gz"))
(sha256
(base32
- "0dd79dxf56d8f6ad9if3j87s9gg7yd17ckypjxwplrbkahlb9xf5"))))
+ "1vbzf0awb6zb456xf48za1kl22018646cfzq4frvxgb9ay97vk0d"))))
(build-system haskell-build-system)
- ;; Tests require older versions of testy.
- (arguments `(#:tests? #f))
+ (arguments `(#:configure-flags (list "--allow-newer=tasty")))
(inputs `(("zlib" ,zlib)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page "https://hackage.haskell.org/package/zlib")
(synopsis
"Compression and decompression in the gzip and zlib formats")
(build-system haskell-build-system)
(inputs
`(("ghc-parsec" ,ghc-parsec)
- ("ghc-concatenative" ,ghc-concatenative)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-concatenative" ,ghc-concatenative)))
(home-page "http://patch-tag.com/r/salazar/indents")
(synopsis "Indentation sensitive parser-combinators for parsec")
(description
(base32
"0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10"))))
(build-system haskell-build-system)
- (inputs
- `(("ghc-mtl" ,ghc-mtl)))
(home-page
"https://sourceforge.net/projects/lazy-regex")
(synopsis "Replaces/Enhances Text.Regex")
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)
- ("ghc-parsec" ,ghc-parsec)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-parsec" ,ghc-parsec)))
(home-page
"https://hackage.haskell.org/package/regex-tdfa")
(synopsis "Tagged DFA regex engine for Haskell")
"This provides an extra text interface for regex-tdfa.")
(license license:bsd-3)))
+(define-public ghc-regex
+ (package
+ (name "ghc-regex")
+ (version "1.0.1.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/regex/"
+ "regex-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
+ ("ghc-regex-tdfa" ,ghc-regex-tdfa)
+ ("ghc-regex-tdfa-text" ,ghc-regex-tdfa-text)
+ ("ghc-text" ,ghc-text)
+ ("ghc-time-locale-compat" ,ghc-time-locale-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-utf8-string" ,ghc-utf8-string)))
+ (home-page "http://regex.uk")
+ (synopsis "Toolkit for regex-base")
+ (description
+ "This package provides a regular expression toolkit for @code{regex-base}
+with compile-time checking of regular expression syntax, data types for
+matches and captures, a text replacement toolkit, portable options, high-level
+AWK-like tools for building text processing apps, regular expression macros
+with parsers and test bench, comprehensive documentation, tutorials and
+copious examples.")
+ (license license:bsd-3)))
+
(define-public ghc-parsers
(package
(name "ghc-parsers")
("ghc-fingertree" ,ghc-fingertree)
("ghc-hashable" ,ghc-hashable)
("ghc-lens" ,ghc-lens)
- ("ghc-mtl" ,ghc-mtl)
("ghc-parsers" ,ghc-parsers)
("ghc-profunctors" ,ghc-profunctors)
("ghc-quickcheck" ,ghc-quickcheck)
`(("ghc-old-time" ,ghc-old-time)
("ghc-digest" ,ghc-digest)
("zip" ,zip)
- ("ghc-mtl" ,ghc-mtl)
("ghc-temporary" ,ghc-temporary)
("ghc-text" ,ghc-text)
("ghc-zlib" ,ghc-zlib)))
(base32
"07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi"))))
(build-system haskell-build-system)
- (inputs `(("ghc-mtl" ,ghc-mtl)))
(home-page "http://code.haskell.org/~dolio/")
(synopsis "Backtracking logic-programming monad")
(description "This library provides a continuation-based, backtracking,
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(inputs
`(("ghc-stm" ,ghc-stm)
- ("ghc-mtl" ,ghc-mtl)
("ghc-transformers-compat" ,ghc-transformers-compat)))
(home-page "https://github.com/ekmett/exceptions/")
(synopsis "Extensible optionally-pure exceptions")
(define-public ghc-smallcheck
(package
(name "ghc-smallcheck")
- (version "1.1.1")
+ (version "1.1.5")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
+ "195fj7w3v03d1y1nm2ylavzrwxjcdbq0lb6zsw1dwyx5jmwfc84h"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-logict" ,ghc-logict)
- ("ghc-mtl" ,ghc-mtl)))
+ `(("ghc-logict" ,ghc-logict)))
(home-page
"https://github.com/feuerbach/smallcheck")
(synopsis "Property-based testing library")
"1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-mtl" ,ghc-mtl)))
+ `(("ghc-hunit" ,ghc-hunit)))
(home-page
"http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
(synopsis "Scrap Your Boilerplate")
(define-public ghc-fgl
(package
(name "ghc-fgl")
- (version "5.5.3.0")
+ (version "5.6.0.0")
(outputs '("out" "doc"))
(source
(origin
".tar.gz"))
(sha256
(base32
- "0fbyb6jxy9whgrv6dgnkzz70cmy98arx3q2gnkhgl4a3d7idh36p"))))
+ "1i6cp4b3w7sjk7y1dq3fh6bci2sm5h3lnbbaw9ln19nwncg2wwll"))))
(build-system haskell-build-system)
(arguments
- `(#:configure-flags (list "--allow-newer=QuickCheck")))
+ `(#:configure-flags (list "--allow-newer=QuickCheck"
+ "--allow-newer=hspec")))
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-hspec" ,ghc-hspec)
+ `(("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell")
(synopsis
"04jwwjs22mqc4hvpp4c3gpb79inrrq5sapks5khknspv2hslm61q"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-quickcheck" ,ghc-quickcheck)
+ `(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-random" ,ghc-random)
("ghc-syb" ,ghc-syb)))
(home-page "https://hackage.haskell.org/package/ChasingBottoms")
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
(inputs
- `(("ghc-text" ,ghc-text)
- ("ghc-mtl" ,ghc-mtl)))
+ `(("ghc-text" ,ghc-text)))
(arguments
`(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
(home-page
(build-system haskell-build-system)
(inputs
`(("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-mtl" ,ghc-mtl)
("ghc-parser-combinators" ,ghc-parser-combinators)
("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)))
(sha256
(base32 "0vmmlsj8ggbpwx6fkf5fvb6jp0zpx6iba6b28m80lllr2p8bi8wm"))))
(build-system haskell-build-system)
- (inputs `(("ghc-mtl" ,ghc-mtl)))
(home-page "http://rwd.rdockins.name/edison/home/")
(synopsis "Library of efficient, purely-functional data structures (API)")
(description
(base32 "06shxmcqxcahcn6zgl64vlqix4fnq53d97drcgsh94qp7gp201ry"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-quickcheck" ,ghc-quickcheck)
+ `(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-edisonapi" ,ghc-edisonapi)))
(home-page "http://rwd.rdockins.name/edison/home/")
(synopsis "Library of efficient, purely-functional data structures")
"1i8dzrc5qi3ryc9vrrmpn3sihmramsbhhd592w4w2k5g26qr3hql"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ `(("ghc-transformers-compat" ,ghc-transformers-compat)))
(home-page "https://hackage.haskell.org/package/mmorph")
(synopsis "Monad morphisms")
(description
(base32
"1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
(build-system haskell-build-system)
- (inputs `(("ghc-mtl" ,ghc-mtl)))
(home-page "http://hackage.haskell.org/package/IfElse")
(synopsis "Monadic control flow with anaphoric variants")
(description "This library provides functions for control flow inside of
(define-public ghc-easy-file
(package
(name "ghc-easy-file")
- (version "0.2.1")
+ (version "0.2.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz"))))
+ "0zmlcz723051qpn8l8vi51c5rx1blwrw4094jcshkmj8p9r2xxaj"))))
(build-system haskell-build-system)
(home-page
"https://github.com/kazu-yamamoto/easy-file")
(define-public ghc-optparse-applicative
(package
(name "ghc-optparse-applicative")
- (version "0.13.0.0")
+ (version "0.14.2.0")
(source
(origin
(method url-fetch)
"/optparse-applicative-" version ".tar.gz"))
(sha256
(base32
- "1b0c5fdq8bd070g24vrjrwlq979r8dk8mys6aji9hy1l9pcv3inf"))))
+ "0c3z1mvynlyv1garjbdmdd3npm40dabgm75js4r07cf766c1wd71"))))
(build-system haskell-build-system)
- ;; These tests fail because the package doesn't come with all needed test
- ;; files:
- ;; - prop_drops_back_contexts
- ;; - prop_context_carry
- ;; - prop_help_on_empty
- ;; - prop_help_on_empty_sub
- (arguments `(#:tests? #f))
(inputs
`(("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)))
("ghc-contravariant" ,ghc-contravariant)
("ghc-distributive" ,ghc-distributive)
("ghc-free" ,ghc-free)
- ("ghc-mtl" ,ghc-mtl)
("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-tagged" ,ghc-tagged)))
(home-page "https://github.com/ekmett/kan-extensions/")
("ghc-comonad" ,ghc-comonad)
("ghc-contravariant" ,ghc-contravariant)
("ghc-hashable" ,ghc-hashable)
- ("ghc-mtl" ,ghc-mtl)
("ghc-profunctors" ,ghc-profunctors)
("ghc-semigroups" ,ghc-semigroups)
("ghc-tagged" ,ghc-tagged)
"1hiqi7h76shjzs2zj0j8g6wnq2hbiq1hmfafdazr97fba2zl2432"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-text" ,ghc-text)
+ `(("ghc-text" ,ghc-text)
("ghc-blaze-html" ,ghc-blaze-html)
("ghc-xss-sanitize" ,ghc-xss-sanitize)
("ghc-data-default" ,ghc-data-default)
("ghc-bifunctors" ,ghc-bifunctors)
("ghc-comonad" ,ghc-comonad)
("ghc-distributive" ,ghc-distributive)
- ("ghc-mtl" ,ghc-mtl)
("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-semigroups" ,ghc-semigroups)))
(home-page "https://github.com/ekmett/free/")
("ghc-contravariant" ,ghc-contravariant)
("ghc-distributive" ,ghc-distributive)
("ghc-free" ,ghc-free)
- ("ghc-mtl" ,ghc-mtl)
("ghc-tagged" ,ghc-tagged)
("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-semigroups" ,ghc-semigroups)
(base32 "0a85bdyyvjqs5z4kfhhf758210k9gi9dv42ik66a3jl0z7aix8kx"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-stmonadtrans" ,ghc-stmonadtrans)
+ `(("ghc-stmonadtrans" ,ghc-stmonadtrans)
("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
(define-public ghc-integer-logarithms
(package
(name "ghc-integer-logarithms")
- (version "1.0.2")
+ (version "1.0.2.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0w5mhak181zi6qr5h2zbcs9ymaqacisp9jwk99naz6s8zz5rq1ii"))))
+ "1wj8kgjg5bn2yrs4zh9qfjv85cx6w998j9pi39yrbv305944mb9j"))))
(build-system haskell-build-system)
- (inputs
- `(("ghc-tasty" ,ghc-tasty)
- ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
- ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ (arguments
+ `(#:configure-flags (list "--allow-newer=tasty")))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-smallcheck" ,ghc-smallcheck)))
- (home-page "https://github.com/phadej/integer-logarithms")
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)))
+ (home-page "https://github.com/Bodigrim/integer-logarithms")
(synopsis "Integer logarithms")
(description
"This package provides the following modules:
(define-public ghc-scientific
(package
(name "ghc-scientific")
- (version "0.3.5.2")
+ (version "0.3.6.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0msnjz7ml0zycw9bssslxbg0nigziw7vs5km4q3vjbs8jpzpkr2w"))))
+ "03ql2f0ac8bsl524idy9xxa3kxisb2sj3avflzw580j5hzy0m397"))))
(build-system haskell-build-system)
(inputs
`(("ghc-integer-logarithms" ,ghc-integer-logarithms)
("ghc-text" ,ghc-text)
("ghc-hashable" ,ghc-hashable)
- ("ghc-primitive" ,ghc-primitive)
- ("ghc-tasty" ,ghc-tasty)
+ ("ghc-primitive" ,ghc-primitive)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
(define-public ghc-texmath
(package
(name "ghc-texmath")
- (version "0.10.1.1")
+ (version "0.11.0.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"texmath/texmath-" version ".tar.gz"))
(sha256
(base32
- "0q2fld5mdcd6j1n3rrg3bjpndbgbn17cwg0xbnvscrpa0s767jaj"))))
+ "11dc09hfnyfsz20ch2c867w0zdgjkzq41506lm61i3dk87ngdisf"))))
(build-system haskell-build-system)
(inputs
`(("ghc-syb" ,ghc-syb)
("ghc-utf8-string" ,ghc-utf8-string)
("ghc-xml" ,ghc-xml)
("ghc-parsec" ,ghc-parsec)
- ("ghc-mtl" ,ghc-mtl)
("ghc-pandoc-types" ,ghc-pandoc-types)))
(home-page "https://github.com/jgm/texmath")
(synopsis "Conversion between formats used to represent mathematics")
(base32
"129q33m56diiv35kdwfb07838wrg0mm88kxdqxfyl1zvf9nzkqkd"))))
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-network-uri" ,ghc-network-uri)
+ `(("ghc-network-uri" ,ghc-network-uri)
("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1)
("ghc-parsec" ,ghc-parsec)
("ghc-split" ,ghc-split)
(native-inputs
`(("ghc-parsec" ,ghc-parsec)
("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-utf8-string" ,ghc-utf8-string)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-utf8-string" ,ghc-utf8-string)))
(home-page "https://github.com/jgm/highlighting-kate")
(synopsis "Syntax highlighting library")
(description
"1b76zjxkj0v0n8zj9l0nwav2irm0c43rx6qjihfw8klmmxvx59df"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-safe" ,ghc-safe)
+ `(("ghc-safe" ,ghc-safe)
("ghc-th-expand-syns" ,ghc-th-expand-syns)))
(home-page "https://github.com/mgsloan/th-reify-many")
(synopsis "Recurseively reify template haskell datatype info")
`(("ghc-th-lift" ,ghc-th-lift)
("ghc-th-lift-instances" ,ghc-th-lift-instances)
("ghc-th-reify-many" ,ghc-th-reify-many)
- ("ghc-mtl" ,ghc-mtl)
("ghc-generic-deriving" ,ghc-generic-deriving)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)))
(define-public ghc-geniplate-mirror
(package
(name "ghc-geniplate-mirror")
- (version "0.7.5")
+ (version "0.7.6")
(source
(origin
(method url-fetch)
"/geniplate-mirror"
"/geniplate-mirror-" version ".tar.gz"))
(sha256
- (base32 "17vjps2118s5z3k39ij00lkmkxv3mqf8h59wv6qdamlgmhyr36si"))))
+ (base32 "1y0m0bw5zpm1y1y6d9qmxj3swl8j8hlw1shxbr5awycf6k884ssb"))))
(build-system haskell-build-system)
- (inputs `(("ghc-mtl" ,ghc-mtl)))
(home-page "https://github.com/danr/geniplate")
(synopsis "Use Template Haskell to generate Uniplate-like functions")
(description
("ghc-lifted-base" ,ghc-lifted-base)
("ghc-mono-traversable" ,ghc-mono-traversable)
("ghc-mmorph" ,ghc-mmorph)
- ("ghc-mtl" ,ghc-mtl)
("ghc-resourcet" ,ghc-resourcet)
("ghc-silently" ,ghc-silently)
("ghc-transformers-base" ,ghc-transformers-base)
"0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-unix-compat" ,ghc-unix-compat)))
+ `(("ghc-unix-compat" ,ghc-unix-compat)))
(home-page "https://github.com/bos/filemanip")
(synopsis "File and directory manipulation for Haskell")
(description
"14s57fgf6kd5n5al2kcvk1aaxbq1ph0r5h8blflrjkx83yl6r8yn"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-zlib" ,ghc-zlib)
+ `(("ghc-zlib" ,ghc-zlib)
("ghc-vector" ,ghc-vector)
("ghc-primitive" ,ghc-primitive)
("ghc-mmap" ,ghc-mmap)))
`(("lua" ,lua)
("ghc-exceptions" ,ghc-exceptions)
("ghc-fail" ,ghc-fail)
- ("ghc-mtl" ,ghc-mtl)
("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
"104d1yd84hclprg740nkz60vx589mnm094zriw6zczbgg8nkclym"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-old-locale" ,ghc-old-locale)))
+ `(("ghc-old-locale" ,ghc-old-locale)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-colour" ,ghc-colour)
("ghc-diff" ,ghc-diff)
("ghc-hxt" ,ghc-hxt)
- ("ghc-mtl" ,ghc-mtl)
("ghc-pretty-show" ,ghc-pretty-show)
("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
("ghc-safe" ,ghc-safe)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-diff" ,ghc-diff)
("ghc-hxt" ,ghc-hxt)
- ("ghc-mtl" ,ghc-mtl)
("ghc-pretty-show" ,ghc-pretty-show)
("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
("ghc-safe" ,ghc-safe)
("ghc-http-client-tls" ,ghc-http-client-tls)
("ghc-http-types" ,ghc-http-types)
("ghc-juicypixels" ,ghc-juicypixels)
- ("ghc-mtl" ,ghc-mtl)
("ghc-network" ,ghc-network)
("ghc-network-uri" ,ghc-network-uri)
("ghc-old-locale" ,ghc-old-locale)
("ghc-http-client-tls" ,ghc-http-client-tls)
("ghc-http-types" ,ghc-http-types)
("ghc-juicypixels" ,ghc-juicypixels)
- ("ghc-mtl" ,ghc-mtl)
("ghc-network" ,ghc-network)
("ghc-network-uri" ,ghc-network-uri)
("ghc-old-time" ,ghc-old-time)
(define-public ghc-xml-conduit
(package
(name "ghc-xml-conduit")
- (version "1.7.1.2")
+ (version "1.8.0.1")
(source
(origin
(method url-fetch)
"xml-conduit-" version ".tar.gz"))
(sha256
(base32
- "0n4k0rq9j5cc9kdvj9xbx8gmiqlyk5x6pw8yxzw5wfsw7qkych2s"))))
+ "177gmyigxql1pn3ncz0r8annwv5cbxnihbgrrg1dhm4gmc9jy2wq"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-doctest" ,ghc-doctest)
("ghc-resourcet" ,ghc-resourcet)
("ghc-text" ,ghc-text)
("ghc-xml-types" ,ghc-xml-types)
(define-public ghc-pandoc-citeproc
(package
(name "ghc-pandoc-citeproc")
- (version "0.12.2.5")
+ (version "0.14.3.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1l58nbflcnlznc93qimkk7ghk2gv8kipf45zf88piqa2zys41yyx"))))
+ "0yj6rckwsc9vig40cm15ry0j3d01xpk04qma9n4byhal6v4b5h22"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(add-after 'install 'post-install-check
(assoc-ref %standard-phases 'check)))))
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-pandoc-types" ,ghc-pandoc-types)
+ `(("ghc-pandoc-types" ,ghc-pandoc-types)
("ghc-pandoc" ,ghc-pandoc)
("ghc-tagsoup" ,ghc-tagsoup)
("ghc-aeson" ,ghc-aeson)
"0f8x8wyr6m21g8dnxvnvalz5bsq37l125l6qhs0fscbvprsxc4nb"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-parsec" ,ghc-parsec)
+ `(("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.")
(define-public ghc-sandi
(package
(name "ghc-sandi")
- (version "0.4.0") ; darcs-2.12.4 needs == 0.4.*
+ (version "0.4.2")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1smf3bq44qni4zbgxpw7cy7b9g95fbrr73j8njjf6139naj9bj20"))))
+ "0dvkpk91n9kz2ha04rvp231ra9sgd1ilyc1qkzf9l03iir7zrh9b"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stringsearch" ,ghc-stringsearch)
(sha256
(base32 "1nr26fnmi5fdjc6d00w13kjhmfyvb5b837d0006w4dj0yxndaksp"))))
(build-system haskell-build-system)
- (inputs
- `(("ghc-mtl" ,ghc-mtl)))
(home-page "https://hackage.haskell.org/package/STMonadTrans")
(synopsis "Monad transformer version of the ST monad")
(description
(define-public ghc-colour
(package
(name "ghc-colour")
- (version "2.3.3")
+ (version "2.3.4")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd"))))
+ "1sy51nz096sv91nxqk6yk7b92b5a40axv9183xakvki2nc09yhqg"))))
+ (arguments
+ ;; The tests for this package have the following dependency cycle:
+ ;; ghc-test-framework -> ghc-ansi-terminal -> ghc-colour.
+ `(#:tests? #f))
(build-system haskell-build-system)
(home-page "https://www.haskell.org/haskellwiki/Colour")
(synopsis "Model for human colour perception")
(define-public ghc-wl-pprint-text
(package
(name "ghc-wl-pprint-text")
- (version "1.1.0.4")
+ (version "1.2.0.0")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1xgizzimfw17mpmw2afvmnvyag976j8ggn7k5r564rkw9f0m6bgz"))))
+ "0g3w92rad6x5appfb22rbzcas2ix2h0hy91sdxhq8a4a5cnlrpa0"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-text" ,ghc-text)))
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-text" ,ghc-text)))
(home-page "https://hackage.haskell.org/package/wl-pprint-text")
(synopsis "Wadler/Leijen Pretty Printer for Text values")
(description
"0ln1szgfy8fa78l3issq4fx3aqnnd54w3cb4wssrfi48vd5rkfjm"))))
(build-system haskell-build-system)
(arguments
- `(#:configure-flags (list "--allow-newer=QuickCheck")))
+ `(#:configure-flags (list "--allow-newer=QuickCheck"
+ "--allow-newer=hspec")))
(inputs
`(("ghc-fgl" ,ghc-fgl)
("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-graphviz
(package
(name "ghc-graphviz")
- (version "2999.18.1.2")
+ (version "2999.20.0.2")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"graphviz/graphviz-" version ".tar.gz"))
(sha256
(base32
- "1z453is01v0rnxlv6xx4iyaqv5vrp3bpz829mpv1a341sck2135h"))))
+ "0kj7ap0gnliviq2p8lscw1m06capnsa90vpvcys24nqy5nw2wrp7"))))
(build-system haskell-build-system)
(arguments
`(#:configure-flags (list "--allow-newer=QuickCheck")))
("ghc-temporary" ,ghc-temporary)
("ghc-text" ,ghc-text)
("ghc-wl-pprint-text" ,ghc-wl-pprint-text)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("graphviz" ,graphviz)
+ ("hspec-discover" ,hspec-discover)))
(home-page "https://hackage.haskell.org/package/graphviz")
(synopsis "Bindings to Graphviz for graph visualisation")
(description
(build-system haskell-build-system)
(inputs
`(("ghc-hashable" ,ghc-hashable)
- ("ghc-mtl" ,ghc-mtl)
("ghc-transformers-compat" ,ghc-transformers-compat)))
(home-page "https://github.com/ekmett/constraints/")
(synopsis "Constraint manipulation")
("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)))
(define-public ghc-shelly
(package
(name "ghc-shelly")
- (version "1.7.0.1")
+ (version "1.8.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0a4ngy8jqcscqhimgiyz7f9kqm23is7x7gyjxr0j6iq1dy57ahq3"))))
+ "023fbvbqs5gdwm30j5517gbdcc7fvz0md70dgwgpypkskj3i926y"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-unix-compat" ,ghc-unix-compat)
+ `(("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-async" ,ghc-async)
("ghc-transformers-base" ,ghc-transformers-base)
("ghc-hunit" ,ghc-hunit)
- ("ghc-hspec" ,ghc-hspec)))
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-contrib" ,ghc-hspec-contrib)))
(home-page "https://github.com/yesodweb/Shelly.hs")
(synopsis "Shell-like (systems) programming in Haskell")
(description
"0as5gvlh6pi2gflakp695qnlizyyp059dqrhvjl4gjxalja6xjnp"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-network" ,ghc-network)
+ `(("ghc-network" ,ghc-network)
("ghc-old-locale" ,ghc-old-locale)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
(build-system haskell-build-system)
(inputs
`(("ghc-syb" ,ghc-syb)
- ("ghc-mtl" ,ghc-mtl)
("ghc-text" ,ghc-text)
("ghc-parsec" ,ghc-parsec)))
(home-page "https://hackage.haskell.org/package/json")
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-json" ,ghc-json)
- ("ghc-mtl" ,ghc-mtl)
("ghc-parsec" ,ghc-parsec)
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
(home-page "https://github.com/koalaman/shellcheck")
#t)))))
(inputs
`(("ghc-vector" ,ghc-vector)
- ("ghc-mtl" ,ghc-mtl)
("ghc-mwc-random" ,ghc-mwc-random)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
(build-system haskell-build-system)
(inputs `(("ghc-abstract-par" ,ghc-abstract-par)
("ghc-cereal" ,ghc-cereal)
- ("ghc-random" ,ghc-random)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-random" ,ghc-random)))
(home-page "https://github.com/simonmar/monad-par")
(synopsis "Combinators and extra features for Par monads for Haskell")
(description "This Haskell package provides additional data structures,
("ghc-abstract-deque" ,ghc-abstract-deque)
("ghc-monad-par-extras" ,ghc-monad-par-extras)
("ghc-mwc-random" ,ghc-mwc-random)
- ("ghc-parallel" ,ghc-parallel)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-parallel" ,ghc-parallel)))
(native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
(define-public ghc-base-prelude
(package
(name "ghc-base-prelude")
- (version "1.2.0.1")
+ (version "1.3")
(source
(origin
(method url-fetch)
"base-prelude-" version ".tar.gz"))
(sha256
(base32
- "17hivs7lmsglagdlzxd9q9zsddmgqin2788mpq911zwnb57lj6l1"))))
+ "1zk728sd09hh2r4xwz4lazsrrgg5cshydn64932sm0vckplndk73"))))
(build-system haskell-build-system)
(home-page "https://github.com/nikita-volkov/base-prelude")
(synopsis "The most complete prelude formed solely from the Haskell's base
"1h1nhswrcmhy3mq6vd530p0df51fcnnf4csbwnljar7cf0mb2h6y"))))
(build-system haskell-build-system)
(inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
- ("ghc-mtl" ,ghc-mtl)
("ghc-primitive" ,ghc-primitive)
("ghc-fail" ,ghc-fail)
("ghc-random" ,ghc-random)))
("ghc-free" ,ghc-free)
("ghc-monad-control" ,ghc-monad-control)
("ghc-manodrandom" ,ghc-monadrandom)
- ("ghc-mtl" ,ghc-mtl)
("ghc-mmorph" ,ghc-mmorph)
("ghc-profunctors" ,ghc-profunctors)
("ghc-semigroups" ,ghc-semigroups)
("ghc-contravariant" ,ghc-contravariant)
("ghc-contravariant-extras" ,ghc-contravariant-extras)
("ghc-semigroups" ,ghc-semigroups)
- ("ghc-mtl" ,ghc-mtl)
("ghc-either" ,ghc-either)
("ghc-fail" ,ghc-fail)
("ghc-base-prelude" ,ghc-base-prelude)))
("ghc-mono-traversable" ,ghc-mono-traversable)))
(native-inputs `(("ghc-hspec" ,ghc-hspec)
("ghc-silently" ,ghc-silently)
- ("ghc-mtl" ,ghc-mtl)
("ghc-safe" ,ghc-safe)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/snoyberg/mono-traversable")
("ghc-http-conduit" ,ghc-http-conduit)
("ghc-http-types" ,ghc-http-types)
("ghc-monad-control" ,ghc-monad-control)
- ("ghc-mtl" ,ghc-mtl)
("ghc-network" ,ghc-network)
("ghc-old-locale" ,ghc-old-locale)
("ghc-safe" ,ghc-safe)
(define-public ghc-basement
(package
(name "ghc-basement")
- (version "0.0.7")
+ (version "0.0.8")
(source
(origin
(method url-fetch)
"basement/basement-" version ".tar.gz"))
(sha256
(base32
- "0w2g4k9bs2ph00p0fgrmcrng8ypdz6xis0r10g380nzkg2rvj0dm"))))
+ "194jw567di4q2758943q9rrwkbf9gl261my7qc21i9xhyabipx67"))))
(build-system haskell-build-system)
(home-page "https://github.com/haskell-foundation/foundation")
(synopsis "Basic primitives for Foundation starter pack")
("ghc-transformers-base" ,ghc-transformers-base)
("ghc-monad-control" ,ghc-monad-control)
("ghc-monad-loops" ,ghc-monad-loops)
- ("ghc-mtl" ,ghc-mtl)
("ghc-blaze-builder" ,ghc-blaze-builder)
("ghc-exceptions" ,ghc-exceptions)))
(home-page "https://github.com/kazu-yamamoto/logger")
("ghc-blaze-html" ,ghc-blaze-html)
("ghc-blaze-markup" ,ghc-blaze-markup)
("ghc-silently" ,ghc-silently)
- ("ghc-mtl" ,ghc-mtl)
("ghc-fast-logger" ,ghc-fast-logger)
("ghc-scientific" ,ghc-scientific)
("ghc-tagged" ,ghc-tagged)))
(inputs `(("ghc-cereal" ,ghc-cereal)
("cabal-doctest" ,cabal-doctest)
("ghc-doctest" ,ghc-doctest-0.13)
- ("ghc-mtl" ,ghc-mtl)
("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)
("ghc-transformers-compat" ,ghc-transformers-compat)
(description "This package provides a library implementing the XDG Base Directory spec.")
(license license:bsd-3)))
+(define-public ghc-errorcall-eq-instance
+ (package
+ (name "ghc-errorcall-eq-instance")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "errorcall-eq-instance/errorcall-eq-instance-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0hqw82m8bbrxy5vgdwb83bhzdx070ibqrm9rshyja7cb808ahijm"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-orphans" ,ghc-base-orphans)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "http://hackage.haskell.org/package/errorcall-eq-instance")
+ (synopsis "Orphan Eq instance for ErrorCall")
+ (description
+ "Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}.
+This package provides an orphan instance.")
+ (license license:expat)))
+
+(define-public ghc-missingh
+ (package
+ (name "ghc-missingh")
+ (version "1.4.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/MissingH/"
+ "MissingH-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0wcvgrmav480w7nf4bl14yi0jq2yzanysxwzwas9hpb28vyjlgr8"))))
+ (build-system haskell-build-system)
+ ;; Tests require the unmaintained testpack package, which depends on the
+ ;; outdated QuickCheck version 2.7, which can no longer be built with
+ ;; recent versions of GHC and Haskell libraries.
+ (arguments '(#:tests? #f))
+ (inputs
+ `(("ghc-network" ,ghc-network)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-regex-compat" ,ghc-regex-compat)
+ ("ghc-hslogger" ,ghc-hslogger)
+ ("ghc-random" ,ghc-random)
+ ("ghc-old-time" ,ghc-old-time)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (native-inputs
+ `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "http://software.complete.org/missingh")
+ (synopsis "Large utility library")
+ (description
+ "MissingH is a library of all sorts of utility functions for Haskell
+programmers. It is written in pure Haskell and thus should be extremely
+portable and easy to use.")
+ (license license:bsd-3)))
+
+(define-public ghc-intervalmap
+ (package
+ (name "ghc-intervalmap")
+ (version "0.6.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/IntervalMap/"
+ "IntervalMap-" version ".tar.gz"))
+ (sha256
+ (base32
+ "06hin9wf1by8aqa7820fsi2339bh82184frkwz3jsb9sqa0hszcg"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://www.chr-breitkopf.de/comp/IntervalMap")
+ (synopsis "Containers for intervals, with efficient search")
+ (description
+ "This package provides ordered containers of intervals, with efficient
+search for all keys containing a point or overlapping an interval. See the
+example code on the home page for a quick introduction.")
+ (license license:bsd-3)))
+
+(define-public ghc-operational
+ (package
+ (name "ghc-operational")
+ (version "0.2.3.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/operational/"
+ "operational-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1x2abg2q9d26h1vzj40r6k7k3gqgappbs4g9d853vvg77837km4i"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)))
+ (home-page "http://wiki.haskell.org/Operational")
+ (synopsis "Implementation of difficult monads made easy with operational semantics")
+ (description
+ "This library makes it easy to implement monads with tricky control
+flow. This is useful for: writing web applications in a sequential style,
+programming games with a uniform interface for human and AI players and easy
+replay capababilities, implementing fast parser monads, designing monadic
+DSLs, etc.")
+ (license license:bsd-3)))
+
+(define-public ghc-gtk2hs-buildtools
+ (package
+ (name "ghc-gtk2hs-buildtools")
+ (version "0.13.4.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "gtk2hs-buildtools/gtk2hs-buildtools-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0yg6xmylgpylmnh5g33qwwn5x9bqckdvvv4czqzd9vrr12lnnghg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-hashtables" ,ghc-hashtables)))
+ (native-inputs
+ `(("ghc-alex" ,ghc-alex)
+ ("ghc-happy" ,ghc-happy)))
+ (home-page "http://projects.haskell.org/gtk2hs/")
+ (synopsis "Tools to build the Gtk2Hs suite of user interface libraries")
+ (description
+ "This package provides a set of helper programs necessary to build the
+Gtk2Hs suite of libraries. These tools include a modified c2hs binding tool
+that is used to generate FFI declarations, a tool to build a type hierarchy
+that mirrors the C type hierarchy of GObjects found in glib, and a generator
+for signal declarations that are used to call back from C to Haskell. These
+tools are not needed to actually run Gtk2Hs programs.")
+ (license license:gpl2)))
+
+(define-public ghc-chart
+ (package
+ (name "ghc-chart")
+ (version "1.8.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/Chart/"
+ "Chart-" version ".tar.gz"))
+ (sha256
+ (base32
+ "13s64fhb2pmkdmx5bkgbgcn25qjihs364fvr47a1dw25f804kiy1"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-lens" ,ghc-lens)
+ ("ghc-colour" ,ghc-colour)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-operational" ,ghc-operational)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/timbod7/haskell-chart/wiki")
+ (synopsis "Library for generating 2D charts and plots")
+ (description
+ "This package provides a library for generating 2D charts and plots, with
+backends provided by the @code{Cairo} and @code{Diagrams} libraries.")
+ (license license:bsd-3)))
+
+(define-public ghc-wcwidth
+ (package
+ (name "ghc-wcwidth")
+ (version "0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/wcwidth/wcwidth-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1n1fq7v64b59ajf5g50iqj9sa34wm7s2j3viay0kxpmvlcv8gipz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-setlocale" ,ghc-setlocale)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-attoparsec" ,ghc-attoparsec)))
+ (home-page "https://github.com/solidsnack/wcwidth/")
+ (synopsis "Haskell bindings to wcwidth")
+ (description "This package provides Haskell bindings to your system's
+native wcwidth and a command line tool to examine the widths assigned by it.
+The command line tool can compile a width table to Haskell code that assigns
+widths to the Char type.")
+ (license license:bsd-3)))
+
;;; haskell.scm ends here
HCoop / jackhill / guix / guix.git / blobdiff