diff options
Diffstat (limited to 'gnu/packages/haskell.scm')
| -rw-r--r-- | gnu/packages/haskell.scm | 3085 |
1 files changed, 2208 insertions, 877 deletions
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm index 759ca6044e..57435dca07 100644 --- a/gnu/packages/haskell.scm +++ b/gnu/packages/haskell.scm @@ -34,6 +34,7 @@ (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) @@ -42,6 +43,7 @@ #:use-module (gnu packages ghostscript) #:use-module (gnu packages gl) #:use-module (gnu packages graphviz) + #:use-module (gnu packages gtk) #:use-module (gnu packages haskell-check) #:use-module (gnu packages haskell-crypto) #:use-module (gnu packages haskell-web) @@ -322,7 +324,7 @@ top of CLISP.") 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") @@ -434,6 +436,130 @@ interactive environment for the functional language Haskell.") 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 @@ -471,7 +597,6 @@ determine the hostname.") (inputs `(("ghc-old-time" ,ghc-old-time) ("ghc-old-locale" ,ghc-old-locale) - ("ghc-mtl" ,ghc-mtl) ("ghc-text" ,ghc-text))) (home-page "https://hackage.haskell.org/package/convertible") (synopsis "Typeclasses and instances for converting between types") @@ -524,8 +649,7 @@ between double precision floating point and text.") "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi")))) (build-system haskell-build-system) (inputs - `(("ghc-mtl" ,ghc-mtl) - ("libxml2" ,libxml2))) + `(("libxml2" ,libxml2))) (arguments `(#:configure-flags `(,(string-append "--extra-include-dirs=" @@ -700,10 +824,119 @@ code pages on Windows. On all other operating systems, the library does nothing.") (license license:bsd-3))) +(define-public ghc-newtype-generics + (package + (name "ghc-newtype-generics") + (version "0.5.3") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "newtype-generics/newtype-generics-" + version ".tar.gz")) + (sha256 + (base32 + "0igyisw2djg19v9vkna1rwf47k97mvkvk4bbkmswznvbm00z15gj")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) + (home-page "http://github.com/sjakobi/newtype-generics") + (synopsis "Typeclass and set of functions for working with newtypes") + (description "The @code{Newtype} typeclass represents the packing and +unpacking of a newtype, and allows you to operate under that newtype with +functions such as @code{ala}. Generics support was added in version 0.4, +making this package a full replacement for the original newtype package, +and an alternative to newtype-th.") + (license license:bsd-3))) + +(define-public ghc-memotrie + (package + (name "ghc-memotrie") + (version "0.6.9") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/MemoTrie/MemoTrie-" + version + ".tar.gz")) + (sha256 + (base32 + "157p0pi6rrq74a35mq6zkkycv4ah7xhkbrcmnkb9xf7pznw4aq0x")))) + (build-system haskell-build-system) + (inputs + `(("ghc-newtype-generics" ,ghc-newtype-generics))) + (home-page "https://github.com/conal/MemoTrie") + (synopsis "Trie-based memo functions") + (description "This package provides a functional library for creating +efficient memo functions using tries.") + (license license:bsd-3))) + +(define-public ghc-tree-diff + (package + (name "ghc-tree-diff") + (version "0.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/tree-diff/tree-diff-" + version + ".tar.gz")) + (sha256 + (base32 + "049v44c520jy3icxlnrvbdblh3mjmvd7m6qmkzxbzkf02x63xqmz")))) + (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("4" "1rqxxyj6hqllahs11693g855cxz8mgnb490s7j1ksd300i5xgjsp") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "tree-diff.cabal" + (("trifecta >=1\\.7\\.1\\.1 && <1\\.8") + "trifecta >=1.7.1.1 && <=2"))))))) + (inputs + `(("ghc-aeson" ,ghc-aeson) + ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-base-compat" ,ghc-base-compat) + ("ghc-generics-sop" ,ghc-generics-sop) + ("ghc-hashable" ,ghc-hashable) + ("ghc-memotrie" ,ghc-memotrie) + ("ghc-parsec" ,ghc-parsec) + ("ghc-parsers" ,ghc-parsers) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-scientific" ,ghc-scientific) + ("ghc-tagged" ,ghc-tagged) + ("ghc-text" ,ghc-text) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-uuid-types" ,ghc-uuid-types) + ("ghc-vector" ,ghc-vector))) + (native-inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) + ("ghc-parsec" ,ghc-parsec) + ("ghc-trifecta" ,ghc-trifecta) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-golden" ,ghc-tasty-golden) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + (home-page "https://github.com/phadej/tree-diff") + (synopsis "Compute difference between (expression) trees") + (description "This Haskell library provides a function for computing +the difference bewteen (expression) trees. It also provides a way to +compute the difference between arbitrary abstract datatypes (ADTs) using +@code{Generics}-derivable helpers.") + (license license:bsd-3))) + (define-public ghc-haddock-library (package (name "ghc-haddock-library") - (version "1.4.3") + (version "1.5.0.1") (source (origin (method url-fetch) @@ -713,14 +946,37 @@ nothing.") ".tar.gz")) (sha256 (base32 - "0ns4bpf6whmcfl0cm2gx2c73if416x4q3ac4l4qm8w84h0zpcr7p")))) + "1cmbg8l5xrwpliclwy3l057raypjqy0hsg1h1743ahaj8gq10b7z")) + (patches (search-patches + "ghc-haddock-library-unbundle.patch")) + (modules '((guix build utils))) + (snippet '(begin + (delete-file-recursively "vendor") + #t)))) (build-system haskell-build-system) - (inputs - `(("ghc-base-compat" ,ghc-base-compat))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'relax-test-suite-dependencies + (lambda _ + (substitute* "haddock-library.cabal" + (("base-compat\\s*\\^>= 0\\.9\\.3") "base-compat") + (("hspec\\s*\\^>= 2\\.4\\.4") "hspec")))) + ;; The release tarball does not contain the "fixtures/examples" + ;; directory, which is required for testing. In the upstream + ;; repository, the directory exists and is populated. Here, we + ;; create an empty directory to placate the tests. + (add-before 'check 'add-examples-directory + (lambda _ + (mkdir "fixtures/examples") + #t))))) (native-inputs - `(("hspec-discover" ,hspec-discover) + `(("ghc-base-compat" ,ghc-base-compat) ("ghc-hspec" ,ghc-hspec) - ("ghc-quickcheck" ,ghc-quickcheck))) + ("ghc-optparse-applicative" ,ghc-optparse-applicative) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-tree-diff" ,ghc-tree-diff) + ("hspec-discover" ,hspec-discover))) (home-page "https://www.haskell.org/haddock/") (synopsis "Library exposing some functionality of Haddock") (description @@ -734,8 +990,7 @@ the ‘haddock’ package.") (define-public ghc-haddock-api (package (name "ghc-haddock-api") - ;; This is the last version to be supported by Cabal < 2.0 - (version "2.17.4") + (version "2.19.0.1") (source (origin (method url-fetch) @@ -745,8 +1000,18 @@ the ‘haddock’ package.") ".tar.gz")) (sha256 (base32 - "00fn6pzgg8xjbaw12d76jdqh2dbc5xy7miyz0x6kidvvar7i35ss")))) + "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "haddock-api.cabal" + (("Cabal \\^>= 2\\.0\\.0") + "Cabal ^>= 2.2.0") + (("hspec \\^>= 2\\.4\\.4") + "hspec >= 2.4.4 && < 2.6"))))))) (inputs `(("ghc-paths" ,ghc-paths) ("ghc-haddock-library" ,ghc-haddock-library))) @@ -785,7 +1050,7 @@ documentation-generation tool for Haskell libraries.") (define-public ghc-haddock (package (name "ghc-haddock") - (version "2.17.4") + (version "2.19.0.1") (source (origin (method url-fetch) @@ -795,16 +1060,37 @@ documentation-generation tool for Haskell libraries.") ".tar.gz")) (sha256 (base32 - "1z3h3v7w84dzsm47iavdppc2w899mr4c1agq9fzghgz902i0a655")))) + "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7")))) (build-system haskell-build-system) - ;; FIXME: Tests fail with this error: - ;; driver-test/Main.hs:4:1: error: - ;; Failed to load interface for ‘ResponseFileSpec’ - (arguments `(#:tests? #f)) + (arguments + `(#:phases + (modify-phases %standard-phases + ;; There are four test suites that require the ghc-haddock-test + ;; package, which no longer builds with GHC 8.4.3. This phase + ;; removes these four test suites from the Cabal file, so that we + ;; do not need ghc-haddock-test as an input. + (add-before 'configure 'remove-haddock-test-test-suites + (lambda _ + (use-modules (ice-9 rdelim)) + (with-atomic-file-replacement "haddock.cabal" + (lambda (in out) + (let loop ((line (read-line in 'concat)) (deleting? #f)) + (cond + ((eof-object? line) #t) + ((string-every char-set:whitespace line) + (unless deleting? (display line out)) + (loop (read-line in 'concat) #f)) + ((member line '("test-suite html-test\n" + "test-suite hypsrc-test\n" + "test-suite latex-test\n" + "test-suite hoogle-test\n")) + (loop (read-line in 'concat) #t)) + (else + (unless deleting? (display line out)) + (loop (read-line in 'concat) deleting?))))))))))) (inputs `(("ghc-haddock-api" ,ghc-haddock-api))) (native-inputs - `(("ghc-hspec" ,ghc-hspec) - ("ghc-haddock-test" ,ghc-haddock-test))) + `(("ghc-hspec" ,ghc-hspec))) (home-page "https://www.haskell.org/haddock/") (synopsis "Documentation-generation tool for Haskell libraries") @@ -815,7 +1101,7 @@ documentation-generation tool for Haskell libraries.") (define-public ghc-simple-reflect (package (name "ghc-simple-reflect") - (version "0.3.2") + (version "0.3.3") (source (origin (method url-fetch) @@ -825,7 +1111,7 @@ documentation-generation tool for Haskell libraries.") ".tar.gz")) (sha256 (base32 - "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq")))) + "0ayvrx5cm8n6db21jiyjmk5h93pw7cz1707hih09hlhk9jh5x0h7")))) (build-system haskell-build-system) (home-page "https://twanvl.nl/blog/haskell/simple-reflection-of-expressions") @@ -842,7 +1128,7 @@ them.") (define-public ghc-haskell-src (package (name "ghc-haskell-src") - (version "1.0.2.0") + (version "1.0.3.0") (source (origin (method url-fetch) @@ -852,7 +1138,7 @@ them.") ".tar.gz")) (sha256 (base32 - "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a")))) + "1g4dj1f0j68bhn4ixfac63wjzy6gsp6kwgxryb1k5nl3i0g99d5l")))) (build-system haskell-build-system) (inputs `(("ghc-happy" ,ghc-happy) @@ -871,7 +1157,7 @@ package are to parse or generate Haskell 98 code.") (define-public ghc-alex (package (name "ghc-alex") - (version "3.2.3") + (version "3.2.4") (source (origin (method url-fetch) @@ -881,9 +1167,20 @@ package are to parse or generate Haskell 98 code.") ".tar.gz")) (sha256 (base32 - "0bi1cs9b8ir33h1fl6x2xw4ymygapqbr713ridpf7rmk2wa7jqqs")))) + "0cpjixgsr0b2x4s6hz4aa6gnmjw9i7xd9nlfi8m37zqlidq4v3nm")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'check 'set-check-variables + (lambda _ + (setenv "PATH" (string-append (getcwd) "/dist/build/alex:" + (getenv "PATH"))) + (setenv "alex_datadir" (string-append (getcwd) "/data")) + #t))))) (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) + (native-inputs + `(("which" ,which))) (home-page "https://www.haskell.org/alex/") (synopsis "Tool for generating lexical analysers in Haskell") @@ -910,14 +1207,25 @@ tool lex or flex for C/C++.") "1hbpplss1m4rdpm4ibip6fpimlhssqa14fl338kl2jbc463i64cj")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck"))) + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "cgi.cabal" + (("exceptions < 0\\.9") + "exceptions < 0.11") + (("time >= 1\\.5 && < 1\\.7") + "time >= 1.5 && < 1.9") + (("doctest >= 0\\.8 && < 0\\.12") + "doctest >= 0.8 && < 0.17") + (("QuickCheck >= 2\\.8\\.1 && < 2\\.10") + "QuickCheck >= 2.8.1 && < 2.12"))))))) (inputs `(("ghc-parsec" ,ghc-parsec) ("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))) @@ -931,7 +1239,7 @@ tool lex or flex for C/C++.") (define-public ghc-cmdargs (package (name "ghc-cmdargs") - (version "0.10.18") + (version "0.10.20") (source (origin (method url-fetch) @@ -940,7 +1248,7 @@ tool lex or flex for C/C++.") version ".tar.gz")) (sha256 (base32 - "1lnmcsf6p9yrwwz1zvrw5lbc32xpff7b70yz4ylawaflnlz6wrlh")))) + "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf")))) (build-system haskell-build-system) (home-page "http://community.haskell.org/~ndm/cmdargs/") @@ -974,7 +1282,7 @@ postfix notation. For more information on stack based languages, see (define-public ghc-happy (package (name "ghc-happy") - (version "1.19.8") + (version "1.19.9") (source (origin (method url-fetch) @@ -984,10 +1292,8 @@ postfix notation. For more information on stack based languages, see ".tar.gz")) (sha256 (base32 - "186ky3bly0i3cc56qk3r7j7pxh2108aackq4n2lli7jmbnb3kxsd")))) + "138xpxdb7x62lpmgmb6b3v3vgdqqvqn4273jaap3mjmc2gla709y")))) (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 @@ -1018,7 +1324,7 @@ Happy works in a similar way to the yacc tool for C.") (define-public ghc-pretty-show (package (name "ghc-pretty-show") - (version "1.6.12") + (version "1.7") (source (origin (method url-fetch) @@ -1026,7 +1332,7 @@ Happy works in a similar way to the yacc tool for C.") "pretty-show-" version ".tar.gz")) (sha256 (base32 - "1fblcxw4z4ry14brin1mvwccs6hqqlhi7xhwv1f23szjq25cjacn")))) + "0br7pkxqqqhby2j2v1g847lgqsrasx56g1jw3dhmjh4flzs6warq")))) (build-system haskell-build-system) (inputs `(("ghc-haskell-lexer" ,ghc-haskell-lexer) @@ -1043,23 +1349,10 @@ complex generic values into an interactive Html page, for easier examination.") (license license:expat))) -(define-public ghc-pretty-show-for-haskell-src-exts - (package (inherit ghc-pretty-show) - (name "ghc-pretty-show") - (version "1.6.10") - (source - (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/pretty-show/" - "pretty-show-" version ".tar.gz")) - (sha256 - (base32 - "133s4l1gk46saf6ycm785rswycy8g3j0qqrv93b5wp8cp50kd0ww")))))) - (define-public ghc-haskell-src-exts (package (name "ghc-haskell-src-exts") - (version "1.20.1") + (version "1.20.2") (source (origin (method url-fetch) @@ -1069,13 +1362,12 @@ examination.") ".tar.gz")) (sha256 (base32 - "1jsjl9hja2dpcfq4mzlfpwyr6axwnwgacfb7aa070kz4lbygzaa8")))) + "1sm3z4v1p5yffg01ldgavz71s3bvfhjfa13k428rk14bpkl8crlz")))) (build-system haskell-build-system) (inputs `(("cpphs" ,cpphs) ("ghc-happy" ,ghc-happy) - ("ghc-mtl" ,ghc-mtl) - ("ghc-pretty-show" ,ghc-pretty-show-for-haskell-src-exts))) + ("ghc-pretty-show" ,ghc-pretty-show))) (native-inputs `(("ghc-smallcheck" ,ghc-smallcheck) ("ghc-tasty" ,ghc-tasty) @@ -1093,7 +1385,7 @@ patterns as per the HaRP extension as well as HSX-style embedded XML syntax.") (define-public ghc-haskell-src-exts-util (package (name "ghc-haskell-src-exts-util") - (version "0.2.2") + (version "0.2.3") (source (origin (method url-fetch) @@ -1102,7 +1394,7 @@ patterns as per the HaRP extension as well as HSX-style embedded XML syntax.") version ".tar.gz")) (sha256 (base32 - "14rhwcrdz3kfb69c64qn8kybl7wnpajrjlfz5p95ca4bva4mwclg")))) + "1803718paq89f8pdck4mb88hv2k1ah9lxzq0lgjgwi9n88ryycz8")))) (build-system haskell-build-system) (inputs `(("ghc-data-default" ,ghc-data-default) @@ -1141,7 +1433,7 @@ specify refactorings without depending on GHC.") (define-public hlint (package (name "hlint") - (version "2.1.1") + (version "2.1.10") (source (origin (method url-fetch) @@ -1150,7 +1442,7 @@ specify refactorings without depending on GHC.") "/" name "-" version ".tar.gz")) (sha256 (base32 - "0mmfavd158l5ig5wb1b1zbhbraj8hhqvbk4mg85n6c8ndpr4grd4")))) + "19as2m9g75cr6n1agzvsij0cvqhb0wbjlk31w4y5d5mns87dki0w")))) (build-system haskell-build-system) (inputs `(("cpphs" ,cpphs) @@ -1192,7 +1484,6 @@ unwanted suggestions, and to add your own custom suggestions.") `(("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))) @@ -1231,7 +1522,7 @@ OpenAL.") (define-public ghc-sdl (package (name "ghc-sdl") - (version "0.6.5.1") + (version "0.6.7.0") (source (origin (method url-fetch) @@ -1241,7 +1532,7 @@ OpenAL.") ".tar.gz")) (sha256 (base32 - "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46")))) + "00y67v80a8l09i3k76z09lg25kw72ivl09nag8ckdlk4a0cfnzfq")))) (build-system haskell-build-system) (inputs `(("sdl" ,sdl))) @@ -1257,7 +1548,7 @@ award winning Linux port of \"Civilization: Call To Power.\"") (define-public ghc-sdl-mixer (package (name "ghc-sdl-mixer") - (version "0.6.2.0") + (version "0.6.3.0") (source (origin (method url-fetch) @@ -1267,7 +1558,7 @@ award winning Linux port of \"Civilization: Call To Power.\"") ".tar.gz")) (sha256 (base32 - "1fhray79d80dk2aj9mx3ks05mm48sd832g8zgxli226jx471fs8r")))) + "0k26hqgdh789ka3mv4dsk6rin6x6vwcs6hjmnsqq7j3mnrh1342r")))) (build-system haskell-build-system) (arguments `(#:configure-flags @@ -1288,7 +1579,7 @@ MIDI, Ogg Vorbis, and SMPEG MP3 libraries.") (define-public ghc-sdl-image (package (name "ghc-sdl-image") - (version "0.6.1.2") + (version "0.6.2.0") (source (origin (method url-fetch) @@ -1298,7 +1589,7 @@ MIDI, Ogg Vorbis, and SMPEG MP3 libraries.") ".tar.gz")) (sha256 (base32 - "1ybdwlqi5nqzpsbh2md5mxhwmjn910iqysf6nykwjxlmvhcjk281")))) + "1gxwrvswgwjw6g7ym52gik22l9l3ljy592phv97jdmcf3gi6qcg1")))) (build-system haskell-build-system) (arguments `(#:configure-flags @@ -1318,7 +1609,7 @@ PNG, PNM, TGA, TIFF, XCF, XPM, XV.") (define-public ghc-half (package (name "ghc-half") - (version "0.2.2.3") + (version "0.3") (source (origin (method url-fetch) @@ -1327,8 +1618,11 @@ PNG, PNM, TGA, TIFF, XCF, XPM, XV.") version ".tar.gz")) (sha256 (base32 - "0p4sb7vv9cljv48wlx65wgdnkryrk5d6yfh7g4yrm20w1p449hl5")))) + "14r0nx8hm5fic9gz0ybjjw4kyc758zfgvhhwvzsshpx5caq6zch6")))) (build-system haskell-build-system) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck))) (home-page "https://github.com/ekmett/half") (synopsis "Half-precision floating-point computations") (description "This library provides a half-precision floating-point @@ -1358,7 +1652,7 @@ arithmetic.") (define-public ghc-openglraw (package (name "ghc-openglraw") - (version "3.2.7.0") + (version "3.3.1.0") (source (origin (method url-fetch) @@ -1368,7 +1662,7 @@ arithmetic.") ".tar.gz")) (sha256 (base32 - "024aln102d1mmsdalq9jd5mmwjbnrb8gxcak73lybrc7q87kswk2")))) + "1x8w3x308jldj2c1xqcq3a3sc2jc06pdpgqkgjsmixi1skv4a1vb")))) (build-system haskell-build-system) (inputs `(("ghc-half" ,ghc-half) @@ -1391,7 +1685,7 @@ found at runtime, a userError is thrown.") (define-public ghc-glut (package (name "ghc-glut") - (version "2.7.0.10") + (version "2.7.0.14") (source (origin (method url-fetch) @@ -1401,7 +1695,7 @@ found at runtime, a userError is thrown.") ".tar.gz")) (sha256 (base32 - "0sbm943bg896nf3qjmlnsg3zzrr3pl330rzh9g0hwv47nzwwn4ab")))) + "01i162fly4q1751fp60lgkzlb8kr0qqbvmxj74zc6skb19qggy2w")))) (build-system haskell-build-system) (inputs `(("ghc-statevar" ,ghc-statevar) @@ -1418,7 +1712,7 @@ programs.") (define-public ghc-gluraw (package (name "ghc-gluraw") - (version "2.0.0.2") + (version "2.0.0.4") (source (origin (method url-fetch) @@ -1428,7 +1722,7 @@ programs.") ".tar.gz")) (sha256 (base32 - "1phmvxr0kkxq89ykmr8rj77inj8dvcxd6h72z1ncdgdazfz3sjw8")))) + "1i2xi35n5z0d372px9mh6cyhgg1m0cfaiy3fnspkf6kbn9fgsqxq")))) (build-system haskell-build-system) (inputs `(("ghc-openglraw" ,ghc-openglraw))) @@ -1442,7 +1736,7 @@ basis for a nicer interface.") (define-public ghc-opengl (package (name "ghc-opengl") - (version "3.0.1.0") + (version "3.0.2.2") (source (origin (method url-fetch) @@ -1452,7 +1746,7 @@ basis for a nicer interface.") ".tar.gz")) (sha256 (base32 - "1nm2mzrn1h2nnfs9vl5p088hqpll7rdvcsyqsn8q641im9jhqp7l")))) + "19vxwvx2n8zq2klj176l25n2b64ybp0b8mhm4p46gvpcivz41fjc")))) (build-system haskell-build-system) (inputs `(("ghc-text" ,ghc-text) @@ -1531,7 +1825,7 @@ unlit literate code files; and an option to turn off macro-expansion.") (define-public ghc-reflection (package (name "ghc-reflection") - (version "2.1.2") + (version "2.1.4") (source (origin (method url-fetch) @@ -1541,7 +1835,7 @@ unlit literate code files; and an option to turn off macro-expansion.") ".tar.gz")) (sha256 (base32 - "0f9w0akbm6p8h7kzgcd2f6nnpw1wy84pqn45vfz1ch5j0hn8h2d9")))) + "0kf4a5ijw6jfnfibjcrpdy9vzh1n6v2pxia8dhyyqdissiwc8bzj")))) (build-system haskell-build-system) (inputs `(("ghc-tagged" ,ghc-tagged))) (home-page "https://github.com/ekmett/reflection") @@ -1568,7 +1862,8 @@ configurations to coexist without resorting to mutable global variables or (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=base"))) + `(#:cabal-revision + ("2" "04b9vn007hlvsrx4ksd3r8r3kbyaj2kvwxchdrmd4370qzi8p6gs"))) (home-page "https://hackage.haskell.org/package/old-locale") (synopsis "Adapt to locale conventions") (description @@ -1592,7 +1887,8 @@ date and time formats.") "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=base"))) + `(#:cabal-revision + ("2" "1j6ln1dkvhdvnwl33bp0xf9lhc4sybqk0aw42p8cq81xwwzbn7y9"))) (inputs `(("ghc-old-locale" ,ghc-old-locale))) (home-page "https://hackage.haskell.org/package/old-time") @@ -1670,10 +1966,111 @@ Writer monad), where list append quickly becomes too expensive.") versions of GHC (i.e., < 6.10).") (license license:bsd-3))) +(define-public ghc-echo + (package + (name "ghc-echo") + (version "0.1.3") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/echo/echo-" + version ".tar.gz")) + (sha256 + (base32 + "1vw5ykpwhr39wc0hhcgq3r8dh59zq6ib4zxbz1qd2wl21wqhfkvh")))) + (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l"))) + (home-page "https://github.com/RyanGlScott/echo") + (synopsis "Echo terminal input portably") + (description "The @code{base} library exposes the @code{hGetEcho} and +@code{hSetEcho} functions for querying and setting echo status, but +unfortunately, neither function works with MinTTY consoles on Windows. +This library provides an alternative interface which works with both +MinTTY and other consoles.") + (license license:bsd-3))) + +(define-public ghc-hackage-security + (package + (name "ghc-hackage-security") + (version "0.5.3.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "hackage-security/hackage-security-" + version ".tar.gz")) + (sha256 + (base32 + "08bwawc7ramgdh54vcly2m9pvfchp0ahhs8117jajni6x4bnx66v")))) + (build-system haskell-build-system) + (arguments + `(#:tests? #f)) ; Tests fail because of framework updates. + (inputs + `(("ghc-base16-bytestring" ,ghc-base16-bytestring) + ("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256) + ("ghc-ed25519" ,ghc-ed25519) + ("ghc-network" ,ghc-network) + ("ghc-network-uri" ,ghc-network-uri) + ("ghc-parsec" ,ghc-parsec) + ("ghc-tar" ,ghc-tar) + ("ghc-zlib" ,ghc-zlib))) + (native-inputs + `(("ghc-network-uri" ,ghc-network-uri) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-tar" ,ghc-tar) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-temporary" ,ghc-temporary) + ("ghc-zlib" ,ghc-zlib))) + (home-page "https://github.com/haskell/hackage-security") + (synopsis "Hackage security library") + (description "This Hackage security library provides both server and +client utilities for securing @uref{http://hackage.haskell.org/, the +Hackage package server}. It is based on +@uref{http://theupdateframework.com/, The Update Framework}, a set of +recommendations developed by security researchers at various universities +in the US as well as developers on the @uref{https://www.torproject.org/, +Tor project}.") + (license license:bsd-3))) + +(define-public ghc-resolv + (package + (name "ghc-resolv") + (version "0.1.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/resolv/resolv-" + version ".tar.gz")) + (sha256 + (base32 + "0wh7wj56l3f2bylz563g5g04a4nydj8acv60hpwa7k3mn792xca9")))) + (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "15ay4n3x8c09cb3h4z1nan84yd3n9zpgvi6h114hk98bq10k8mma") + #:tests? #f)) ; The required test frameworks are too old. + (inputs + `(("ghc-base16-bytestring" ,ghc-base16-bytestring))) + (home-page "https://github.com/haskell/hackage-security") + (synopsis "Domain Name Service (DNS) lookup via @code{libresolv}") + (description "This package implements an API for accessing the +@uref{https://tools.ietf.org/html/rfc1035, Domain Name Service (DNS)} +resolver service via the standard @code{libresolv} system library (whose +API is often available directly via the standard @code{libc} C library) on +Unix systems.") + (license license:gpl3))) + (define-public cabal-install (package (name "cabal-install") - (version "1.22.6.0") + (version "2.2.0.0") (source (origin (method url-fetch) @@ -1682,16 +2079,24 @@ versions of GHC (i.e., < 6.10).") version ".tar.gz")) (sha256 - (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx")))) + (base32 "1nd3ch7qr4dpfxhgkcq2lnhvszx2kjgnn1kwb44vk9y5jgfs4mn8")))) (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. (build-system haskell-build-system) (inputs - `(("ghc-http" ,ghc-http) - ("ghc-mtl" ,ghc-mtl) + `(("ghc-async" ,ghc-async) + ("ghc-base16-bytestring" ,ghc-base16-bytestring) + ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256) + ("ghc-echo" ,ghc-echo) + ("ghc-edit-distance" ,ghc-edit-distance) + ("ghc-hackage-security" ,ghc-hackage-security) + ("ghc-hashable" ,ghc-hashable) + ("ghc-http" ,ghc-http) ("ghc-network-uri" ,ghc-network-uri) ("ghc-network" ,ghc-network) ("ghc-random" ,ghc-random) + ("ghc-resolv" ,ghc-resolv) ("ghc-stm" ,ghc-stm) + ("ghc-tar" ,ghc-tar) ("ghc-zlib" ,ghc-zlib))) (home-page "https://www.haskell.org/cabal/") (synopsis "Command-line interface for Cabal and Hackage") @@ -1715,6 +2120,9 @@ installation of Haskell libraries and programs.") (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 @@ -1723,37 +2131,6 @@ configuration. This library provides the common bits for writing custom @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") @@ -1813,7 +2190,8 @@ School of Functional Programming', 1995. See (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=base"))) + `(#:cabal-revision + ("3" "02vhj5gykkqa2dyn7s6gn8is1b5fdn9xcqqvlls268g7cpv6rk38"))) (home-page "https://github.com/glguy/utf8-string/") (synopsis "Support for reading and writing UTF8 Strings") (description @@ -1846,7 +2224,7 @@ environment variables.") (define-public ghc-setlocale (package (name "ghc-setlocale") - (version "1.0.0.6") + (version "1.0.0.8") (source (origin (method url-fetch) (uri (string-append @@ -1854,7 +2232,7 @@ environment variables.") version "/setlocale-" version ".tar.gz")) (sha256 (base32 - "1rl8qb8vzv8fdbczy2dxwgn4cb68lfrjdxf2w8nn9wy1acqzcyjq")))) + "0sdrsmkhw08483d73ysgm2926fdbhii61br03lqpqw0lfzj4ilbd")))) (build-system haskell-build-system) (home-page "https://hackage.haskell.org/package/setlocale") (synopsis "Haskell bindings to setlocale") @@ -1865,14 +2243,14 @@ environment variables.") (define-public ghc-x11 (package (name "ghc-x11") - (version "1.8") + (version "1.9") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/X11/" "X11-" version ".tar.gz")) (sha256 - (base32 "13lxq36856fzp61y4api78vssykyh8fm2aplr0nsj18ymdm1c6sl")))) + (base32 "1f8dy6ckkyvpcv7zlniyv01cqjb9lgqscm8pml58cvwc7n38w4qh")))) (build-system haskell-build-system) (inputs `(("libx11" ,libx11) @@ -1917,7 +2295,7 @@ parts.") (define-public ghc-stringbuilder (package (name "ghc-stringbuilder") - (version "0.5.0") + (version "0.5.1") (source (origin (method url-fetch) @@ -1927,7 +2305,7 @@ parts.") ".tar.gz")) (sha256 (base32 - "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9")))) + "1fh3csx1wcssn8xyvl4ip4aprh9l4qyz2kk8mgjvqvc0vb2bsy6q")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests ; enabled @@ -1953,9 +2331,21 @@ literals.") (base32 "1vbzf0awb6zb456xf48za1kl22018646cfzq4frvxgb9ay97vk0d")))) (build-system haskell-build-system) - ;; Tests require older versions of testy. - (arguments `(#:tests? #f)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'strip-test-framework-constraints + (lambda _ + (substitute* "zlib.cabal" + (("tasty >= 0\\.8 && < 0\\.12") "tasty") + (("tasty-hunit >= 0\\.8 && < 0\\.10") "tasty-hunit") + (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck"))))))) (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") @@ -1999,7 +2389,7 @@ case with other forms of concurrent communication, such as locks or (define-public ghc-parallel (package (name "ghc-parallel") - (version "3.2.1.0") + (version "3.2.2.0") (outputs '("out" "doc")) (source (origin @@ -2010,7 +2400,7 @@ case with other forms of concurrent communication, such as locks or ".tar.gz")) (sha256 (base32 - "09l52k1gsn667lmv0pp052cbwkzkbhfivp51f2xkrlfzf6xwvqsd")))) + "1xkfi96w6yfpppd0nw1rnszdxmvifwzm699ilv6332ra3akm610p")))) (build-system haskell-build-system) (home-page "https://hackage.haskell.org/package/parallel") (synopsis "Parallel programming library") @@ -2045,7 +2435,7 @@ are not exception safe and can be broken by @code{killThread}.") (define-public ghc-text (package (name "ghc-text") - (version "1.2.2.2") + (version "1.2.3.0") (outputs '("out" "doc")) (source (origin @@ -2056,7 +2446,7 @@ are not exception safe and can be broken by @code{killThread}.") ".tar.gz")) (sha256 (base32 - "1y9d0zjs2ls0c574mr5xw7y3y49s62sd3wcn9lhpwz8a6q352iii")))) + "06iir7q99rnffzxi8gagn8w1k9m49368sbidgz634fv1gxib3q10")))) (build-system haskell-build-system) ;; The test dependencies depend on ghc-text: ghc-test-framework -> ghc-xml -> ghc-text (arguments `(#:tests? #f)) @@ -2120,7 +2510,7 @@ IO operations.") (define-public ghc-hashable (package (name "ghc-hashable") - (version "1.2.6.1") + (version "1.2.7.0") (outputs '("out" "doc")) (source (origin @@ -2131,7 +2521,7 @@ IO operations.") ".tar.gz")) (sha256 (base32 - "0ymv2mcrrgbdc2w39rib171fwnhg7fgp0sy4h8amrh1vw64qgjll")))) + "1gra8gq3kb7b2sd845h55yxlrfqx3ii004c6vjhga8v0b30fzdgc")))) (build-system haskell-build-system) (inputs `(("ghc-text" ,ghc-text) @@ -2151,6 +2541,14 @@ data structures. The package provides instances for basic types and a way to combine hash values.") (license license:bsd-3))) +(define-public ghc-hashable-bootstrap + (package + (inherit ghc-hashable) + (name "ghc-hashable-bootstrap") + (arguments `(#:tests? #f)) + (native-inputs '()) + (properties '((hidden? #t))))) + (define-public ghc-hashable-time (package (name "ghc-hashable-time") @@ -2166,6 +2564,9 @@ combine hash values.") (base32 "0k932nyd08l3xxbh2g3n76py2f4kd9yw4s5a065vjz0xp6wjnxdm")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "0rv40xkg3gj8jnqsry1gq3f5s5la6d5arg8fzkirnwdpcgha1as6"))) (inputs `(("ghc-hashable" ,ghc-hashable))) (home-page "http://hackage.haskell.org/package/hashable-time") (synopsis "Hashable instances for Data.Time") @@ -2293,7 +2694,7 @@ Hashing\" by Claessen, Pałka for details and the rationale of the design.") (define-public ghc-transformers-base (package (name "ghc-transformers-base") - (version "0.4.4") + (version "0.4.5.2") (source (origin (method url-fetch) @@ -2303,7 +2704,7 @@ Hashing\" by Claessen, Pałka for details and the rationale of the design.") ".tar.gz")) (sha256 (base32 - "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va")))) + "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h")))) (build-system haskell-build-system) (inputs `(("ghc-stm" ,ghc-stm) @@ -2321,7 +2722,7 @@ compatibility to run on old versions of the platform.") (define-public ghc-transformers-compat (package (name "ghc-transformers-compat") - (version "0.5.1.4") + (version "0.6.2") (source (origin (method url-fetch) @@ -2330,7 +2731,7 @@ compatibility to run on old versions of the platform.") "/transformers-compat-" version ".tar.gz")) (sha256 (base32 - "17yam0199fh9ndsn9n69jx9nvbsmymzzwbi23dck3dk4q57fz0fq")))) + "1gp4a8kvniwgm8947ghb4iwv4b7wd6ry4kvv4nfnym4agf5j41nw")))) (build-system haskell-build-system) (home-page "https://github.com/ekmett/transformers-compat/") (synopsis "Small compatibility shim between transformers 0.3 and 0.4") @@ -2343,7 +2744,7 @@ but also need those types.") (define-public ghc-unix-time (package (name "ghc-unix-time") - (version "0.3.7") + (version "0.3.8") (source (origin (method url-fetch) @@ -2353,7 +2754,7 @@ but also need those types.") ".tar.gz")) (sha256 (base32 - "1qdlc9raih8s0m3x8x3n7q3ngh4faw2alv9l78sp6gnx648k0c8i")))) + "051slgpid5cxiaw203ky0ql3823h28fcjs08axkzd4265wrvv8fw")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This @@ -2370,7 +2771,7 @@ for Unix time in Haskell.") (define-public ghc-unix-compat (package (name "ghc-unix-compat") - (version "0.4.2.0") + (version "0.5.1") (source (origin (method url-fetch) @@ -2380,7 +2781,7 @@ for Unix time in Haskell.") ".tar.gz")) (sha256 (base32 - "036nv05w0yjxc3rfpar60ddjrlzc40mdgr5k6ihvwlvqfmq1gw9m")))) + "0llwl7rp63fy2ychwdclz1afj45pbin5pfl01dvn6rwhvmwhr7d3")))) (build-system haskell-build-system) (home-page "https://github.com/jystic/unix-compat") @@ -2394,7 +2795,7 @@ isn't available, portable implementations are used.") (define-public ghc-indents (package (name "ghc-indents") - (version "0.3.3") + (version "0.5.0.0") (source (origin (method url-fetch) (uri (string-append @@ -2402,12 +2803,16 @@ isn't available, portable implementations are used.") version ".tar.gz")) (sha256 (base32 - "16lz21bp9j14xilnq8yym22p3saxvc9fsgfcf5awn2a6i6n527xn")))) + "1ly3v41jacc6lrsvg4j3m5a6zs90gr8dyif5m6bf34hj1k5cgg0n")))) (build-system haskell-build-system) + ;; This package needs an older version of tasty. + (arguments '(#:tests? #f)) (inputs `(("ghc-parsec" ,ghc-parsec) - ("ghc-concatenative" ,ghc-concatenative) - ("ghc-mtl" ,ghc-mtl))) + ("ghc-concatenative" ,ghc-concatenative))) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit))) (home-page "http://patch-tag.com/r/salazar/indents") (synopsis "Indentation sensitive parser-combinators for parsec") (description @@ -2419,7 +2824,7 @@ lines continued at an indented level below.") (define-public ghc-iproute (package (name "ghc-iproute") - (version "1.7.1") + (version "1.7.5") (source (origin (method url-fetch) @@ -2429,7 +2834,7 @@ lines continued at an indented level below.") ".tar.gz")) (sha256 (base32 - "1viyxq3m1aifl05w0hxwrhhhcfpmvwz4ymil2gngi4nfm0yd1f2p")))) + "1vw1nm3s8vz1hqnjnqd3wh5rr4q3m2r4izn5ynhf93h9185qwqzd")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder, ; exported by ghc-byteorder. Doctest issue. @@ -2482,8 +2887,6 @@ supported systems.") (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") @@ -2555,8 +2958,7 @@ Haskell library @code{regex-base}.") (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") @@ -2602,6 +3004,17 @@ Haskell library @code{regex-base}.") (base32 "1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'relax-dependencies + (lambda _ + (substitute* "regex.cabal" + (("base-compat.*>=.*0.6.*") + "base-compat >= 0.6\n") + (("template-haskell.*>=.*2.7.*") + "template-haskell >= 2.7\n")) + #t))))) (inputs `(("ghc-base-compat" ,ghc-base-compat) ("ghc-hashable" ,ghc-hashable) @@ -2627,7 +3040,7 @@ copious examples.") (define-public ghc-parsers (package (name "ghc-parsers") - (version "0.12.4") + (version "0.12.9") (source (origin (method url-fetch) @@ -2637,7 +3050,7 @@ copious examples.") ".tar.gz")) (sha256 (base32 - "07najh7f9y3ahh42z96sw4hnd0kc4x3wm0xlf739y0gh81ys5097")))) + "1r05sc1mcglk8w596kq9a1brfn9c2vll8lq16j07ln0vsz4jzrc1")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy ; -package attoparsec-0.13.0.1" @@ -2661,7 +3074,7 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s (define-public ghc-trifecta (package (name "ghc-trifecta") - (version "1.7.1.1") + (version "2") (source (origin (method url-fetch) (uri (string-append @@ -2669,11 +3082,10 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s "trifecta-" version ".tar.gz")) (sha256 (base32 - "13n6a3fdxngnzsjnhfrzigv1c2g0xm6lqkjcnirpc37sd0rpby31")))) + "0hznd8i65s81xy13i2qc7cvipw3lfb2yhkv53apbdsh6sbljz5sk")))) (build-system haskell-build-system) (inputs - `(("ghc-doctest" ,ghc-doctest-0.13) - ("ghc-reducers" ,ghc-reducers) + `(("ghc-reducers" ,ghc-reducers) ("ghc-semigroups" ,ghc-semigroups) ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) ("ghc-ansi-terminal" ,ghc-ansi-terminal) @@ -2682,18 +3094,17 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s ("ghc-blaze-markup" ,ghc-blaze-markup) ("ghc-charset" ,ghc-charset) ("ghc-comonad" ,ghc-comonad) - ("ghc-doctest" ,ghc-doctest) ("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-unordered-containers" ,ghc-unordered-containers) ("ghc-utf8-string" ,ghc-utf8-string))) (native-inputs - `(("cabal-doctest" ,cabal-doctest))) + `(("cabal-doctest" ,cabal-doctest) + ("ghc-doctest" ,ghc-doctest) + ("ghc-quickcheck" ,ghc-quickcheck))) (home-page "https://github.com/ekmett/trifecta/") (synopsis "Parser combinator library with convenient diagnostics") (description "Trifecta is a modern parser combinator library for Haskell, @@ -2703,7 +3114,7 @@ with slicing and Clang-style colored diagnostics.") (define-public ghc-time-locale-compat (package (name "ghc-time-locale-compat") - (version "0.1.1.3") + (version "0.1.1.5") (source (origin (method url-fetch) @@ -2712,7 +3123,7 @@ with slicing and Clang-style colored diagnostics.") version ".tar.gz")) (sha256 (base32 - "1vdcfr2hp9qh3ag90x6ikbdf42wiqpdylnplffna54bpnilbyi4i")))) + "0b2hmj8wwrfkndwzgm11qr496ca2ahwdxcj3m0ii91bxvrk1bzq7")))) (build-system haskell-build-system) (inputs `(("ghc-old-locale" ,ghc-old-locale))) (home-page "https://github.com/khibino/haskell-time-locale-compat") @@ -2736,10 +3147,19 @@ with slicing and Clang-style colored diagnostics.") (base32 "0j6qcwd146yzlkc9mcvzvnixsyl65n2a68l28322q5v9p4g4g4yx")))) (build-system haskell-build-system) - ;; FIXME: at least on test fails with QuickCheck > 2.9.2. Once upstream - ;; has updated the tests to work with a later version of QuickCheck we can - ;; re-enable them. - (arguments `(#:tests? #f)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'patch-for-newer-quickcheck + (lambda _ + (substitute* "attoparsec.cabal" + (("QuickCheck >= 2\\.7 && < 2\\.10") + "QuickCheck >= 2.7 && < 2.12")) + ;; This test fails because of the newer QuickCheck: + ;; <https://github.com/bos/attoparsec/issues/134>. + (substitute* "tests/QC/ByteString.hs" + ((", testProperty \"satisfyWith\" satisfyWith") + ""))))))) (inputs `(("ghc-scientific" ,ghc-scientific) ("ghc-text" ,ghc-text))) @@ -2756,10 +3176,21 @@ aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats.") (license license:bsd-3))) +(define-public ghc-attoparsec-bootstrap + (package + (inherit ghc-attoparsec) + (name "ghc-attoparsec-bootstrap") + (arguments `(#:tests? #f)) + (inputs + `(("ghc-scientific" ,ghc-scientific-bootstrap) + ("ghc-text" ,ghc-text))) + (native-inputs '()) + (properties '(hidden? #t)))) + (define-public ghc-zip-archive (package (name "ghc-zip-archive") - (version "0.3.0.5") + (version "0.3.3") (source (origin (method url-fetch) @@ -2769,18 +3200,16 @@ complicated text/binary file formats.") ".tar.gz")) (sha256 (base32 - "1iwpzjck4jg9bz1yqky051i2wljsqc14q5zbi10dydfp8ip3d0yw")))) + "0kf8xyac168bng8a0za2jwrbss7a4ralvci9g54hnvl0gkkxx2lq")))) (build-system haskell-build-system) (inputs - `(("ghc-old-time" ,ghc-old-time) - ("ghc-digest" ,ghc-digest) - ("zip" ,zip) - ("ghc-mtl" ,ghc-mtl) + `(("ghc-digest" ,ghc-digest) ("ghc-temporary" ,ghc-temporary) ("ghc-text" ,ghc-text) ("ghc-zlib" ,ghc-zlib))) (native-inputs - `(("ghc-hunit" ,ghc-hunit))) + `(("ghc-hunit" ,ghc-hunit) + ("unzip" ,unzip))) (home-page "https://hackage.haskell.org/package/zip-archive") (synopsis "Zip archive library for Haskell") (description "The zip-archive library provides functions for creating, @@ -2802,6 +3231,9 @@ modifying, and extracting files from zip archives in Haskell.") (base32 "0y566r97sfyvhsmd4yxiz4ns2mqgwf5bdbp56wgxl6wlkidq0wwi")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("6" "06bd38rf31yrvvy989r44pm0id3dsxwcp6nxg7wk6ccj3n2b8rzk"))) (inputs `(("ghc-tagged" ,ghc-tagged) ("ghc-base-orphans" ,ghc-base-orphans) @@ -2810,7 +3242,7 @@ modifying, and extracting files from zip archives in Haskell.") ("ghc-generic-deriving" ,ghc-generic-deriving))) (native-inputs `(("cabal-doctest" ,cabal-doctest) - ("ghc-doctest" ,ghc-doctest-0.12) + ("ghc-doctest" ,ghc-doctest) ("ghc-hspec" ,ghc-hspec) ("hspec-discover" ,hspec-discover))) (home-page "https://github.com/ekmett/distributive/") @@ -2822,7 +3254,7 @@ Dual to @code{Traversable}.") (define-public ghc-cereal (package (name "ghc-cereal") - (version "0.5.3.0") + (version "0.5.7.0") (source (origin (method url-fetch) @@ -2832,7 +3264,7 @@ Dual to @code{Traversable}.") ".tar.gz")) (sha256 (base32 - "1x4aib7nnaf4x2b9zlndq5n5zsqniw78jifkf55nhnbmvryf05n3")))) + "1j7imh2mzqcljld7sx0av69699955rpy3hzivi5723i6a9nszgbs")))) (build-system haskell-build-system) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck) @@ -2849,7 +3281,7 @@ parser isolation, and labeled blocks for better error messages.") (define-public ghc-comonad (package (name "ghc-comonad") - (version "5") + (version "5.0.4") (source (origin (method url-fetch) @@ -2859,10 +3291,11 @@ parser isolation, and labeled blocks for better error messages.") ".tar.gz")) (sha256 (base32 - "0anb36m9z52y9xsipxzj9w1b41b2rj8r389cxd6d20dplnfv3rbq")))) + "09g870c4flp4k3fgbibsd0mmfjani1qcpbcl685v8x89kxzrva3q")))) (build-system haskell-build-system) (native-inputs - `(("ghc-doctest" ,ghc-doctest))) + `(("cabal-doctest" ,cabal-doctest) + ("ghc-doctest" ,ghc-doctest))) (inputs `(("ghc-contravariant" ,ghc-contravariant) ("ghc-distributive" ,ghc-distributive) @@ -2877,7 +3310,7 @@ parser isolation, and labeled blocks for better error messages.") (define-public hscolour (package (name "hscolour") - (version "1.24.1") + (version "1.24.4") (source (origin (method url-fetch) @@ -2887,7 +3320,7 @@ parser isolation, and labeled blocks for better error messages.") ".tar.gz")) (sha256 (base32 - "1j3rpzjygh3igvnd1n2xn63bq68rs047cjxr2qi6xyfnivgf6vz4")))) + "079jwph4bwllfp03yfr26s5zc6m6kw3nhb1cggrifh99haq34cr4")))) (build-system haskell-build-system) (home-page "https://hackage.haskell.org/package/hscolour") (synopsis "Script to colourise Haskell code") @@ -2931,7 +3364,7 @@ Strings.") (define-public ghc-extra (package (name "ghc-extra") - (version "1.6.3") + (version "1.6.9") (source (origin (method url-fetch) @@ -2941,7 +3374,7 @@ Strings.") ".tar.gz")) (sha256 (base32 - "06ds0jlx6sljwdf63l154qbzia9mnsri79i9qm3xikky3nj9ia1m")))) + "0xxcpb00pgwi9cmy6a7ghh6rblxry42p8pz5ssfgj20fs1xwzj1b")))) (build-system haskell-build-system) (inputs `(("ghc-clock" ,ghc-clock) @@ -2969,6 +3402,9 @@ this package makes them available back to GHC 7.2.") (base32 "0s1pwjidbn761xk43pmzyvn99hm3psdifjd78ylki7f97aiyd0g9")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("2" "1ywlg9z8nlhd2avgb8c6gbkv8zyk7hvc25926bafyg0m0k8y1amq"))) (inputs `(("ghc-base-orphans" ,ghc-base-orphans) ("ghc-bifunctors" ,ghc-bifunctors) @@ -2985,7 +3421,7 @@ this package makes them available back to GHC 7.2.") (define-public ghc-reducers (package (name "ghc-reducers") - (version "3.12.2") + (version "3.12.3") (source (origin (method url-fetch) @@ -2995,7 +3431,7 @@ this package makes them available back to GHC 7.2.") ".tar.gz")) (sha256 (base32 - "1gbaa5x4zbvnbklcb0d4q4m8hk6w0gz4s0c4m288czi1nw43dl65")))) + "09wf8pl9ycglcv6qj5ba26gkg2s5iy81hsx9xp0q8na0cwvp71ki")))) (build-system haskell-build-system) (inputs `(("ghc-fingertree" ,ghc-fingertree) @@ -3035,7 +3471,7 @@ style.") (define-public ghc-safe (package (name "ghc-safe") - (version "0.3.9") + (version "0.3.17") (source (origin (method url-fetch) @@ -3045,8 +3481,10 @@ style.") ".tar.gz")) (sha256 (base32 - "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh")))) + "0p3yaf5slvyz1cyy51jq64c5rlp8yzwim8iy2dlnk42if4gc9ibr")))) (build-system haskell-build-system) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck))) (home-page "https://github.com/ndmitchell/safe#readme") (synopsis "Library of safe (exception free) functions") (description "This library provides wrappers around @code{Prelude} and @@ -3057,7 +3495,7 @@ exceptions.") (define-public ghc-generic-deriving (package (name "ghc-generic-deriving") - (version "1.11.1") + (version "1.12.2") (source (origin (method url-fetch) @@ -3067,8 +3505,10 @@ exceptions.") ".tar.gz")) (sha256 (base32 - "1sdh5hpcwvh3b6zvgfk3pr3hla8p88l82njnih880c0gk5zl53dk")))) + "1i7d6cpj9yhaqb79zays3nqchhaacacjz9bkc0zlwj73y5gvi22n")))) (build-system haskell-build-system) + (inputs + `(("ghc-th-abstraction" ,ghc-th-abstraction))) (native-inputs `(("ghc-hspec" ,ghc-hspec) ("hspec-discover" ,hspec-discover))) @@ -3120,7 +3560,6 @@ syntax and semantics as Perl 5.") (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, @@ -3155,7 +3594,7 @@ online}.") (define-public ghc-feed (package (name "ghc-feed") - (version "0.3.12.0") + (version "1.0.0.0") (source (origin (method url-fetch) @@ -3163,14 +3602,21 @@ online}.") "feed/feed-" version ".tar.gz")) (sha256 (base32 - "0hkrsinspg70bbm3hwqdrvivws6zya1hyk0a3awpaz82j4xnlbfc")))) + "05rgg7x1984mgfhkmz792xj8lhwjgznixhygzr8blf517lns2nck")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("4" "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d"))) (inputs - `(("ghc-old-locale" ,ghc-old-locale) + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-old-locale" ,ghc-old-locale) ("ghc-old-time" ,ghc-old-time) + ("ghc-safe" ,ghc-safe) + ("ghc-text" ,ghc-text) ("ghc-time-locale-compat" ,ghc-time-locale-compat) ("ghc-utf8-string" ,ghc-utf8-string) - ("ghc-xml" ,ghc-xml))) + ("ghc-xml-conduit" ,ghc-xml-conduit) + ("ghc-xml-types" ,ghc-xml-types))) (native-inputs `(("ghc-hunit" ,ghc-hunit) ("ghc-test-framework" ,ghc-test-framework) @@ -3184,7 +3630,7 @@ consuming feeds in both RSS (Really Simple Syndication) and Atom format.") (define-public ghc-exceptions (package (name "ghc-exceptions") - (version "0.8.3") + (version "0.10.0") (source (origin (method url-fetch) @@ -3194,16 +3640,15 @@ consuming feeds in both RSS (Really Simple Syndication) and Atom format.") ".tar.gz")) (sha256 (base32 - "1gl7xzffsqmigam6zg0jsglncgzxqafld2p6kb7ccp9xirzdjsjd")))) + "1ms9zansv0pwzwdjncvx4kf18lnkjy2p61hvjhvxmjx5bqp93p8y")))) (build-system haskell-build-system) - (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck"))) (native-inputs - `(("ghc-test-framework" ,ghc-test-framework) + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) ("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") @@ -3214,7 +3659,7 @@ for Haskell.") (define-public ghc-temporary (package (name "ghc-temporary") - (version "1.2.0.4") + (version "1.3") (source (origin (method url-fetch) @@ -3224,9 +3669,15 @@ for Haskell.") ".tar.gz")) (sha256 (base32 - "0qk741yqnpd69sksgks2vb7zi50rglp9m498lzw4sh268a017rsi")))) + "144qhwfwg37l3k313raf4ssiz16jbgwlm1nf4flgqpsbd69jji4c")))) (build-system haskell-build-system) - (inputs `(("ghc-exceptions" ,ghc-exceptions))) + (inputs + `(("ghc-exceptions" ,ghc-exceptions) + ("ghc-random" ,ghc-random))) + (native-inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit))) (home-page "https://www.github.com/batterseapower/temporary") (synopsis "Temporary file and directory support") (description "The functions for creating temporary files and directories @@ -3268,7 +3719,7 @@ This is a better maintained fork of the \"temporary\" package.") (define-public ghc-smallcheck (package (name "ghc-smallcheck") - (version "1.1.1") + (version "1.1.5") (source (origin (method url-fetch) @@ -3278,11 +3729,10 @@ This is a better maintained fork of the \"temporary\" package.") ".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") @@ -3318,7 +3768,7 @@ writing to stdout and other handles.") (define-public ghc-case-insensitive (package (name "ghc-case-insensitive") - (version "1.2.0.7") + (version "1.2.0.11") (outputs '("out" "doc")) (source (origin @@ -3329,7 +3779,7 @@ writing to stdout and other handles.") ".tar.gz")) (sha256 (base32 - "1j6ahvrz1g5q89y2difyk838yhwjc8z67zr0v2z512qdznc3h38n")))) + "1qrpxfirsxckg7jv28f5ah2qc8lh95hp7rnqkbqs1ahcwlbnvkm7")))) (build-system haskell-build-system) (inputs `(("ghc-hunit" ,ghc-hunit))) @@ -3352,7 +3802,7 @@ to cases.") (define-public ghc-syb (package (name "ghc-syb") - (version "0.6") + (version "0.7") (outputs '("out" "doc")) (source (origin @@ -3363,11 +3813,10 @@ to cases.") ".tar.gz")) (sha256 (base32 - "1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3")))) + "1da2zz7gqm4xbkx5vpd74dayx1svaxyl145fl14mq15lbb77sxdq")))) (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") @@ -3396,11 +3845,17 @@ variety of traversals.") "1i6cp4b3w7sjk7y1dq3fh6bci2sm5h3lnbbaw9ln19nwncg2wwll")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck" - "--allow-newer=hspec"))) + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "fgl.cabal" + (("QuickCheck >= 2\\.8 && < 2\\.10") + "QuickCheck >= 2.8 && < 2.12") + (("hspec >= 2\\.1 && < 2\\.5") + "hspec >= 2.1 && < 2.6"))))))) (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 @@ -3414,7 +3869,7 @@ encourages inductive, recursive definitions of graph algorithms.") (define-public ghc-chasingbottoms (package (name "ghc-chasingbottoms") - (version "1.3.1.3") + (version "1.3.1.4") (source (origin (method url-fetch) @@ -3422,11 +3877,10 @@ encourages inductive, recursive definitions of graph algorithms.") "ChasingBottoms-" version ".tar.gz")) (sha256 (base32 - "04jwwjs22mqc4hvpp4c3gpb79inrrq5sapks5khknspv2hslm61q")))) + "06cynx6hcbfpky7qq3b3mjjgwbnaxkwin3znbwq4b9ikiw0ng633")))) (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") @@ -3445,7 +3899,7 @@ Partial and Infinite Values\"}.") (define-public ghc-unordered-containers (package (name "ghc-unordered-containers") - (version "0.2.7.1") + (version "0.2.9.0") (outputs '("out" "doc")) (source (origin @@ -3455,7 +3909,7 @@ Partial and Infinite Values\"}.") "/unordered-containers-" version ".tar.gz")) (sha256 (base32 - "00npqiphivjp2d7ryqsdavfn4m5v3w1lq2azhdsrfh0wsvqpg4ig")))) + "0l4264p0av12cc6i8gls13q8y27x12z2ar4x34n3x59y99fcnc37")))) (build-system haskell-build-system) (inputs `(("ghc-chasingbottoms" ,ghc-chasingbottoms) @@ -3475,6 +3929,15 @@ optimized for performance critical use, both in terms of large data quantities and high speed.") (license license:bsd-3))) +(define-public ghc-unordered-containers-bootstrap + (package + (inherit ghc-unordered-containers) + (name "ghc-unordered-containers-bootstrap") + (arguments `(#:tests? #f)) + (inputs + `(("ghc-hashable" ,ghc-hashable-bootstrap))) + (properties '(hidden? #t)))) + (define-public ghc-uniplate (package (name "ghc-uniplate") @@ -3551,7 +4014,7 @@ a variety of ways.") (define-public ghc-wl-pprint (package (name "ghc-wl-pprint") - (version "1.2") + (version "1.2.1") (source (origin (method url-fetch) (uri (string-append @@ -3559,7 +4022,7 @@ a variety of ways.") version ".tar.gz")) (sha256 (base32 - "166zvk4zwn2zaa9kx66m1av38m34qp6h4i65bri2sfnxgvx0700r")))) + "0kn7y8pdrv8f87zhd5mifcl8fy3b2zvnzmzwhdqhxxlyzwiq6z0c")))) (build-system haskell-build-system) (home-page "https://hackage.haskell.org/package/wl-pprint") (synopsis "Wadler/Leijen pretty printer") @@ -3595,7 +4058,7 @@ colored output using the ansi-terminal package.") (define-public ghc-split (package (name "ghc-split") - (version "0.2.3.1") + (version "0.2.3.3") (outputs '("out" "doc")) (source (origin @@ -3606,7 +4069,7 @@ colored output using the ansi-terminal package.") ".tar.gz")) (sha256 (base32 - "12660m16c6sib3laaxn6w9s453pyx1b49myrmzfij372vq5bc5bn")))) + "04qlmkcyklznl03gsjg95b4nzb6i96gdapqg60rny9szgi7ngk8x")))) (build-system haskell-build-system) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck))) @@ -3620,7 +4083,7 @@ mainstream languages.") (define-public ghc-parsec (package (name "ghc-parsec") - (version "3.1.11") + (version "3.1.13.0") (outputs '("out" "doc")) (source (origin @@ -3630,13 +4093,12 @@ mainstream languages.") version ".tar.gz")) (sha256 - (base32 "0vk7q9j2128q191zf1sg0ylj9s9djwayqk9747k0a5fin4f2b1vg")))) + (base32 "1wc09pyn70p8z6llink10c8pqbh6ikyk554911yfwxv1g91swqbq")))) (build-system haskell-build-system) (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 @@ -3651,7 +4113,7 @@ is also parametric in the input stream type.") (define-public ghc-parser-combinators (package (name "ghc-parser-combinators") - (version "0.4.0") + (version "1.0.0") (source (origin (method url-fetch) @@ -3660,7 +4122,7 @@ is also parametric in the input stream type.") version ".tar.gz")) (sha256 (base32 - "1azkz0a6ikym02s8wydjcklp7rz8k512bs4s9lp9g1g03m0yj95i")))) + "1pwfdsklqwvaynwpdzmx1bs35mp6dpsyaqdnzxnqcrxwf5h8sk75")))) (build-system haskell-build-system) (home-page "https://github.com/mrkkrp/parser-combinators") (synopsis "Commonly useful parser combinators") @@ -3672,7 +4134,7 @@ combinators.") (define-public ghc-megaparsec (package (name "ghc-megaparsec") - (version "6.4.0") + (version "6.5.0") (source (origin (method url-fetch) @@ -3681,11 +4143,13 @@ combinators.") version ".tar.gz")) (sha256 (base32 - "0h9azhs0dfrc359vrbd1jljrg3yfdbwd4p62cxqkn7mnh8913jpd")))) + "12iggy7qpf8x93jm64zf0g215xwy779bqyfyjk2bhmxqqr1yzgdy")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("4" "0ij3asi5vwlhbgwsy6nhli9a0qb7926mg809fsgyl1rnhs9fvpx1"))) (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))) @@ -3720,7 +4184,10 @@ speed, flexibility, and quality of parse errors.") (build-system haskell-build-system) ;; FIXME: To simplify upgrading all Haskell packages, we leave the tests ;; disabled for now. - (arguments `(#:tests? #f)) + (arguments + `(#:cabal-revision + ("3" "0y5rh8k710i2a3p1h2rghvr5cfg78p5h0kbfi7ifxqqf6pzlyr1x") + #:tests? #f)) (inputs `(("ghc-primitive" ,ghc-primitive) ("ghc-random" ,ghc-random) @@ -3752,6 +4219,9 @@ optimisation framework.") (base32 "1y236jb72iab9ska1mc48z6yb0xgwmj45laaqdyjxksd84z7hbrb")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "196frl4akhfk7xf1nxzn8lmq99dxhzhsimanswn9yy7ym8zhki4i"))) (inputs `(("ghc-vector" ,ghc-vector))) (native-inputs @@ -3794,7 +4264,7 @@ interface.") (define-public ghc-network (package (name "ghc-network") - (version "2.6.3.1") + (version "2.6.3.6") (outputs '("out" "doc")) (source (origin @@ -3805,7 +4275,7 @@ interface.") ".tar.gz")) (sha256 (base32 - "1rl2gl37cf4k0ddsq93q15fwdz1l25nhl4w205krbh7d5dg5y12p")))) + "198mam7ahny48p9fajznbqq16a8ya2gw0xm3gnm1si1rmc4hdplv")))) (build-system haskell-build-system) ;; The regression tests depend on an unpublished module. (arguments `(#:tests? #f)) @@ -3854,7 +4324,7 @@ package into this package.") (define-public ghc-ansi-terminal (package (name "ghc-ansi-terminal") - (version "0.6.2.3") + (version "0.8.0.4") (source (origin (method url-fetch) @@ -3864,8 +4334,10 @@ package into this package.") ".tar.gz")) (sha256 (base32 - "0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d")))) + "0428gq8m3fdnb7ldcsyk97qcch76hcxbgh2666p6f76fs2qbhg7b")))) (build-system haskell-build-system) + (inputs + `(("ghc-colour" ,ghc-colour))) (home-page "https://github.com/feuerbach/ansi-terminal") (synopsis "ANSI terminal support for Haskell") (description "This package provides ANSI terminal support for Haskell. It @@ -3876,7 +4348,7 @@ cursor, and changing the title.") (define-public ghc-vault (package (name "ghc-vault") - (version "0.3.0.6") + (version "0.3.1.2") (source (origin (method url-fetch) @@ -3886,11 +4358,12 @@ cursor, and changing the title.") ".tar.gz")) (sha256 (base32 - "0j7gcs440q7qlgzi2hn36crgp2c0w69k40g6vj9hxlm31zk3shqb")))) + "072mbrihsdsb8c6xvg6lvk0rqjgvxvi8qkg4n6wwym5hq0pfa04y")))) (build-system haskell-build-system) (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers) - ("ghc-hashable" ,ghc-hashable))) + ("ghc-hashable" ,ghc-hashable) + ("ghc-semigroupoids" ,ghc-semigroupoids))) (home-page "https://github.com/HeinrichApfelmus/vault") (synopsis "Persistent store for arbitrary values") @@ -3914,7 +4387,6 @@ representing a store for a single element.") (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 @@ -3930,18 +4402,17 @@ finite maps and priority queues where the priority and element are distinct.") (define-public ghc-edisoncore (package (name "ghc-edisoncore") - (version "1.3.1.1") + (version "1.3.2.1") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/EdisonCore" "/EdisonCore-" version ".tar.gz")) (sha256 - (base32 "06shxmcqxcahcn6zgl64vlqix4fnq53d97drcgsh94qp7gp201ry")))) + (base32 "0fgj5iwiv3v2gdgx7kjcr15dcs4x1kvmjspp3p99wyhh0x6h3ikk")))) (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") @@ -3954,7 +4425,7 @@ with various performance characteristics.") (define-public ghc-mmorph (package (name "ghc-mmorph") - (version "1.0.6") + (version "1.1.2") (source (origin (method url-fetch) @@ -3964,11 +4435,10 @@ with various performance characteristics.") ".tar.gz")) (sha256 (base32 - "1i8dzrc5qi3ryc9vrrmpn3sihmramsbhhd592w4w2k5g26qr3hql")))) + "1gjz1ib968lqybma7my1n19qq6cdj6a7nskrlnwy4jy9jrwzs2n9")))) (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 @@ -3989,7 +4459,6 @@ manipulating monad transformer stacks.") (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 @@ -4000,7 +4469,7 @@ monads with anaphoric variants on @code{if} and @code{when} and a C-like (define-public ghc-monad-control (package (name "ghc-monad-control") - (version "1.0.1.0") + (version "1.0.2.3") (source (origin (method url-fetch) @@ -4009,7 +4478,7 @@ monads with anaphoric variants on @code{if} and @code{when} and a C-like "/monad-control-" version ".tar.gz")) (sha256 (base32 - "1x018gi5irznx5rgzmkr2nrgh26r8cvqwkcfc6n6y05pdjf21c6l")))) + "1c92833gr6cadidjdp8mlznkpp8lyxl0w3y7d19y8yi3klc3843c")))) (build-system haskell-build-system) (inputs `(("ghc-stm" ,ghc-stm) @@ -4121,7 +4590,7 @@ pragmas in your code.") (define-public ghc-blaze-builder (package (name "ghc-blaze-builder") - (version "0.4.0.2") + (version "0.4.1.0") (source (origin (method url-fetch) @@ -4131,7 +4600,7 @@ pragmas in your code.") ".tar.gz")) (sha256 (base32 - "1m33y6p5xldni8p4fzg8fmsyqvkfmnimdamr1xjnsmgm3dkf9lws")))) + "05681dih2d8s96an945wkbwl05w8ddbcfx8n3r3ck79ydyb8pz4i")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Missing test libraries. (inputs @@ -4149,7 +4618,7 @@ interoperate with code that uses the new implementation.") (define-public ghc-blaze-markup (package (name "ghc-blaze-markup") - (version "0.8.2.0") + (version "0.8.2.1") (source (origin (method url-fetch) @@ -4158,8 +4627,16 @@ interoperate with code that uses the new implementation.") version ".tar.gz")) (sha256 (base32 - "0m3h3ryxj5r74mv5g5dnfq5jbbwmvkl7ray18vi20d5vd93sydj4")))) + "0ih1c3qahkdgzbqihdhny5s313l2m66fbb88w8jbx7yz56y7rawh")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "blaze-markup.cabal" + (("tasty >= 1\\.0 && < 1\\.1") + "tasty >= 1.0 && < 1.2"))))))) (inputs `(("ghc-blaze-builder" ,ghc-blaze-builder) ("ghc-text" ,ghc-text))) @@ -4178,7 +4655,7 @@ library for Haskell.") (define-public ghc-easy-file (package (name "ghc-easy-file") - (version "0.2.1") + (version "0.2.2") (source (origin (method url-fetch) @@ -4188,7 +4665,7 @@ library for Haskell.") ".tar.gz")) (sha256 (base32 - "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz")))) + "0zmlcz723051qpn8l8vi51c5rx1blwrw4094jcshkmj8p9r2xxaj")))) (build-system haskell-build-system) (home-page "https://github.com/kazu-yamamoto/easy-file") @@ -4199,7 +4676,7 @@ library for Haskell.") (define-public ghc-async (package (name "ghc-async") - (version "2.1.1.1") + (version "2.2.1") (source (origin (method url-fetch) @@ -4209,10 +4686,11 @@ library for Haskell.") ".tar.gz")) (sha256 (base32 - "1qj4fp1ynwg0l453gmm27vgkzb5k5m2hzdlg5rdqi9kf8rqy90yd")))) + "09whscli1q5z7lzyq9rfk0bq1ydplh6pjmc6qv0x668k5818c2wg")))) (build-system haskell-build-system) (inputs `(("ghc-stm" ,ghc-stm) + ("ghc-hashable" ,ghc-hashable) ("ghc-hunit" ,ghc-hunit) ("ghc-test-framework" ,ghc-test-framework) ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) @@ -4227,7 +4705,7 @@ will eventually deliver a value of type @code{a}.") (define-public ghc-fingertree (package (name "ghc-fingertree") - (version "0.1.3.0") + (version "0.1.4.1") (source (origin (method url-fetch) @@ -4236,7 +4714,7 @@ will eventually deliver a value of type @code{a}.") version ".tar.gz")) (sha256 (base32 - "1ryjj7qrx70ckcjlr02x9zh86kfp76azbxq05r7hawqkaqg44sfs")))) + "192fyzv0pn1437wdpqg1l80rswkk4rw3w61r4bq7dhv354bdqy4p")))) (build-system haskell-build-system) (native-inputs `(("ghc-hunit" ,ghc-hunit) @@ -4256,7 +4734,7 @@ simple general-purpose data structure\".") (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) @@ -4265,15 +4743,8 @@ simple general-purpose data structure\".") "/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))) @@ -4288,7 +4759,7 @@ command line options in Haskell.") (define-public ghc-base-orphans (package (name "ghc-base-orphans") - (version "0.6") + (version "0.7") (source (origin (method url-fetch) @@ -4298,7 +4769,7 @@ command line options in Haskell.") ".tar.gz")) (sha256 (base32 - "03mdww5j0gwai7aqlx3m71ldmjcr99jzpkcclzjfclk6a6kjla67")))) + "057f9npnqk71ccfh95djfkpd54dzazphj06grwxa3fyhwcwxrb8a")))) (build-system haskell-build-system) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck) @@ -4346,6 +4817,9 @@ periodic, on-demand actions in Haskell.") (base32 "16cdzh0bw16nvjnyyy5j9s60malhz4nnazw96vxb0xzdap4m2z74")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("2" "0r2knfcq0b4s652vlvlnfwxlc2mkc2ra9kl8bp4zdn1awmfy0ia5"))) (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat))) (home-page "https://hackage.haskell.org/package/tagged") @@ -4357,7 +4831,7 @@ having to unsafely pass dummy arguments.") (define-public ghc-unbounded-delays (package (name "ghc-unbounded-delays") - (version "0.1.0.9") + (version "0.1.1.0") (source (origin (method url-fetch) @@ -4367,7 +4841,7 @@ having to unsafely pass dummy arguments.") ".tar.gz")) (sha256 (base32 - "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420")))) + "1ir9fghbrc214c97bwafk5ck6cacxz1pdnq4i18p604d1b8zg9wa")))) (build-system haskell-build-system) (home-page "https://github.com/basvandijk/unbounded-delays") (synopsis "Unbounded thread delays and timeouts") @@ -4449,7 +4923,7 @@ Compatibility package for older packages.") (define-public ghc-nats (package (name "ghc-nats") - (version "1.1.1") + (version "1.1.2") (source (origin (method url-fetch) @@ -4459,7 +4933,7 @@ Compatibility package for older packages.") ".tar.gz")) (sha256 (base32 - "1kfl2yy97nb7q0j17v96rl73xvi3z4db9bk0xychc76dax41n78k")))) + "1v40drmhixck3pz3mdfghamh73l4rp71mzcviipv1y8jhrfxilmr")))) (build-system haskell-build-system) (arguments `(#:haddock? #f)) (inputs @@ -4469,10 +4943,18 @@ Compatibility package for older packages.") (description "This library provides the natural numbers for Haskell.") (license license:bsd-3))) +(define-public ghc-nats-bootstrap + (package + (inherit ghc-nats) + (name "ghc-nats-bootstrap") + (inputs + `(("ghc-hashable" ,ghc-hashable-bootstrap))) + (properties '((hidden? #t))))) + (define-public ghc-void (package (name "ghc-void") - (version "0.7.1") + (version "0.7.2") (source (origin (method url-fetch) @@ -4482,7 +4964,7 @@ Compatibility package for older packages.") ".tar.gz")) (sha256 (base32 - "1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69")))) + "0aygw0yb1h3yhmfl3bkwh5d3h0l4mmsxz7j53vdm6jryl1kgxzyk")))) (build-system haskell-build-system) (inputs `(("ghc-semigroups" ,ghc-semigroups) @@ -4495,10 +4977,47 @@ Compatibility package for older packages.") given term should not exist.") (license license:bsd-3))) +(define-public ghc-invariant + (package + (name "ghc-invariant") + (version "0.5.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/invariant/invariant-" + version ".tar.gz")) + (sha256 + (base32 + "0aqj7z55632qdg45074kgn9qfdxzb0a2f8lgjzr0l0i4mm2rr37b")))) + (build-system haskell-build-system) + (inputs + `(("ghc-bifunctors" ,ghc-bifunctors) + ("ghc-comonad" ,ghc-comonad) + ("ghc-contravariant" ,ghc-contravariant) + ("ghc-profunctors" ,ghc-profunctors) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-statevar" ,ghc-statevar) + ("ghc-stm" ,ghc-stm) + ("ghc-tagged" ,ghc-tagged) + ("ghc-th-abstraction" ,ghc-th-abstraction) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/nfrisby/invariant-functors") + (synopsis "Haskell98 invariant functors") + (description "Haskell98 invariant functors (also known as exponential +functors). For more information, see Edward Kmett's article +@uref{http://comonad.com/reader/2008/rotten-bananas/, Rotten Bananas}.") + (license license:bsd-2))) + (define-public ghc-kan-extensions (package (name "ghc-kan-extensions") - (version "5.0.1") + (version "5.2") (source (origin (method url-fetch) @@ -4508,7 +5027,7 @@ given term should not exist.") ".tar.gz")) (sha256 (base32 - "1qm0kf4krmyjbjynn96ab0h3q117vwcia5nin7n2b8b4f3jrzph1")))) + "1lyvyiwwh962j2nnnsqzlvp5zq6z8p3spvhmji99cjvldxc7wwkb")))) (build-system haskell-build-system) (inputs `(("ghc-adjunctions" ,ghc-adjunctions) @@ -4516,9 +5035,10 @@ given term should not exist.") ("ghc-contravariant" ,ghc-contravariant) ("ghc-distributive" ,ghc-distributive) ("ghc-free" ,ghc-free) - ("ghc-mtl" ,ghc-mtl) + ("ghc-invariant" ,ghc-invariant) ("ghc-semigroupoids" ,ghc-semigroupoids) - ("ghc-tagged" ,ghc-tagged))) + ("ghc-tagged" ,ghc-tagged) + ("ghc-transformers-compat" ,ghc-transformers-compat))) (home-page "https://github.com/ekmett/kan-extensions/") (synopsis "Kan extensions library") (description "This library provides Kan extensions, Kan lifts, various @@ -4557,7 +5077,7 @@ call stacks with different versions of the compiler.") (define-public ghc-statevar (package (name "ghc-statevar") - (version "1.1.0.4") + (version "1.1.1.1") (source (origin (method url-fetch) @@ -4567,7 +5087,7 @@ call stacks with different versions of the compiler.") ".tar.gz")) (sha256 (base32 - "1dzz9l0haswgag9x56q7n57kw18v7nhmzkjyr61nz9y9npn8vmks")))) + "08r2iw0gdmfs4f6wraaq19vfmkjdbics3dbhw39y7mdjd98kcr7b")))) (build-system haskell-build-system) (inputs `(("ghc-stm" ,ghc-stm))) @@ -4580,7 +5100,7 @@ in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.") (define-public ghc-lens (package (name "ghc-lens") - (version "4.15.4") + (version "4.16.1") (source (origin (method url-fetch) @@ -4588,12 +5108,14 @@ in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.") version ".tar.gz")) (sha256 (base32 - "1lkwlnhgpgnsz046mw4qs0fa7h4l012gilrr3nf3spllsy3pnbkl")))) + "1im4drhbydbawd6i0jsrzpqihnmx4ywpkg7yg94ddwsw3mxwkgpm")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("2" "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri"))) (inputs `(("ghc-base-orphans" ,ghc-base-orphans) ("ghc-bifunctors" ,ghc-bifunctors) - ("ghc-doctest" ,ghc-doctest-0.13) ("ghc-distributive" ,ghc-distributive) ("ghc-exceptions" ,ghc-exceptions) ("ghc-free" ,ghc-free) @@ -4606,7 +5128,6 @@ in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.") ("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) @@ -4620,6 +5141,7 @@ in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.") ("hlint" ,hlint))) (native-inputs `(("cabal-doctest" ,cabal-doctest) + ("ghc-doctest" ,ghc-doctest) ("ghc-hunit" ,ghc-hunit) ("ghc-test-framework" ,ghc-test-framework) ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) @@ -4650,8 +5172,7 @@ indexed variants.") "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) @@ -4669,7 +5190,7 @@ cross-site scripting (@dfn{XSS}) attacks.") (define-public ghc-bifunctors (package (name "ghc-bifunctors") - (version "5.5.2") + (version "5.5.3") (source (origin (method url-fetch) @@ -4679,7 +5200,7 @@ cross-site scripting (@dfn{XSS}) attacks.") ".tar.gz")) (sha256 (base32 - "04fbsysm6zl8kmvqgffmrqa9bxl9dl2gibrd51asqzg737mb4ark")))) + "1jn9rxg643xnlhrknmjz88nblcpsr45xwjkwwnn5nxpasa7m4d6l")))) (build-system haskell-build-system) (inputs `(("ghc-base-orphans" ,ghc-base-orphans) @@ -4700,7 +5221,7 @@ cross-site scripting (@dfn{XSS}) attacks.") (define-public ghc-semigroupoids (package (name "ghc-semigroupoids") - (version "5.1") + (version "5.2.2") (source (origin (method url-fetch) @@ -4710,9 +5231,11 @@ cross-site scripting (@dfn{XSS}) attacks.") ".tar.gz")) (sha256 (base32 - "0dgqc59p4xx5cl8qkpm6sn4wd3n59rq7l6din76hf10bnklqrb0n")))) + "17i96y4iqj8clcs090lf6k0ij3j16nj14vsfwz0mm9nd6i4gbpp4")))) (build-system haskell-build-system) - (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem. + (arguments + `(#:cabal-revision + ("4" "0pqfrxzypjq6z8lgdkzq4vhcyqkpk5326hny0r6snpc3gm78r4ij"))) (inputs `(("ghc-base-orphans" ,ghc-base-orphans) ("ghc-transformers-compat" ,ghc-transformers-compat) @@ -4720,8 +5243,13 @@ cross-site scripting (@dfn{XSS}) attacks.") ("ghc-comonad" ,ghc-comonad) ("ghc-contravariant" ,ghc-contravariant) ("ghc-distributive" ,ghc-distributive) + ("ghc-hashable" ,ghc-hashable) ("ghc-semigroups" ,ghc-semigroups) - ("ghc-tagged" ,ghc-tagged))) + ("ghc-tagged" ,ghc-tagged) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (native-inputs + `(("cabal-doctest" ,cabal-doctest) + ("ghc-doctest" ,ghc-doctest))) (home-page "https://github.com/ekmett/semigroupoids") (synopsis "Semigroupoids operations for Haskell") (description "This library provides a wide array of (semi)groupoids and @@ -4737,7 +5265,7 @@ just a @code{Semigroup} are added.") (define-public ghc-contravariant (package (name "ghc-contravariant") - (version "1.4") + (version "1.4.1") (source (origin (method url-fetch) @@ -4747,7 +5275,7 @@ just a @code{Semigroup} are added.") ".tar.gz")) (sha256 (base32 - "117fff8kkrvlmr8cb2jpj71z7lf2pdiyks6ilyx89mry6zqnsrp1")))) + "1vfhk8c5cxmmakx7rflap1ipkx5q0j5vnlrcz7yz6y53kxhksgf9")))) (build-system haskell-build-system) (inputs `(("ghc-void" ,ghc-void) @@ -4763,7 +5291,7 @@ just a @code{Semigroup} are added.") (define-public ghc-semigroups (package (name "ghc-semigroups") - (version "0.18.2") + (version "0.18.5") (source (origin (method url-fetch) @@ -4773,7 +5301,7 @@ just a @code{Semigroup} are added.") ".tar.gz")) (sha256 (base32 - "1r6hsn3am3dpf4rprrj4m04d9318v9iq02bin0pl29dg4a3gzjax")))) + "17g29h62g1k51ghhvzkw72zksjgi6vs6bfipkj81pqw1dsprcamb")))) (build-system haskell-build-system) (inputs `(("ghc-nats" ,ghc-nats) @@ -4792,10 +5320,22 @@ where every element did not have to have an inverse, thus the name semigroup.") (license license:bsd-3))) +(define-public ghc-semigroups-bootstrap + (package + (inherit ghc-semigroups) + (name "ghc-semigroups-bootstrap") + (inputs + `(("ghc-nats" ,ghc-nats-bootstrap) + ("ghc-tagged" ,ghc-tagged) + ("ghc-unordered-containers" ,ghc-unordered-containers-bootstrap) + ("ghc-text" ,ghc-text) + ("ghc-hashable" ,ghc-hashable-bootstrap))) + (properties '(hidden? #t)))) + (define-public ghc-free (package (name "ghc-free") - (version "4.12.4") + (version "5.0.2") (source (origin (method url-fetch) @@ -4805,7 +5345,7 @@ semigroup.") ".tar.gz")) (sha256 (base32 - "1147s393442xf4gkpbq0rd1p286vmykgx85mxhk5d1c7wfm4bzn9")))) + "15m3n9vhz7z3kzv1w3wlfa3x8jp4cbrkwmrcjr7jlx39iqffn1gg")))) (build-system haskell-build-system) (inputs `(("ghc-prelude-extras" ,ghc-prelude-extras) @@ -4814,9 +5354,10 @@ semigroup.") ("ghc-bifunctors" ,ghc-bifunctors) ("ghc-comonad" ,ghc-comonad) ("ghc-distributive" ,ghc-distributive) - ("ghc-mtl" ,ghc-mtl) ("ghc-semigroupoids" ,ghc-semigroupoids) - ("ghc-semigroups" ,ghc-semigroups))) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-transformers-base" ,ghc-transformers-base) + ("ghc-transformers-compat" ,ghc-transformers-compat))) (home-page "https://github.com/ekmett/free/") (synopsis "Unrestricted monads for Haskell") (description "This library provides free monads, which are useful for many @@ -4831,7 +5372,7 @@ definition of @code{Monad}.") (define-public ghc-adjunctions (package (name "ghc-adjunctions") - (version "4.3") + (version "4.4") (source (origin (method url-fetch) @@ -4841,7 +5382,7 @@ definition of @code{Monad}.") ".tar.gz")) (sha256 (base32 - "1k1ykisf96i4g2zm47c45md7p42c4vsp9r73392pz1g8mx7s2j5r")))) + "1sbal7cbhm12crfnfhkk322jnzgx7lhw3jzq0p463bipagsjwz2h")))) (build-system haskell-build-system) (inputs `(("ghc-profunctors" ,ghc-profunctors) @@ -4849,11 +5390,15 @@ definition of @code{Monad}.") ("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) + ("ghc-transformers-compat" ,ghc-transformers-compat) ("ghc-void" ,ghc-void))) + (native-inputs + `(("ghc-generic-deriving" ,ghc-generic-deriving) + ("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) (home-page "https://github.com/ekmett/adjunctions/") (synopsis "Adjunctions and representable functors") (description "This library provides adjunctions and representable functors @@ -4873,8 +5418,7 @@ for Haskell.") (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) @@ -4920,7 +5464,7 @@ monad transformer (instead of the IO monad).") (define-public ghc-doctest (package (name "ghc-doctest") - (version "0.11.0") + (version "0.16.0") (source (origin (method url-fetch) @@ -4930,13 +5474,14 @@ monad transformer (instead of the IO monad).") ".tar.gz")) (sha256 (base32 - "0xv4vx1r3mk7cmiwywzrq25545cx3i7imhcx33mk47r88j5c49fj")))) + "0hkccch65s3kp0b36h7bqhilnpi4bx8kngncm7ma9vbd3dwacjdv")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: missing test framework (inputs `(("ghc-syb" ,ghc-syb) ("ghc-paths" ,ghc-paths) ("ghc-base-compat" ,ghc-base-compat) + ("ghc-code-page" ,ghc-code-page) ("ghc-hunit" ,ghc-hunit) ("ghc-hspec" ,ghc-hspec) ("ghc-quickcheck" ,ghc-quickcheck) @@ -4951,41 +5496,10 @@ It is modeled after doctest for Python, see @uref{https://docs.python.org/library/doctest.html, the Doctest website}.") (license license:expat))) -(define-public ghc-doctest-0.12 - (package (inherit ghc-doctest) - (name "ghc-doctest") - (version "0.12.0") - (source - (origin - (method url-fetch) - (uri (string-append - "https://hackage.haskell.org/package/doctest/doctest-" - version - ".tar.gz")) - (sha256 - (base32 - "13h549cpgcvb7c54c7wif28g5wak84dxc3ais0hlqhzk1q6la91a")))) - (inputs - `(("ghc-code-page" ,ghc-code-page) - ,@(package-inputs ghc-doctest))))) - -(define-public ghc-doctest-0.13 - (package (inherit ghc-doctest-0.12) - (name "ghc-doctest") - (version "0.13.0") - (source - (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "doctest/doctest-" version ".tar.gz")) - (sha256 - (base32 - "08g3nmpqbnbkxc95d65hkhfabwax10qrq51vlynr342npn40mn2b")))))) - (define-public ghc-lifted-base (package (name "ghc-lifted-base") - (version "0.2.3.8") + (version "0.2.3.12") (source (origin (method url-fetch) @@ -4995,7 +5509,7 @@ It is modeled after doctest for Python, see ".tar.gz")) (sha256 (base32 - "17yz4n7q96x4cp8vxai8csn2vmpigxvipkfh48arahf91f0xy18n")))) + "1i8p8d3rkdh21bhgjjh32vd7qqjr7jq7p59qds0aw2kmargsjd61")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries. (inputs @@ -5061,7 +5575,7 @@ occurrences of a substring (the first in case of overlaps) with another.") (define-public ghc-integer-logarithms (package (name "ghc-integer-logarithms") - (version "1.0.2") + (version "1.0.2.1") (source (origin (method url-fetch) @@ -5070,16 +5584,24 @@ occurrences of a substring (the first in case of overlaps) with another.") 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 + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "integer-logarithms.cabal" + (("tasty >= 0\\.10 && < 1\\.1") + "tasty >= 0.10 && < 1.2"))))))) + (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: @@ -5090,10 +5612,18 @@ occurrences of a substring (the first in case of overlaps) with another.") in migrated modules.") (license license:expat))) +(define-public ghc-integer-logarithms-bootstrap + (package + (inherit ghc-integer-logarithms) + (name "ghc-integer-logarithms-bootstrap") + (arguments `(#:tests? #f)) + (native-inputs '()) + (properties '(hidden? #t)))) + (define-public ghc-scientific (package (name "ghc-scientific") - (version "0.3.5.2") + (version "0.3.6.2") (source (origin (method url-fetch) @@ -5103,14 +5633,15 @@ in migrated modules.") ".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) @@ -5126,17 +5657,30 @@ and space efficient. They are represented using notation}.") (license license:bsd-3))) +(define-public ghc-scientific-bootstrap + (package + (inherit ghc-scientific) + (name "ghc-scientific-bootstrap") + (arguments `(#:tests? #f)) + (inputs + `(("ghc-integer-logarithms" ,ghc-integer-logarithms-bootstrap) + ("ghc-text" ,ghc-text) + ("ghc-hashable" ,ghc-hashable) + ("ghc-primitive" ,ghc-primitive))) + (native-inputs '()) + (properties '(hidden? #t)))) + (define-public ghc-boxes (package (name "ghc-boxes") - (version "0.1.4") + (version "0.1.5") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/boxes/boxes-" version ".tar.gz")) (sha256 - (base32 "1n7xiplzd3s1a39nizwjcgsh3wi2348mp21c3fk19v98ialfjgjf")))) + (base32 "1hsnmw95i58d4bkpxby3ddsj1cawypw4mdyb18m393s5i8p7iq9q")))) (build-system haskell-build-system) (inputs `(("ghc-split" ,ghc-split) @@ -5161,6 +5705,9 @@ using a simple box model.") (base32 "17bwghc15mc9pchfd1w46jh2p3wzc86aj6a537wqwxn08rayzcxh")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("2" "1pnidf8w8x0w5fsqgv8hhrw07slmhxwy5x4fikgk0bd6k76aqicb"))) (native-inputs `(("ghc-hunit" ,ghc-hunit) ("ghc-test-framework" ,ghc-test-framework) @@ -5209,8 +5756,6 @@ and bytestrings.") (base32 "1q6v2bynij724fv347mhqxdscwifzrx5jb9mq80608qf638fn717")))) (build-system haskell-build-system) - (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck"))) (inputs `(("ghc-syb" ,ghc-syb) ("ghc-aeson" ,ghc-aeson) @@ -5229,25 +5774,6 @@ pandoc to represent structured documents. It also provides functions for building up, manipulating and serialising @code{Pandoc} structures.") (license license:bsd-3))) -(define-public ghc-pandoc-types-for-pandoc-1 - (package (inherit ghc-pandoc-types) - (version "1.17.0.5") - (source (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "pandoc-types/pandoc-types-" - version ".tar.gz")) - (sha256 - (base32 - "1csipjdq00iiq77k2wlrg4i7afrzlh8nl585q785xzw7nn45b0n8")))) - (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck" - "--allow-newer=HUnit"))) - (inputs - `(("ghc-syb" ,ghc-syb) - ("ghc-aeson" ,ghc-aeson-for-pandoc-1) - ("ghc-string-qq" ,ghc-string-qq))))) - (define-public ghc-texmath (package (name "ghc-texmath") @@ -5268,7 +5794,6 @@ building up, manipulating and serialising @code{Pandoc} structures.") ("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") @@ -5281,27 +5806,6 @@ markup formats). The TeX reader supports basic LaTeX and AMS extensions, and it can parse and apply LaTeX macros.") (license license:gpl2+))) -(define-public ghc-texmath-for-pandoc-1 - (package (inherit ghc-texmath) - (version "0.9.4.4") - (source (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "texmath/texmath-" version ".tar.gz")) - (sha256 - (base32 - "129q33m56diiv35kdwfb07838wrg0mm88kxdqxfyl1zvf9nzkqkd")))) - (inputs - `(("ghc-mtl" ,ghc-mtl) - ("ghc-network-uri" ,ghc-network-uri) - ("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1) - ("ghc-parsec" ,ghc-parsec) - ("ghc-split" ,ghc-split) - ("ghc-syb" ,ghc-syb) - ("ghc-temporary" ,ghc-temporary) - ("ghc-utf8-string" ,ghc-utf8-string) - ("ghc-xml" ,ghc-xml))))) - (define-public ghc-regex-pcre-builtin (package (name "ghc-regex-pcre-builtin") @@ -5351,7 +5855,7 @@ and utilities for pretty printing.") (define-public ghc-highlighting-kate (package (name "ghc-highlighting-kate") - (version "0.6.3") + (version "0.6.4") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -5359,7 +5863,7 @@ and utilities for pretty printing.") version ".tar.gz")) (sha256 (base32 - "03c4flh4h1jd48bx0qmplax3q8w6wj1dhbh6j0xhaf5h95fbinki")))) + "1bqv00gfmrsf0jjr4qf3lhshvfkyzmhbi3pjb6mafbnsyn2k7f6q")))) (build-system haskell-build-system) (inputs `(("ghc-diff" ,ghc-diff) @@ -5367,8 +5871,7 @@ and utilities for pretty printing.") (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 @@ -5410,7 +5913,7 @@ sources, and does not require prior installation of the C library.") (define-public ghc-cmark-gfm (package (name "ghc-cmark-gfm") - (version "0.1.3") + (version "0.1.5") (source (origin (method url-fetch) @@ -5419,7 +5922,7 @@ sources, and does not require prior installation of the C library.") version ".tar.gz")) (sha256 (base32 - "1fkisbrydmdx5h8yad09fzk8h1b1j53r02g7vb81izgdwj9b673k")))) + "13b0mqks5c1q989slgsa3ixr5vvkfyic4ynzgv00kgl5qrs7hqk7")))) (build-system haskell-build-system) (inputs `(("ghc-text" ,ghc-text))) @@ -5521,7 +6024,7 @@ asynchronous exceptions.") (define-public ghc-th-abstraction (package (name "ghc-th-abstraction") - (version "0.2.6.0") + (version "0.2.8.0") (source (origin (method url-fetch) @@ -5530,7 +6033,7 @@ asynchronous exceptions.") version ".tar.gz")) (sha256 (base32 - "0g42h6wnj2awc5ryhbvx009wd8w75pn66bjzsq1z4s3xajd2hbp5")))) + "0n17w4q2ykd0nica4sck2wng6md56rfad8x0icl0l8vnzb9nn4ya")))) (build-system haskell-build-system) (home-page "https://github.com/glguy/th-abstraction") (synopsis "Nicer interface for reified information about data types") @@ -5544,15 +6047,17 @@ Template Haskell.") (define-public ghc-th-lift (package (name "ghc-th-lift") - (version "0.7.8") + (version "0.7.11") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "th-lift/th-lift-" version ".tar.gz")) (sha256 (base32 - "0ay10b78x3969rpqqrgzy8srkl6iby2cljbf3mm17na8x22k7y1c")))) + "131360zxb0hazbqwbkk6ab2p77jkxr79bwwm618mrwrwkm3x2g6m")))) (build-system haskell-build-system) + (inputs + `(("ghc-th-abstraction" ,ghc-th-abstraction))) (home-page "https://github.com/mboes/th-lift") (synopsis "Derive Template Haskell's Lift class for datatypes") (description @@ -5589,7 +6094,7 @@ instances. This package provides orphan instances for @code{containers}, (define-public ghc-th-expand-syns (package (name "ghc-th-expand-syns") - (version "0.4.0.0") + (version "0.4.4.0") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -5597,7 +6102,7 @@ instances. This package provides orphan instances for @code{containers}, version ".tar.gz")) (sha256 (base32 - "1sjy7a17zwyvlbkc8gklii67sy78wpnw35fyb00lsbnpk4cryd2r")))) + "01prlvh3py5hq5ccjidfyp9ixq2zd88dkbsidyjrpkja6v8m43yc")))) (build-system haskell-build-system) (inputs `(("ghc-syb" ,ghc-syb))) @@ -5611,7 +6116,7 @@ instances. This package provides orphan instances for @code{containers}, (define-public ghc-th-reify-many (package (name "ghc-th-reify-many") - (version "0.1.6") + (version "0.1.8") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -5619,11 +6124,10 @@ instances. This package provides orphan instances for @code{containers}, version ".tar.gz")) (sha256 (base32 - "1b76zjxkj0v0n8zj9l0nwav2irm0c43rx6qjihfw8klmmxvx59df")))) + "0hzy6hvhvcd6i60vx5cp2b7ggmnnjh9rx4h8bm8xw4grglcaxjnf")))) (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") @@ -5637,20 +6141,19 @@ function which generates instances.") (define-public ghc-th-orphans (package (name "ghc-th-orphans") - (version "0.13.2") + (version "0.13.6") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "th-orphans/th-orphans-" version ".tar.gz")) (sha256 (base32 - "0102vkyzpgnp2fys8pvw4khrhrh2y1b8dp1slgvn020vg4s351mc")))) + "0sfl3pn9kq9da3ji3lsgzgzy82vz6yvsg80dmakc1jvk7awycibp")))) (build-system haskell-build-system) (inputs `(("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))) @@ -5666,7 +6169,7 @@ package, and that's where the version number started.") (define-public ghc-geniplate-mirror (package (name "ghc-geniplate-mirror") - (version "0.7.5") + (version "0.7.6") (source (origin (method url-fetch) @@ -5674,9 +6177,8 @@ package, and that's where the version number started.") "/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 @@ -5710,7 +6212,7 @@ info for more informative bug reports.") (define-public ghc-haskell-src-meta (package (name "ghc-haskell-src-meta") - (version "0.8.0.2") + (version "0.8.0.3") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -5718,7 +6220,7 @@ info for more informative bug reports.") version ".tar.gz")) (sha256 (base32 - "12rc4v5dbbbcwdp7j8isvnm9vqpazv124j5kdfwlgwgwjhxi8ysb")))) + "08jq156zv4m0fjq6712n99c1jwxnpa6kj6sq8ch0r1l0a1ay6ww4")))) (build-system haskell-build-system) (inputs `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts) @@ -5752,7 +6254,6 @@ template-haskell abstract syntax.") ("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) @@ -5778,7 +6279,7 @@ space as enumerator/iteratee and pipes.") (define-public ghc-logging-facade (package (name "ghc-logging-facade") - (version "0.1.1") + (version "0.3.0") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -5786,7 +6287,7 @@ space as enumerator/iteratee and pipes.") version ".tar.gz")) (sha256 (base32 - "18ldv6rsff480rqpbs3iabjpvn1fhw0i2a0g80jnhxg9ajfz5yb0")))) + "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf")))) (build-system haskell-build-system) (native-inputs `(("ghc-hspec" ,ghc-hspec) @@ -5801,14 +6302,14 @@ back-ends.") (define-public ghc-mockery (package (name "ghc-mockery") - (version "0.3.3") + (version "0.3.5") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "mockery/mockery-" version ".tar.gz")) (sha256 (base32 - "1m7sq2vclgir3qbpngzl3g87ks4034blwwf7p3h02c0jlcwpl5b1")))) + "09ypgm3z69gq8mj6y66ss58kbjnk15r8frwcwbqcfbfksfnfv8dp")))) (build-system haskell-build-system) (inputs `(("ghc-temporary" ,ghc-temporary) @@ -5826,14 +6327,14 @@ back-ends.") (define-public ghc-yaml (package (name "ghc-yaml") - (version "0.8.28") + (version "0.8.32") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "yaml/yaml-" version ".tar.gz")) (sha256 (base32 - "0swgkzkfrwj0ac7lssn8rnrdfmh3lcsdn5fbq2iwv55di6jbc0pp")))) + "0cbsyh4ilvjzq1q7pxls43k6pdqxg1l85xzibcwpbvmlvrizh86w")))) (build-system haskell-build-system) (inputs `(("ghc-conduit" ,ghc-conduit) @@ -5859,12 +6360,6 @@ back-ends.") "This package provides a library to parse and render YAML documents.") (license license:bsd-3))) -(define-public ghc-yaml-for-pandoc-1 - (package (inherit ghc-yaml) - (inputs - `(("ghc-aeson" ,ghc-aeson-for-pandoc-1) - ,@(alist-delete "ghc-aeson" (package-inputs ghc-yaml)))))) - (define-public ghc-filemanip (package (name "ghc-filemanip") @@ -5878,8 +6373,7 @@ back-ends.") "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 @@ -5912,7 +6406,7 @@ do on-demand loading.") (define-public ghc-juicypixels (package (name "ghc-juicypixels") - (version "3.2.9.3") + (version "3.2.9.5") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -5920,11 +6414,10 @@ do on-demand loading.") version ".tar.gz")) (sha256 (base32 - "14s57fgf6kd5n5al2kcvk1aaxbq1ph0r5h8blflrjkx83yl6r8yn")))) + "0mf3ihr0xy2wc2wzb9a17g0n3p60x7pvm8akwpvhdy8klvs6r744")))) (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))) @@ -5938,14 +6431,14 @@ TIFF and GIF formats.") (define-public ghc-hslua (package (name "ghc-hslua") - (version "0.9.5") + (version "0.9.5.2") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "hslua/hslua-" version ".tar.gz")) (sha256 (base32 - "1j2zk7f7nyywg2b0n6kb2yf6ljc7cn2sk9jz0h76g3ag2b70l12n")))) + "1rdvv01p214zfjh6fcqjjgqwi8y42wad6cqzhlcv5gvclzw2ck8f")))) (build-system haskell-build-system) (arguments `(#:configure-flags '("-fsystem-lua"))) @@ -5953,7 +6446,6 @@ TIFF and GIF formats.") `(("lua" ,lua) ("ghc-exceptions" ,ghc-exceptions) ("ghc-fail" ,ghc-fail) - ("ghc-mtl" ,ghc-mtl) ("ghc-text" ,ghc-text))) (native-inputs `(("ghc-tasty" ,ghc-tasty) @@ -5969,27 +6461,6 @@ TIFF and GIF formats.") described in @url{https://www.lua.org/}.") (license license:expat))) -(define-public ghc-hslua-for-pandoc-1 - (package (inherit ghc-hslua) - (version "0.4.1") - (source (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "hslua/hslua-" version ".tar.gz")) - (sha256 - (base32 - "0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid")))) - (inputs - `(("lua" ,lua-5.1) - ("ghc-text" ,ghc-text))) - (native-inputs - `(("ghc-quickcheck" ,ghc-quickcheck) - ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) - ("ghc-hspec" ,ghc-hspec) - ("ghc-hspec-contrib" ,ghc-hspec-contrib) - ("ghc-hunit" ,ghc-hunit) - ("hspec-discover" ,hspec-discover))))) - (define-public ghc-hslua-module-text (package (name "ghc-hslua-module-text") @@ -6004,6 +6475,9 @@ described in @url{https://www.lua.org/}.") (base32 "0bcfpb1dhnxp0gr376ai4w7vczr9zrjl1r3r6w7kcxivfkwq9cxf")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n"))) (inputs `(("ghc-hslua" ,ghc-hslua) ("ghc-text" ,ghc-text))) @@ -6041,18 +6515,17 @@ wrapping a bytestring with stronger and more meaniful name.") (define-public ghc-hourglass (package (name "ghc-hourglass") - (version "0.2.10") + (version "0.2.12") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "hourglass/hourglass-" version ".tar.gz")) (sha256 (base32 - "104d1yd84hclprg740nkz60vx589mnm094zriw6zczbgg8nkclym")))) + "0jnay5j13vpz6i1rkaj3j0d9v8jfpri499xn3l7wd01f81f5ncs4")))) (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) @@ -6080,7 +6553,13 @@ representations of current time.") (base32 "0jkca97zyv23yyilp3jydcrzxqhyk27swhzh82llvban5zp8b21y")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck"))) + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "edit-distance.cabal" + (("QuickCheck >= 2\\.4 && <2\\.9") + "QuickCheck >= 2.4 && < 2.12"))))))) (inputs `(("ghc-random" ,ghc-random) ("ghc-test-framework" ,ghc-test-framework) @@ -6126,14 +6605,14 @@ set, memory copy, ..) and more") (define-public ghc-socks (package (name "ghc-socks") - (version "0.5.5") + (version "0.5.6") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "socks/socks-" version ".tar.gz")) (sha256 (base32 - "0s689w1hh9g8ifl75xhzbv96ir07hwn04b4lgvbxzl8swa9ylir6")))) + "0f44qy74i0n6ll3jym0a2ipafkpw1h67amcpqmj8iq95h21wsqzs")))) (build-system haskell-build-system) (inputs `(("ghc-cereal" ,ghc-cereal) @@ -6147,7 +6626,7 @@ set, memory copy, ..) and more") (define-public ghc-connection (package (name "ghc-connection") - (version "0.2.6") + (version "0.2.8") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" @@ -6155,7 +6634,7 @@ set, memory copy, ..) and more") version ".tar.gz")) (sha256 (base32 - "1c1prsgad669cmf6qrqlb5hmh0dnam2imijqzpwcr4ja14l6rh83")))) + "1swkb9w5vx9ph7x55y51dc0srj2z27nd9ibgn8c0qcl6hx7g9cbh")))) (build-system haskell-build-system) (inputs `(("ghc-byteable" ,ghc-byteable) @@ -6175,17 +6654,18 @@ needs. It provides a very simple API to create sockets to a destination with the choice of SSL/TLS, and SOCKS.") (license license:bsd-3))) -(define-public ghc-skylighting +(define-public ghc-skylighting-core (package - (name "ghc-skylighting") - (version "0.5.1") + (name "ghc-skylighting-core") + (version "0.7.2") (source (origin (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/skylighting-" - version "/skylighting-" version ".tar.gz")) + (uri (string-append "https://hackage.haskell.org/package/" + "skylighting-core/skylighting-core-" + version ".tar.gz")) (sha256 (base32 - "0l5lhhqqlfaq1fs7pn3n3b25kmazk8p4ahwvhagbrhcbm5hsigdg")))) + "066fwmwsd7xcvwlinfk2izlzq0xp8697i6lnbgsbl71jdybyackq")))) (build-system haskell-build-system) (inputs `(("ghc-aeson" ,ghc-aeson) @@ -6195,22 +6675,21 @@ the choice of SSL/TLS, and SOCKS.") ("ghc-blaze-html" ,ghc-blaze-html) ("ghc-case-insensitive" ,ghc-case-insensitive) ("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-text" ,ghc-text) ("ghc-utf8-string" ,ghc-utf8-string))) (native-inputs - `(("ghc-hunit" ,ghc-hunit) + `(("ghc-diff" ,ghc-diff) + ("ghc-hunit" ,ghc-hunit) + ("ghc-pretty-show" ,ghc-pretty-show) ("ghc-quickcheck" ,ghc-quickcheck) ("ghc-tasty" ,ghc-tasty) ("ghc-tasty-golden" ,ghc-tasty-golden) ("ghc-tasty-hunit" ,ghc-tasty-hunit) ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) - (home-page "https://hackage.haskell.org/package/skylighting") + (home-page "https://github.com/jgm/skylighting") (synopsis "Syntax highlighting library") (description "Skylighting is a syntax highlighting library with support for over one hundred languages. It derives its tokenizers from XML syntax @@ -6219,61 +6698,26 @@ supported by that framework can be added. An optional command-line program is provided. Skylighting is intended to be the successor to highlighting-kate.") (license license:gpl2))) -(define-public ghc-skylighting-for-pandoc-1 - (package (inherit ghc-skylighting) - (version "0.1.1.5") +(define-public ghc-skylighting + (package + (inherit ghc-skylighting-core) + (name "ghc-skylighting") + (version "0.7.2") (source (origin - (method git-fetch) - ;; We take the sources from Github, because the tarball on - ;; hackage does not include the XML files. - (uri (git-reference - (url "https://github.com/jgm/skylighting.git") - (commit version))) - (file-name (string-append "ghc-skylighting-" version "-checkout")) + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/skylighting-" + version "/skylighting-" version ".tar.gz")) (sha256 (base32 - "0z3yv8v2fqqgv6lsf0ff3ld0h2vkg97b2jiry9wn2f1rizwdqmzl")))) - (arguments - `(#:configure-flags '("-fbootstrap") - #:phases - (modify-phases %standard-phases - ;; After building the skylighting-extract tool we use it to generate - ;; syntax source files from the included XML files. These are then - ;; added to the skylighting.cabal file. - (add-after 'build 'extract-xml - (lambda _ - (make-file-writable "skylighting.cabal") - (apply invoke "./dist/build/skylighting-extract/skylighting-extract" - (find-files "xml" "\\.xml$")) - #t)) - ;; Reconfigure without bootstrap flag - (add-after 'extract-xml 'configure-again - (lambda* (#:key outputs inputs tests? #:allow-other-keys) - ((assoc-ref %standard-phases 'configure) - #:outputs outputs - #:inputs inputs - #:tests? tests? - #:configure-flags '("-f-bootstrap")))) - (add-after 'configure-again 'build-again - (assoc-ref %standard-phases 'build))))) - (inputs - `(("ghc-aeson" ,ghc-aeson-for-pandoc-1) - ("ghc-ansi-terminal" ,ghc-ansi-terminal) - ("ghc-blaze-html" ,ghc-blaze-html) - ("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-text" ,ghc-text) - ("ghc-utf8-string" ,ghc-utf8-string))))) + "1rh3z1a7a4clvksdw1qlpmhxqkfahwypi70k91whgfamzsqpxdch")))) + (inputs + `(("ghc-skylighting-core" ,ghc-skylighting-core) + ,@(package-inputs ghc-skylighting-core))))) (define-public ghc-doctemplates (package (name "ghc-doctemplates") - (version "0.2.1") + (version "0.2.2.1") (source (origin (method url-fetch) @@ -6282,7 +6726,7 @@ provided. Skylighting is intended to be the successor to highlighting-kate.") version ".tar.gz")) (sha256 (base32 - "1bfs2kl5j5al2w2y4qpbn68p0xsnb65r7h51l356kpkzc326646p")))) + "1gyckfg3kgvzhxw14i7iwrw0crygvsp86sy53bbr1yn7bxbgn33b")))) (build-system haskell-build-system) (inputs `(("ghc-aeson" ,ghc-aeson) @@ -6301,29 +6745,6 @@ provided. Skylighting is intended to be the successor to highlighting-kate.") "This package provides a simple text templating system used by pandoc.") (license license:bsd-3))) -(define-public ghc-doctemplates-for-pandoc-1 - (package (inherit ghc-doctemplates) - (version "0.1.0.2") - (source - (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "doctemplates/doctemplates-" - version ".tar.gz")) - (sha256 - (base32 - "0swal6rjya1293mwvl63jch5fx9ghpsil7qs4v7rpansa0izalmp")))) - (build-system haskell-build-system) - (inputs - `(("ghc-aeson" ,ghc-aeson-for-pandoc-1) - ("ghc-blaze-markup" ,ghc-blaze-markup) - ("ghc-blaze-html" ,ghc-blaze-html) - ("ghc-text" ,ghc-text) - ("ghc-vector" ,ghc-vector) - ("ghc-parsec" ,ghc-parsec) - ("ghc-unordered-containers" ,ghc-unordered-containers) - ("ghc-scientific" ,ghc-scientific))))) - (define-public ghc-pandoc (package (name "ghc-pandoc") @@ -6337,6 +6758,20 @@ provided. Skylighting is intended to be the successor to highlighting-kate.") (base32 "1dqin92w513l7whg5wdgrngnxsj5mb8gppfvn7kjgyv2pdgpy0zy")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "pandoc.cabal" + (("tasty >= 0\\.11 && < 1\\.1") + "tasty >= 0.11 && < 1.1.1")))) + (add-before 'configure 'patch-tests + (lambda _ + ;; These tests fail benignly and have been adjusted upstream: + ;; <https://github.com/commercialhaskell/stackage/issues/3719>. + (substitute* "test/Tests/Old.hs" + (("lhsWriterTests \"html\"") "[]"))))))) (inputs `(("ghc-aeson" ,ghc-aeson) ("ghc-aeson-pretty" ,ghc-aeson-pretty) @@ -6358,7 +6793,6 @@ provided. Skylighting is intended to be the successor to highlighting-kate.") ("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) @@ -6400,71 +6834,10 @@ definition lists, tables, and other features. A compatibility mode is provided for those who need a drop-in replacement for Markdown.pl.") (license license:gpl2+))) -;; This is the last version of Pandoc 1.x, which is preferred for Rmarkdown. -(define-public ghc-pandoc-1 - (package (inherit ghc-pandoc) - (version "1.19.2.4") - (source - (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-" - version ".tar.gz")) - (sha256 - (base32 - "0mim429mpakrcnm50csxyqk3ljcx2l26r5grk6w9isnggwgqrq5v")))) - (arguments - `(#:configure-flags (list "--allow-newer=skylighting"))) - (inputs - `(("ghc-aeson" ,ghc-aeson-for-pandoc-1) - ("ghc-ansi-terminal" ,ghc-ansi-terminal) - ("ghc-base64-bytestring" ,ghc-base64-bytestring) - ("ghc-blaze-html" ,ghc-blaze-html) - ("ghc-blaze-markup" ,ghc-blaze-markup) - ("ghc-cmark" ,ghc-cmark) - ("ghc-data-default" ,ghc-data-default) - ("ghc-deepseq-generics" ,ghc-deepseq-generics) - ("ghc-diff" ,ghc-diff) - ("ghc-doctemplates" ,ghc-doctemplates-for-pandoc-1) - ("ghc-executable-path" ,ghc-executable-path) - ("ghc-extensible-exceptions" ,ghc-extensible-exceptions) - ("ghc-filemanip" ,ghc-filemanip) - ("ghc-haddock-library" ,ghc-haddock-library) - ("ghc-hslua" ,ghc-hslua-for-pandoc-1) - ("ghc-http" ,ghc-http) - ("ghc-http-client" ,ghc-http-client) - ("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) - ("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1) - ("ghc-parsec" ,ghc-parsec) - ("ghc-random" ,ghc-random) - ("ghc-scientific" ,ghc-scientific) - ("ghc-sha" ,ghc-sha) - ("ghc-skylighting" ,ghc-skylighting-for-pandoc-1) - ("ghc-syb" ,ghc-syb) - ("ghc-tagsoup" ,ghc-tagsoup) - ("ghc-temporary" ,ghc-temporary) - ("ghc-texmath" ,ghc-texmath-for-pandoc-1) - ("ghc-text" ,ghc-text) - ("ghc-unordered-containers" ,ghc-unordered-containers) - ("ghc-vector" ,ghc-vector) - ("ghc-xml" ,ghc-xml) - ("ghc-yaml" ,ghc-yaml-for-pandoc-1) - ("ghc-zip-archive" ,ghc-zip-archive) - ("ghc-zlib" ,ghc-zlib))) - (native-inputs - `(("ghc-test-framework" ,ghc-test-framework) - ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) - ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2))))) - (define-public ghc-hs-bibutils (package (name "ghc-hs-bibutils") - (version "6.2.0.1") + (version "6.6.0.0") (source (origin (method url-fetch) @@ -6473,7 +6846,7 @@ provided for those who need a drop-in replacement for Markdown.pl.") version ".tar.gz")) (sha256 (base32 - "0c56sjgg82kjcg5rrplnyn7vf02ccsj3kkcbgc87zxlv0j880rjb")))) + "0n2sz2zl4naspryd49ii858qkjp2lapns5a2gr8zm6vvn5sh1f0l")))) (build-system haskell-build-system) (inputs `(("ghc-syb" ,ghc-syb))) (home-page "https://hackage.haskell.org/package/hs-bibutils") @@ -6510,7 +6883,7 @@ better for some purposes.") (define-public ghc-typed-process (package (name "ghc-typed-process") - (version "0.2.2.0") + (version "0.2.3.0") (source (origin (method url-fetch) @@ -6519,7 +6892,7 @@ better for some purposes.") version ".tar.gz")) (sha256 (base32 - "0c6gvgvjyncbni9a5bvpbglknd4yclr3d3hfg9bhgahmkj40dva2")))) + "0j36vrc9w841m5qbwqra1lwiznx31xfnhin1sm8x2c2739csbpn0")))) (build-system haskell-build-system) (inputs `(("ghc-async" ,ghc-async) @@ -6604,7 +6977,7 @@ documents.") (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) @@ -6612,11 +6985,12 @@ documents.") "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) @@ -6637,7 +7011,7 @@ the @code{conduit} package.") (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) @@ -6646,18 +7020,24 @@ the @code{conduit} package.") version ".tar.gz")) (sha256 (base32 - "1l58nbflcnlznc93qimkk7ghk2gv8kipf45zf88piqa2zys41yyx")))) + "0yj6rckwsc9vig40cm15ry0j3d01xpk04qma9n4byhal6v4b5h22")))) (build-system haskell-build-system) (arguments `(#:phases (modify-phases %standard-phases + ;; Many YAML tests (44) are failing do to changes in ghc-yaml: + ;; <https://github.com/jgm/pandoc-citeproc/issues/342>. + (add-before 'configure 'patch-tests + (lambda _ + (substitute* "tests/test-pandoc-citeproc.hs" + (("let allTests = citeprocTests \\+\\+ biblio2yamlTests") + "let allTests = citeprocTests")))) ;; Tests need to be run after installation. (delete 'check) (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) @@ -6689,19 +7069,6 @@ and also has a mode for converting bibliographic databases a YAML format suitable for inclusion in pandoc YAML metadata.") (license license:bsd-3))) -(define-public ghc-pandoc-citeproc-with-pandoc-1 - (let ((for-pandoc-1 - (package-input-rewriting - `((,ghc-aeson . ,ghc-aeson-for-pandoc-1) - (,ghc-yaml . ,ghc-yaml-for-pandoc-1) - (,ghc-texmath . ,ghc-texmath-for-pandoc-1) - (,ghc-pandoc-types . ,ghc-pandoc-types-for-pandoc-1) - (,ghc-hslua . ,ghc-hslua-for-pandoc-1) - (,ghc-skylighting . ,ghc-skylighting-for-pandoc-1) - (,ghc-doctemplates . ,ghc-doctemplates-for-pandoc-1) - (,ghc-pandoc . ,ghc-pandoc-1))))) - (for-pandoc-1 ghc-pandoc-citeproc))) - (define-public ghc-union-find (package (name "ghc-union-find") @@ -6797,7 +7164,7 @@ regular expressions. Parsers can be built using Applicative interface.") (define-public ghc-regex-tdfa (package (name "ghc-regex-tdfa") - (version "1.2.2") + (version "1.2.3.1") (source (origin (method url-fetch) @@ -6806,11 +7173,10 @@ regular expressions. Parsers can be built using Applicative interface.") version ".tar.gz")) (sha256 (base32 - "0f8x8wyr6m21g8dnxvnvalz5bsq37l125l6qhs0fscbvprsxc4nb")))) + "0l7ajnh4hpgggf2a1r9dg0hx2fy679vd2kada5y7r02hy3nfxala")))) (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.") @@ -6888,6 +7254,16 @@ this problem.") (base32 "18f17aja1ivhr3zyg2cccn2m03hdn5jf5410dndkhf12gvgiqs7y")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "bytestring-handle.cabal" + (("QuickCheck >= 2\\.1\\.2 && < 2\\.11") + "QuickCheck >= 2.1.2 && < 2.12") + (("base >= 4\\.2 && < 4\\.11") + "base >= 4.2 && < 4.12"))))))) (inputs `(("ghc-hunit" ,ghc-hunit) ("ghc-quickcheck" ,ghc-quickcheck) @@ -6902,7 +7278,7 @@ this problem.") (define-public ghc-tar (package (name "ghc-tar") - (version "0.5.0.3") + (version "0.5.1.0") (source (origin (method url-fetch) @@ -6911,7 +7287,7 @@ this problem.") version ".tar.gz")) (sha256 (base32 - "18qq94j9bm91iswnxq2dm5dws5c7wm4k01q2rpf8py35cf3svnfq")))) + "0s2brvaxg5fki2jdkccmnpssiy6a3wjh24p6a3dkkdvjcixnk7f8")))) (build-system haskell-build-system) ;; FIXME: 2/24 tests fail. (arguments `(#:tests? #f)) @@ -6944,8 +7320,6 @@ an index.") (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 @@ -7026,7 +7400,7 @@ the @code{mtl-tf} package.") (define-public ghc-colour (package (name "ghc-colour") - (version "2.3.3") + (version "2.3.4") (source (origin (method url-fetch) @@ -7035,7 +7409,11 @@ the @code{mtl-tf} package.") 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") @@ -7083,8 +7461,15 @@ supported. A module of colour names (\"Data.Colour.Names\") is provided.") "0ln1szgfy8fa78l3issq4fx3aqnnd54w3cb4wssrfi48vd5rkfjm")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck" - "--allow-newer=hspec"))) + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "fgl-arbitrary.cabal" + (("QuickCheck >= 2\\.3 && < 2\\.10") + "QuickCheck >= 2.3 && < 2.12") + (("hspec >= 2\\.1 && < 2\\.5") + "hspec >= 2.1 && < 2.6"))))))) (inputs `(("ghc-fgl" ,ghc-fgl) ("ghc-quickcheck" ,ghc-quickcheck) @@ -7110,8 +7495,6 @@ for generating graph-like data structures.") (base32 "0kj7ap0gnliviq2p8lscw1m06capnsa90vpvcys24nqy5nw2wrp7")))) (build-system haskell-build-system) - (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck"))) (inputs `(("ghc-quickcheck" ,ghc-quickcheck) ("ghc-colour" ,ghc-colour) @@ -7149,7 +7532,7 @@ and edge labels with positional information, etc. (define-public ghc-constraints (package (name "ghc-constraints") - (version "0.8") + (version "0.10.1") (source (origin (method url-fetch) @@ -7158,12 +7541,15 @@ and edge labels with positional information, etc. version ".tar.gz")) (sha256 (base32 - "120mmv9rwbahslisc1z8zx9lw7v6hl5fzid4l0hiy5as6ijqgl2c")))) + "1xy3vv78jxc17hm0z7qqspxjwv7l2jbcbj670yrl2f053qkfr02q")))) (build-system haskell-build-system) (inputs `(("ghc-hashable" ,ghc-hashable) - ("ghc-mtl" ,ghc-mtl) + ("ghc-semigroups" ,ghc-semigroups) ("ghc-transformers-compat" ,ghc-transformers-compat))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) (home-page "https://github.com/ekmett/constraints/") (synopsis "Constraint manipulation") (description @@ -7175,7 +7561,7 @@ a vocabulary for working with them.") (define-public ghc-lifted-async (package (name "ghc-lifted-async") - (version "0.9.0") + (version "0.10.0.2") (source (origin (method url-fetch) @@ -7184,7 +7570,7 @@ a vocabulary for working with them.") version ".tar.gz")) (sha256 (base32 - "00fnwfcnc6niq9jbbb9rap9rkdgv5qhcglwanzc5fi8834j94c1r")))) + "1073r512c1x2m1v0jar9bwqg656slg7jd1jhsyj6m8awgx1l1mwf")))) (build-system haskell-build-system) (inputs `(("ghc-async" ,ghc-async) @@ -7193,8 +7579,8 @@ a vocabulary for working with them.") ("ghc-monad-control" ,ghc-monad-control) ("ghc-constraints" ,ghc-constraints) ("ghc-hunit" ,ghc-hunit) - ("ghc-mtl" ,ghc-mtl) ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure) ("ghc-tasty-hunit" ,ghc-tasty-hunit) ("ghc-tasty-th" ,ghc-tasty-th))) (home-page "https://github.com/maoe/lifted-async") @@ -7211,7 +7597,7 @@ instance of @code{MonadBase} or @code{MonadBaseControl}.") (define ghc-system-filepath-bootstrap (package (name "ghc-system-filepath-bootstrap") - (version "0.4.13.4") + (version "0.4.14") (source (origin (method url-fetch) @@ -7220,7 +7606,7 @@ instance of @code{MonadBase} or @code{MonadBaseControl}.") version ".tar.gz")) (sha256 (base32 - "1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l")))) + "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) @@ -7282,8 +7668,7 @@ which can't be decoded in the current locale encoding.") "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) @@ -7333,7 +7718,7 @@ easily work with command-line options.") (define-public ghc-chell (package (name "ghc-chell") - (version "0.4.0.1") + (version "0.4.0.2") (source (origin (method url-fetch) @@ -7342,7 +7727,7 @@ easily work with command-line options.") version ".tar.gz")) (sha256 (base32 - "0lb95abzxl4a87nfqxsxpb3a39pd52cci43hcvj8615hyhqvs2jz")))) + "10ingy9qnbmc8cqh4i9pskcw43l0mzk8f3d76b3qz3fig5ary3j9")))) (build-system haskell-build-system) (inputs `(("ghc-options-bootstrap" ,ghc-options-bootstrap) @@ -7378,7 +7763,14 @@ testing strategies.") ("ghc-random" ,ghc-random) ("ghc-quickcheck" ,ghc-quickcheck))) (arguments - `(#:tests? #f)) + `(#:tests? #f + #:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "chell-quickcheck.cabal" + (("QuickCheck >= 2\\.3 && < 2\\.11") + "QuickCheck >= 2.3 && < 2.12"))))))) (home-page "https://john-millikin.com/software/chell/") (synopsis "QuickCheck support for the Chell testing library") (description "More complex tests for @code{chell}.") @@ -7398,6 +7790,14 @@ testing strategies.") (base32 "1iicsys9igx7m7n4l2b8djardmjy2ah5ibzp7kzs758h460fq53a")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "chell-quickcheck.cabal" + (("QuickCheck >= 2\\.3 && < 2\\.11") + "QuickCheck >= 2.3 && < 2.12"))))))) (inputs `(("ghc-chell" ,ghc-chell) ("ghc-chell-quickcheck-bootstrap" ,ghc-chell-quickcheck-bootstrap) @@ -7518,7 +7918,7 @@ and Fortran complex data types.") (define-public ghc-hmatrix (package (name "ghc-hmatrix") - (version "0.18.1.0") + (version "0.19.0.0") (source (origin (method url-fetch) @@ -7526,12 +7926,13 @@ and Fortran complex data types.") "https://hackage.haskell.org/package/hmatrix/hmatrix-" version ".tar.gz")) (sha256 - (base32 "07zkwvg872hfk6jyn4s54ws8mvclynazaxf7fsbqi16dmf9dn61c")))) + (base32 "10jd69nby29dggghcyjk6ykyr5wrn97nrv1dkpyrp0y5xm12xssj")))) (build-system haskell-build-system) (inputs `(("ghc-random" ,ghc-random) ("ghc-split" ,ghc-split) ("ghc-storable-complex" ,ghc-storable-complex) + ("ghc-semigroups" ,ghc-semigroups) ("ghc-vector" ,ghc-vector) ;;("openblas" ,openblas) ("lapack" ,lapack))) @@ -7548,7 +7949,7 @@ numerical computations based on BLAS and LAPACK.") (define-public ghc-hmatrix-gsl (package (name "ghc-hmatrix-gsl") - (version "0.18.0.1") + (version "0.19.0.1") (source (origin (method url-fetch) @@ -7556,7 +7957,7 @@ numerical computations based on BLAS and LAPACK.") "https://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-" version ".tar.gz")) (sha256 - (base32 "0mflm7zg6c6a5vy092pa429rzpyv5drc1589r3x4fbmvcyqc79gx")))) + (base32 "0v6dla426x4ywaq59jm89ql1i42n39iw6z0j378xwb676v9kfxhm")))) (build-system haskell-build-system) (inputs `(("ghc-hmatrix" ,ghc-hmatrix) @@ -7574,7 +7975,7 @@ using GSL.") (define-public ghc-hmatrix-special (package (name "ghc-hmatrix-special") - (version "0.4.0.1") + (version "0.19.0.0") (source (origin (method url-fetch) @@ -7583,7 +7984,7 @@ using GSL.") "https://hackage.haskell.org/package/hmatrix-special/hmatrix-special-" version ".tar.gz")) (sha256 - (base32 "0kpcqdchi7ikzhqacy4rh4dxz3v37paxyb84wqa66sysb72wkabj")))) + (base32 "1mywr61kr852sbff26n9x95kswx9l4ycbv6s68qsbkh02xzqq7qz")))) (build-system haskell-build-system) (inputs `(("ghc-hmatrix" ,ghc-hmatrix) @@ -7647,7 +8048,7 @@ Haskell, using gnuplot for rendering.") (define-public ghc-hashtables (package (name "ghc-hashtables") - (version "1.2.1.0") + (version "1.2.3.1") (source (origin (method url-fetch) @@ -7655,10 +8056,8 @@ Haskell, using gnuplot for rendering.") "https://hackage.haskell.org/package/hashtables/hashtables-" version ".tar.gz")) (sha256 - (base32 "1b6w9xznk42732vpd8ili60k12yq190xnajgga0iwbdpyg424lgg")))) + (base32 "1giw9caajr07slf09j7zry9b0kvm4yj9q78zy1mawzi6gk3wglcg")))) (build-system haskell-build-system) - (arguments - `(#:configure-flags (list "--allow-newer=vector"))) (inputs `(("ghc-hashable" ,ghc-hashable) ("ghc-primitive" ,ghc-primitive) @@ -7714,14 +8113,14 @@ Accessor to access state in transformers State monad.") (define-public ghc-utility-ht (package (name "ghc-utility-ht") - (version "0.0.12") + (version "0.0.14") (home-page "https://hackage.haskell.org/package/utility-ht") (source (origin (method url-fetch) (uri (string-append home-page "/utility-ht-" version ".tar.gz")) (sha256 - (base32 "1vq5bd51rl9l5lgfmaqxgiggddk38hzgngcj7qgrqnalcd1myi54")))) + (base32 "1a7bgk7wv7sqbxbiv7kankiimr3wij7zdm7s83zwsf886ghyxhk9")))) (build-system haskell-build-system) (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) (synopsis "Haskell helper functions for Lists, Maybes, Tuples, Functions") @@ -7732,7 +8131,7 @@ helper functions for Lists, Maybes, Tuples, Functions.") (define-public ghc-gnuplot (package (name "ghc-gnuplot") - (version "0.5.4.1") + (version "0.5.5.2") (source (origin (method url-fetch) @@ -7740,13 +8139,14 @@ helper functions for Lists, Maybes, Tuples, Functions.") "mirror://hackage/package/gnuplot/gnuplot-" version ".tar.gz")) (sha256 - (base32 "1xz8prw9xjk0rsyrkp9bsmxykzrbhpv9qhhkdapy75mdbmgwjm7s")))) + (base32 "1mlppnc13ygjzmf6ldydys4wvy35yb3xjwwfgf9rbi7nfcqjr6mn")))) (build-system haskell-build-system) (inputs `(("ghc-temporary" ,ghc-temporary) ("ghc-utility-ht" ,ghc-utility-ht) ("ghc-data-accessor-transformers" ,ghc-data-accessor-transformers) ("ghc-data-accessor" ,ghc-data-accessor) + ("ghc-semigroups" ,ghc-semigroups) ("gnuplot" ,gnuplot))) (arguments `(#:phases @@ -7766,7 +8166,7 @@ helper functions for Lists, Maybes, Tuples, Functions.") (define-public ghc-hinotify (package (name "ghc-hinotify") - (version "0.3.8.1") + (version "0.3.10") (source (origin (method url-fetch) (uri (string-append @@ -7774,8 +8174,10 @@ helper functions for Lists, Maybes, Tuples, Functions.") "hinotify-" version ".tar.gz")) (sha256 (base32 - "03c1f4d7x805zdiq2w26kl09xrfjw19saycdkhnixzv2qcr6xm1p")))) + "17ax3n68a5c2ddazp86aciliskrh6znd3bnry0wcllmb6dbpsaxg")))) (build-system haskell-build-system) + (inputs + `(("ghc-async" ,ghc-async))) (home-page "https://github.com/kolmodin/hinotify.git") (synopsis "Haskell binding to inotify") (description "This library provides a wrapper to the Linux kernel's inotify @@ -7786,7 +8188,7 @@ accessed or modified.") (define-public ghc-fsnotify (package (name "ghc-fsnotify") - (version "0.2.1") + (version "0.3.0.1") (source (origin (method url-fetch) (uri (string-append @@ -7794,7 +8196,7 @@ accessed or modified.") "fsnotify-" version ".tar.gz")) (sha256 (base32 - "0asl313a52qx2w6dw25g845683xsl840bwjh118nkwi5v1xipkzb")))) + "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny")))) (build-system haskell-build-system) (inputs `(("ghc-text" ,ghc-text) @@ -7803,7 +8205,9 @@ accessed or modified.") ("ghc-hinotify" ,ghc-hinotify) ("ghc-tasty" ,ghc-tasty) ("ghc-tasty-hunit" ,ghc-tasty-hunit) - ("ghc-temporary-rc" ,ghc-temporary-rc))) + ("ghc-random" ,ghc-random) + ("ghc-shelly" ,ghc-shelly) + ("ghc-temporary" ,ghc-temporary))) (home-page "https://github.com/haskell-fswatch/hfsnotify") (synopsis "Cross platform library for file change notification.") (description "Cross platform library for file creation, modification, and @@ -7814,7 +8218,7 @@ specific Windows, Mac, and Linux file system event notification.") (define-public ghc-ieee754 (package (name "ghc-ieee754") - (version "0.7.8") + (version "0.8.0") (source (origin (method url-fetch) (uri (string-append @@ -7822,7 +8226,7 @@ specific Windows, Mac, and Linux file system event notification.") "ieee754-" version ".tar.gz")) (sha256 (base32 - "1zvfnnd5nm5kgr60214cdyks0kqdqyzpwk5sdh0s60yr8b7fyjny")))) + "1lcs521g9lzy9d7337vg4w7q7s8500rfqy7rcifcz6pm6yfgyb8f")))) (build-system haskell-build-system) (home-page "https://github.com/patperry/hs-ieee754") (synopsis "Utilities for dealing with IEEE floating point numbers") @@ -7853,7 +8257,7 @@ dependency.") (define-public ghc-language-c (package (name "ghc-language-c") - (version "0.5.0") + (version "0.8.1") (source (origin (method url-fetch) @@ -7861,7 +8265,7 @@ dependency.") "language-c/language-c-" version ".tar.gz")) (sha256 (base32 - "08i2bl7jmmymn2sldzlbz6ig7lx3wfwhlpadzibs3fx72z08pmc6")))) + "0sdkjj0hq8p69fcdm6ljbjkjvrsrb8a6rl5dq6dj6byj32ajrm3d")))) (build-system haskell-build-system) (inputs `(("ghc-syb" ,ghc-syb))) (native-inputs @@ -7878,7 +8282,7 @@ and a large set of GNU extensions.") (define-public ghc-markdown-unlit (package (name "ghc-markdown-unlit") - (version "0.4.0") + (version "0.5.0") (source (origin (method url-fetch) (uri (string-append @@ -7886,7 +8290,7 @@ and a large set of GNU extensions.") "markdown-unlit-" version ".tar.gz")) (sha256 (base32 - "1kj2bffl7ndd8ygwwa3r1mbpwbxbfhyfgnbla8k8g9i6ffp0qrbw")))) + "1gy79vr85vcp13rdjh0hz7zv6daqqffww4j0cqn2lpjjh9xhsbg7")))) (build-system haskell-build-system) (inputs `(("ghc-base-compat" ,ghc-base-compat) @@ -7936,7 +8340,7 @@ Rust syntax. It is intended to be useful for two different purposes: (define-public ghc-wave (package (name "ghc-wave") - (version "0.1.4") + (version "0.1.5") (source (origin (method url-fetch) (uri (string-append @@ -7945,8 +8349,16 @@ Rust syntax. It is intended to be useful for two different purposes: ".tar.gz")) (sha256 (base32 - "1g5nmqfk6p25v9ismwz4i66ay91bd1qh39xwj0hm4z6a5mw8frk8")))) + "03zycmwrchhqvi37fdvlzz2d1vl4hy0i8xyys1zznw38qfq0h2i5")))) (build-system haskell-build-system) + (arguments + '(#:phases + (modify-phases %standard-phases + (add-before 'configure 'update-constraints + (lambda _ + (substitute* "wave.cabal" + (("temporary.* < 1\\.3") + "temporary >= 1.1 && < 1.4"))))))) (inputs `(("ghc-cereal" ,ghc-cereal) ("ghc-data-default-class" @@ -7976,8 +8388,7 @@ files in Haskell.") "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))) @@ -7992,14 +8403,14 @@ handler built in.") (define-public ghc-unexceptionalio (package (name "ghc-unexceptionalio") - (version "0.3.0") + (version "0.4.0") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "unexceptionalio-" version "/" "unexceptionalio-" version ".tar.gz")) - (sha256 (base32 "1f7h7zwky4scdcyjspg4ksfh7x6yra0wjybxq70p7vcwpgk2nzlj")))) + (sha256 (base32 "09gynk472l7nn5l2w320n4dwigwp0wh0shfp6dyw6r5h2jdxz18p")))) (build-system haskell-build-system) (home-page "https://github.com/singpolyma/unexceptionalio") (synopsis "IO without any non-error, synchronous exceptions") @@ -8010,7 +8421,7 @@ handled safely, this is what you're left with.") (define-public ghc-json (package (name "ghc-json") - (version "0.9.1") + (version "0.9.2") (source (origin (method url-fetch) @@ -8018,11 +8429,10 @@ handled safely, this is what you're left with.") "json-" version ".tar.gz")) (sha256 (base32 - "18l5027vc68hnnxrxlnyl59vkkg95a92m1zzms0dqiby2r6pxdcn")))) + "13kkfgx58z18jphbg56jn08jn72wi3kvfndlwwx87hqwg7x1dfz6")))) (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") @@ -8033,61 +8443,88 @@ JSON (JavaScript Object Notation) is a lightweight data-interchange format.") (license license:bsd-3))) (define-public ghc-esqueleto - (package - (name "ghc-esqueleto") - (version "2.5.3") - (source - (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "esqueleto/esqueleto-" version ".tar.gz")) - (sha256 - (base32 - "10n49rzqmblky7pwjnysalyy6nacmxfms8dqbsdv6hlyzr8pb69x")))) - (build-system haskell-build-system) - (inputs - `(("ghc-blaze-html" ,ghc-blaze-html) - ("ghc-conduit" ,ghc-conduit) - ("ghc-monad-logger" ,ghc-monad-logger) - ("ghc-persistent" ,ghc-persistent) - ("ghc-resourcet" ,ghc-resourcet) - ("ghc-tagged" ,ghc-tagged) - ("ghc-text" ,ghc-text) - ("ghc-unordered-containers" ,ghc-unordered-containers))) - (native-inputs - `(("ghc-hspec" ,ghc-hspec) - ("ghc-hunit" ,ghc-hunit) - ("ghc-monad-control" ,ghc-monad-control) - ("ghc-persistent-sqlite" ,ghc-persistent-sqlite) - ("ghc-persistent-template" ,ghc-persistent-template) - ("ghc-quickcheck" ,ghc-quickcheck))) - (home-page "https://github.com/bitemyapp/esqueleto") - (synopsis "Type-safe embedded domain specific language for SQL queries") - (description "This library provides a type-safe embedded domain specific + (let ((version "2.5.3") + (revision "1") + (commit "b81e0d951e510ebffca03c5a58658ad884cc6fbd")) + (package + (name "ghc-esqueleto") + (version (git-version version revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/bitemyapp/esqueleto") + (commit commit))) + (sha256 + (base32 + "0lz1qxms7cfg5p3j37inlych0r2fwhm8xbarcys3df9m7jy9nixa")))) + (build-system haskell-build-system) + (arguments + `(#:haddock? #f ; Haddock reports an internal error. + #:phases + (modify-phases %standard-phases + ;; This package normally runs tests for the MySQL, PostgreSQL, and + ;; SQLite backends. Since we only have Haskell packages for + ;; SQLite, we remove the other two test suites. FIXME: Add the + ;; other backends and run all three test suites. + (add-before 'configure 'remove-non-sqlite-test-suites + (lambda _ + (use-modules (ice-9 rdelim)) + (with-atomic-file-replacement "esqueleto.cabal" + (lambda (in out) + (let loop ((line (read-line in 'concat)) (deleting? #f)) + (cond + ((eof-object? line) #t) + ((string-every char-set:whitespace line) + (unless deleting? (display line out)) + (loop (read-line in 'concat) #f)) + ((member line '("test-suite mysql\n" + "test-suite postgresql\n")) + (loop (read-line in 'concat) #t)) + (else + (unless deleting? (display line out)) + (loop (read-line in 'concat) deleting?))))))))))) + (inputs + `(("ghc-blaze-html" ,ghc-blaze-html) + ("ghc-conduit" ,ghc-conduit) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-persistent" ,ghc-persistent) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-tagged" ,ghc-tagged) + ("ghc-text" ,ghc-text) + ("ghc-unliftio" ,ghc-unliftio) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-persistent-sqlite" ,ghc-persistent-sqlite) + ("ghc-persistent-template" ,ghc-persistent-template))) + (home-page "https://github.com/bitemyapp/esqueleto") + (synopsis "Type-safe embedded domain specific language for SQL queries") + (description "This library provides a type-safe embedded domain specific language (EDSL) for SQL queries that works with SQL backends as provided by @code{ghc-persistent}. Its language closely resembles SQL, so you don't have to learn new concepts, just new syntax, and it's fairly easy to predict the generated SQL and optimize it for your backend.") - (license license:bsd-3))) + (license license:bsd-3)))) (define-public shellcheck (package (name "shellcheck") - (version "0.4.6") + (version "0.5.0") (source (origin (method url-fetch) - (uri (string-append "https://github.com/koalaman/shellcheck/archive/" - "v" version ".tar.gz")) + (uri (string-append + "https://hackage.haskell.org/package/ShellCheck/ShellCheck-" + version ".tar.gz")) (sha256 (base32 - "1qkd69lc34n3l23ss9rq1azvx49bfq4hi4bmaj76rgxybscxhg0w")) + "0z1hscbr11hwkq8k1v0vaa947hb9m6k4cm831jk1gpj8dxrk151b")) (file-name (string-append name "-" version ".tar.gz")))) (build-system haskell-build-system) (inputs - `(("ghc-quickcheck" ,ghc-quickcheck) - ("ghc-json" ,ghc-json) - ("ghc-mtl" ,ghc-mtl) + `(("ghc-aeson" ,ghc-aeson) + ("ghc-quickcheck" ,ghc-quickcheck) ("ghc-parsec" ,ghc-parsec) ("ghc-regex-tdfa" ,ghc-regex-tdfa))) (home-page "https://github.com/koalaman/shellcheck") @@ -8109,7 +8546,7 @@ advanced user's otherwise working script to fail under future circumstances. (define-public ghc-simple-sendfile (package (name "ghc-simple-sendfile") - (version "0.2.25") + (version "0.2.27") (source (origin (method url-fetch) @@ -8118,7 +8555,7 @@ advanced user's otherwise working script to fail under future circumstances. "simple-sendfile-" version ".tar.gz")) (sha256 (base32 - "0k99j9xfcf83c55jmn202hdinhjaa4yn3dal4rvjk2w2rlhqirha")))) + "1bwwqzcm56m2w4ymsa054sxmpbj76h9pvb0jf8zxp8lr41cp51gn")))) (build-system haskell-build-system) (inputs `(("ghc-conduit" ,ghc-conduit) @@ -8157,7 +8594,7 @@ bytestrings and their hexademical representation.") (define-public ghc-psqueues (package (name "ghc-psqueues") - (version "0.2.6.0") + (version "0.2.7.0") (source (origin (method url-fetch) @@ -8166,10 +8603,8 @@ bytestrings and their hexademical representation.") "psqueues-" version ".tar.gz")) (sha256 (base32 - "0n39s1i88j6s7vvsdhpbhcr3gpbwlzabwcc3nbd7nqb4kb4i0sls")))) + "1sjgc9bxh63kkdp59nbirx3xazr02ia5yhp4f4a0jnq1hj465wsc")))) (build-system haskell-build-system) - (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck"))) (inputs `(("ghc-hashable" ,ghc-hashable))) (native-inputs @@ -8224,7 +8659,7 @@ Typical applications of Priority Search Queues include: (define-public ghc-glob (package (name "ghc-glob") - (version "0.9.1") + (version "0.9.2") (source (origin (method url-fetch) @@ -8233,7 +8668,7 @@ Typical applications of Priority Search Queues include: "Glob-" version ".tar.gz")) (sha256 (base32 - "0rzmsknl02p332dxmm36fyrz3dpma7bchn0ymyjipxvqil20pjw0")))) + "1rbwcq9w9951qsnp13vqcm9r01yax2yh1wk8s4zxa3ckk9717iwg")))) (build-system haskell-build-system) (inputs `(("ghc-dlist" ,ghc-dlist) @@ -8254,7 +8689,7 @@ matching patterns against file paths.") (define-public ghc-errors (package (name "ghc-errors") - (version "2.2.2") + (version "2.3.0") (source (origin (method url-fetch) @@ -8263,7 +8698,7 @@ matching patterns against file paths.") "errors-" version ".tar.gz")) (sha256 (base32 - "13sflhglcm5skwrxb48fw96skdcx7ydiy4zg22200733pxhjncpn")))) + "0x8znwn31qcx6kqx99wp7bc86kckfb39ncz3zxvj1s07kxlfawk7")))) (build-system haskell-build-system) (inputs `(("ghc-exceptions" ,ghc-exceptions) @@ -8396,7 +8831,7 @@ between 2 and 3 times faster than the Mersenne Twister.") (define-public ghc-vector-algorithms (package (name "ghc-vector-algorithms") - (version "0.7.0.1") + (version "0.7.0.4") (source (origin (method url-fetch) @@ -8405,23 +8840,10 @@ between 2 and 3 times faster than the Mersenne Twister.") "vector-algorithms-" version ".tar.gz")) (sha256 (base32 - "0w4hf598lpxfg58rnimcqxrbnpqq2jmpjx82qa5md3q6r90hlipd")))) + "0mfa8ig9v69l41p2vb5jl4qmaln5y1rlzarr2mlgm8g1nvq8qqdg")))) (build-system haskell-build-system) - ;; The limits have been adjusted in a revision of the cabal file. - (arguments - '(#:configure-flags (list "--allow-newer=vector") - #:phases - (modify-phases %standard-phases - ;; The tests cannot be built due to type errors. - (add-after 'unpack 'do-not-build-quickcheck-tests - (lambda _ - (substitute* "vector-algorithms.cabal" - (("\\!flag\\(properties\\)") "True")) - #t))))) (inputs - `(("ghc-vector" ,ghc-vector) - ("ghc-mtl" ,ghc-mtl) - ("ghc-mwc-random" ,ghc-mwc-random))) + `(("ghc-vector" ,ghc-vector))) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck))) (home-page "https://github.com/bos/math-functions") @@ -8496,8 +8918,7 @@ module for more details.") (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, @@ -8559,8 +8980,7 @@ This package also includes a simple reference implementation based on ("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) @@ -8591,6 +9011,11 @@ that are much lighter weight than IO-threads.") (base32 "0y27gafkib0x0fn39qfn2rkgsfrm09ng35sbb5dwr7rclhnxz59l")))) (build-system haskell-build-system) + (arguments + '(#:cabal-revision + ("2" "1bx70yqkn62ii17fjv3pig4hklrzkqd09zj67zzjiyjzmn04fir3") + ;; Two tests fail: "Discrete CDF is OK" and "Quantile is CDF inverse". + #:tests? #f)) (inputs `(("ghc-aeson" ,ghc-aeson) ("ghc-base-orphans" ,ghc-base-orphans) @@ -8610,8 +9035,6 @@ that are much lighter weight than IO-threads.") ("ghc-test-framework" ,ghc-test-framework) ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2))) - (arguments - `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails. (home-page "https://github.com/bos/mwc-random") (synopsis "Haskell library of statistical types, data, and functions") (description "This library provides a number of common functions @@ -8639,7 +9062,7 @@ and regression and autocorrelation analysis. (define-public ghc-chunked-data (package (name "ghc-chunked-data") - (version "0.3.0") + (version "0.3.1") (source (origin (method url-fetch) @@ -8648,7 +9071,7 @@ and regression and autocorrelation analysis. "chunked-data-" version ".tar.gz")) (sha256 (base32 - "0bszq6fijnr4pmadzz89smj7kfmzx0ca3wd9ga8gv0in9jk9vgp1")))) + "16m7y7fwrirbjbqqcsfmr4yxa9qvfax6r7pw0zl9ky71ms0wa47p")))) (build-system haskell-build-system) (inputs `(("ghc-vector" ,ghc-vector) ("ghc-semigroups" ,ghc-semigroups) @@ -8663,7 +9086,7 @@ classy-prelude.") (define-public ghc-base-prelude (package (name "ghc-base-prelude") - (version "1.2.0.1") + (version "1.3") (source (origin (method url-fetch) @@ -8672,7 +9095,7 @@ classy-prelude.") "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 @@ -8718,7 +9141,7 @@ statically known size.") (define-public ghc-contravariant-extras (package (name "ghc-contravariant-extras") - (version "0.3.3.1") + (version "0.3.4") (source (origin (method url-fetch) @@ -8727,11 +9150,13 @@ statically known size.") "contravariant-extras-" version ".tar.gz")) (sha256 (base32 - "1mbrgjybdx8fjdck4ldwi8955w4qnmm0ql56zix7dyn0s7s9spgk")))) + "0gg62ccl94kvh7mnvdq09pifqxjx2kgs189si90nmg44bafj7a9n")))) (build-system haskell-build-system) - (inputs `(("ghc-tuple-th" ,ghc-tuple-th) - ("ghc-contravariant" ,ghc-contravariant) - ("ghc-base-prelude" ,ghc-base-prelude))) + (inputs + `(("ghc-tuple-th" ,ghc-tuple-th) + ("ghc-contravariant" ,ghc-contravariant) + ("ghc-base-prelude" ,ghc-base-prelude) + ("ghc-semigroups" ,ghc-semigroups))) (home-page "https://github.com/nikita-volkov/contravariant-extras") (synopsis "Extras for the @code{ghc-contravariant} Haskell package") (description "This Haskell package provides extras for the @@ -8741,7 +9166,7 @@ statically known size.") (define-public ghc-monadrandom (package (name "ghc-monadrandom") - (version "0.4.2.3") + (version "0.5.1.1") (source (origin (method url-fetch) @@ -8750,10 +9175,9 @@ statically known size.") "MonadRandom-" version ".tar.gz")) (sha256 (base32 - "1h1nhswrcmhy3mq6vd530p0df51fcnnf4csbwnljar7cf0mb2h6y")))) + "0w44jl1n3kqvqaflh82l1wj3xxbhzfs3kf4m8rk7w6fgg8llmnmb")))) (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))) @@ -8766,7 +9190,7 @@ which consume random values.") (define-public ghc-either (package (name "ghc-either") - (version "4.4.1.1") + (version "5.0.1") (source (origin (method url-fetch) @@ -8775,19 +9199,22 @@ which consume random values.") "either-" version ".tar.gz")) (sha256 (base32 - "1lrlwqqnm6ibfcydlv5qvvssw7bm0c6yypy0rayjzv1znq7wp1xh")))) + "064hjfld7dkzs78sy30k5qkiva3hx24rax6dvzz5ygr2c0zypdkc")))) (build-system haskell-build-system) (inputs `(("ghc-bifunctors" ,ghc-bifunctors) ("ghc-exceptions" ,ghc-exceptions) ("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-semigroupoids" ,ghc-semigroupoids) ("ghc-transformers-base" ,ghc-transformers-base))) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2))) (home-page "https://github.com/ekmett/either") (synopsis "Provides an either monad transformer for Haskell") (description "This Haskell package provides an either monad transformer.") @@ -8816,7 +9243,7 @@ ByteStrings in the style of other common *nix hex dump tools.") (define-public ghc-network-info (package (name "ghc-network-info") - (version "0.2.0.8") + (version "0.2.0.10") (source (origin (method url-fetch) @@ -8825,7 +9252,7 @@ ByteStrings in the style of other common *nix hex dump tools.") "network-info-" version ".tar.gz")) (sha256 (base32 - "0xndvg776241fgjmynxfpy81f1csjmh8dg33yf0c8m71ychz3pzc")))) + "0anmgzcpnz7nw3n6vq0r25m1s9l2svpwi83wza0lzkrlbnbzd02n")))) (build-system haskell-build-system) (home-page "https://github.com/jystic/network-info") (synopsis "Access the local computer's basic network configuration") @@ -8850,8 +9277,16 @@ IPv4, IPv6 and MAC addresses.") "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck" - "--allow-newer=HUnit"))) + `(#:phases + (modify-phases %standard-phases + (add-before 'configure 'strip-test-framework-constraints + (lambda _ + (substitute* "uuid-types.cabal" + (("HUnit >=1\\.2 && < 1\\.4") "HUnit") + (("QuickCheck >=2\\.4 && < 2\\.9") "QuickCheck") + (("tasty >= 0\\.10 && < 0\\.12") "tasty") + (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit") + (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck"))))))) (inputs `(("ghc-hashable" ,ghc-hashable) ("ghc-random" ,ghc-random) ("ghc-text" ,ghc-text))) @@ -8883,8 +9318,18 @@ functions.") "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z")))) (build-system haskell-build-system) (arguments - `(#:configure-flags (list "--allow-newer=QuickCheck" - "--allow-newer=HUnit"))) + `(#:cabal-revision + ("2" "0m185q62jkfb5jsv358nxbnrkv8y8hd0qqvgvh22wvc5g9ipz0r9") + #:phases + (modify-phases %standard-phases + (add-before 'configure 'strip-test-framework-constraints + (lambda _ + (substitute* "uuid.cabal" + (("HUnit >= 1\\.2 && < 1\\.4") "HUnit") + (("QuickCheck >= 2\\.4 && < 2\\.10") "QuickCheck") + (("tasty >= 0\\.10 && < 0\\.12") "tasty") + (("tasty-hunit == 0\\.9\\.\\*") "tasty-hunit") + (("tasty-quickcheck == 0\\.8\\.\\*") "tasty-quickcheck"))))))) (inputs `(("ghc-cryptohash-sha1" ,ghc-cryptohash-sha1) ("ghc-cryptohash-md5" ,ghc-cryptohash-md5) ("ghc-entropy" ,ghc-entropy) @@ -8906,7 +9351,7 @@ parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.") (define-public ghc-rebase (package (name "ghc-rebase") - (version "1.1") + (version "1.2.4") (source (origin (method url-fetch) @@ -8915,7 +9360,7 @@ parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.") "rebase-" version ".tar.gz")) (sha256 (base32 - "1qkhnpcc4g2vd6jmbf3b6psqkan6hyawqzrwzqdd931hsb02l6ia")))) + "1gah2qwfpzwamnikbc5h4nv6dgvv9h16di9ka7946za3nibyasya")))) (build-system haskell-build-system) (inputs `(("ghc-stm" ,ghc-stm) ("ghc-hashable" ,ghc-hashable) @@ -8931,7 +9376,6 @@ parsing and printing @dfn{Universally Unique Identifiers} or UUIDs.") ("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))) @@ -8961,10 +9405,33 @@ The package is intended to rapidly evolve with the contribution from the community, with the missing features being added with pull-requests.") (license license:expat))) +(define-public ghc-rerebase + (package + (name "ghc-rerebase") + (version "1.2.2") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/rerebase/rerebase-" + version ".tar.gz")) + (sha256 + (base32 + "11v6rmz7ql2rdx6mhb3lsal952lwihclfhh0m7fcnii5br0906ks")))) + (build-system haskell-build-system) + (inputs + `(("ghc-rebase" ,ghc-rebase))) + (home-page "https://github.com/nikita-volkov/rerebase") + (synopsis "Reexports from ``base'' with many other standard libraries") + (description "A rich drop-in replacement for ``base''. For details and +documentation please visit @uref{https://github.com/nikita-volkov/rerebase, +the project's home page}.") + (license license:expat))) + (define-public ghc-vector-builder (package (name "ghc-vector-builder") - (version "0.3.1") + (version "0.3.6") (source (origin (method url-fetch) @@ -8973,17 +9440,18 @@ the community, with the missing features being added with pull-requests.") "vector-builder-" version ".tar.gz")) (sha256 (base32 - "1l6sfgd2s107zkp1qd1w6jdjcbznp31769qf99pxar087f697wvp")))) + "06d2pa1fb3ydrl7l6rjazqyxv5i73v65x2f5fp0ypjxfbm6jsmn8")))) (build-system haskell-build-system) (inputs `(("ghc-vector" ,ghc-vector) ("ghc-semigroups" ,ghc-semigroups) ("ghc-base-prelude" ,ghc-base-prelude))) - (native-inputs `(("ghc-tasty" ,ghc-tasty) + (native-inputs `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-tasty" ,ghc-tasty) ("ghc-tasty-hunit" ,ghc-tasty-hunit) ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) ("ghc-hunit" ,ghc-hunit) ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) - ("ghc-rebase" ,ghc-rebase))) + ("ghc-rerebase" ,ghc-rerebase))) (home-page "https://github.com/nikita-volkov/vector-builder") (synopsis "Vector builder for Haskell") (description "This Haskell package provides an API for constructing vectors. @@ -8998,7 +9466,7 @@ vector. ") (define-public ghc-foldl (package (name "ghc-foldl") - (version "1.3.5") + (version "1.4.3") (source (origin (method url-fetch) @@ -9007,7 +9475,7 @@ vector. ") "foldl-" version ".tar.gz")) (sha256 (base32 - "10qsp7dj2xsq4q2xm6x6b12y5pq32qf7my41hnkmdwwbccvhdxb2")))) + "13n0ca3hw5jzqf6rxsdbhbwkn61a9zlm13f0f205s60j3sc72jzk")))) (build-system haskell-build-system) (inputs `(("ghc-mwc-randam" ,ghc-mwc-random) ("ghc-primitive" ,ghc-primitive) @@ -9016,7 +9484,9 @@ vector. ") ("ghc-unordered-containers" ,ghc-unordered-containers) ("ghc-hashable" ,ghc-hashable) ("ghc-contravariant" ,ghc-contravariant) + ("ghc-semigroups" ,ghc-semigroups) ("ghc-profunctors" ,ghc-profunctors) + ("ghc-semigroupoids" ,ghc-semigroupoids) ("ghc-comonad" ,ghc-comonad) ("ghc-vector-builder" ,ghc-vector-builder))) (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library") @@ -9093,7 +9563,6 @@ data structures as non-empty.") ("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") @@ -9106,14 +9575,14 @@ as well as a convenient Conduit module.") (define-public ghc-aws (package (name "ghc-aws") - (version "0.18") + (version "0.20") (source (origin (method url-fetch) (uri (string-append "https://hackage.haskell.org/package/" "aws-" version "/aws-" version ".tar.gz")) (sha256 (base32 - "0h7473wkvc5xjzx5fd5k5fp70rjq5gqmn1cpy95mswvvfsq3irxj")))) + "0pwpabmypi1w8rni9qfwabgn95jks4h8dyw6889mn8xzsrhdhyf0")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; Tests require AWS credentials. (inputs @@ -9131,8 +9600,8 @@ as well as a convenient Conduit module.") ("ghc-data-default" ,ghc-data-default) ("ghc-http-conduit" ,ghc-http-conduit) ("ghc-http-types" ,ghc-http-types) + ("ghc-lifted-base" ,ghc-lifted-base) ("ghc-monad-control" ,ghc-monad-control) - ("ghc-mtl" ,ghc-mtl) ("ghc-network" ,ghc-network) ("ghc-old-locale" ,ghc-old-locale) ("ghc-safe" ,ghc-safe) @@ -9164,7 +9633,7 @@ Web Services.") (define-public ghc-basement (package (name "ghc-basement") - (version "0.0.7") + (version "0.0.8") (source (origin (method url-fetch) @@ -9172,7 +9641,7 @@ Web Services.") "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") @@ -9184,7 +9653,7 @@ packages.") (define-public ghc-foundation (package (name "ghc-foundation") - (version "0.0.20") + (version "0.0.21") (source (origin (method url-fetch) @@ -9192,8 +9661,18 @@ packages.") "foundation/foundation-" version ".tar.gz")) (sha256 (base32 - "0bg4g0xf4pb2vmahnfp8c4f0a3v0av73lb5g8bwnp170khxfcsms")))) + "1q43y8wfj0wf9gdq2kzphwjwq6m5pvryy1lqgk954aq5z3ks1lsf")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'add-setup-script + (lambda _ + ;; The usual "Setup.hs" script is missing from the source. + (with-output-to-file "Setup.hs" + (lambda () + (format #t "import Distribution.Simple~%") + (format #t "main = defaultMain~%")))))))) (inputs `(("ghc-basement" ,ghc-basement))) (home-page "https://github.com/haskell-foundation/foundation") (synopsis "Alternative prelude with batteries and no dependencies") @@ -9262,7 +9741,7 @@ operators for looping.") (define-public ghc-monad-logger (package (name "ghc-monad-logger") - (version "0.3.25.1") + (version "0.3.29") (source (origin (method url-fetch) @@ -9271,7 +9750,7 @@ operators for looping.") "monad-logger-" version ".tar.gz")) (sha256 (base32 - "0yv4fsi566zrn30j2g5l901lyqgmflhvzy4hji7ikcbh5d45m920")))) + "1z516s4pa9n94zf0l45mylssg07xr1d1m6zrz900p0iv3vfd07mv")))) (build-system haskell-build-system) (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat) ("ghc-text" ,ghc-text) @@ -9285,7 +9764,6 @@ operators for looping.") ("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") @@ -9300,7 +9778,7 @@ code locations of messages.") (define-public ghc-shakespeare (package (name "ghc-shakespeare") - (version "2.0.14") + (version "2.0.15") (source (origin (method url-fetch) @@ -9309,7 +9787,7 @@ code locations of messages.") "shakespeare-" version ".tar.gz")) (sha256 (base32 - "0j5zx8ka7d7scvb9shm7k3376qzl3k4kpim9aqqfs6n86901zpl4")))) + "1vk4b19zvwy4mpwaq9z3l3kfmz75gfyf7alhh0y112gspgpccm23")))) (build-system haskell-build-system) (inputs `(("ghc-parsec" ,ghc-parsec) ("ghc-text" ,ghc-text) @@ -9334,7 +9812,7 @@ interpolates variables according to the type being inserted.") (define-public ghc-securemem (package (name "ghc-securemem") - (version "0.1.9") + (version "0.1.10") (source (origin (method url-fetch) @@ -9343,7 +9821,7 @@ interpolates variables according to the type being inserted.") "securemem-" version ".tar.gz")) (sha256 (base32 - "0dkhhjxa7njc3qbgvd5a23rkvr39vj2kn2a9nk6yjg7a8b2hvdpy")))) + "19hnw2cfbsfjynxq1bq9f6djbxhsc1k751ml0y1ab3ah913mm29j")))) (build-system haskell-build-system) (inputs `(("ghc-byteable" ,ghc-byteable) ("ghc-memory" ,ghc-memory))) @@ -9394,6 +9872,9 @@ connections.") (base32 "12l55b76bhya9q89mfmqmy6sl5v39b6gzrw5rf3f70vkb23nsv5a")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4"))) (inputs `(("ghc-attoparsec" ,ghc-attoparsec) ("ghc-base-compat" ,ghc-base-compat) ("ghc-text" ,ghc-text))) @@ -9406,7 +9887,7 @@ from aeson.") (define-public ghc-generics-sop (package (name "ghc-generics-sop") - (version "0.3.1.0") + (version "0.3.2.0") (source (origin (method url-fetch) @@ -9415,7 +9896,7 @@ from aeson.") "generics-sop-" version ".tar.gz")) (sha256 (base32 - "1bazlhgmxcwv7vd44jhdx74cnhmaz6yy47jxfycapjj4mjrnp0x7")))) + "168v62i845jh9jbfaz3ldz8svz4wmzq9mf2vhb7pxlnbkk8fqq1h")))) (build-system haskell-build-system) (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat))) (home-page "https://github.com/well-typed/generics-sop") @@ -9429,7 +9910,7 @@ each constructor are represented using an n-ary product.") (define-public ghc-uri-bytestring (package (name "ghc-uri-bytestring") - (version "0.3.1.0") + (version "0.3.2.0") (source (origin (method url-fetch) @@ -9438,7 +9919,7 @@ each constructor are represented using an n-ary product.") "uri-bytestring-" version ".tar.gz")) (sha256 (base32 - "04qjv1sgyrdg538290p9hqnvyxnahvr5cjwl8vm1rn9j0fv3ymq9")))) + "1q04j5ybvk37zk2m0bkjwyhblz0ymdj0cn4rvsvdca1ikn5xdv5c")))) (build-system haskell-build-system) (inputs `(("ghc-attoparsec" ,ghc-attoparsec) ("ghc-fail" ,ghc-fail) @@ -9463,7 +9944,7 @@ parser that uses ByteStrings for parsing and representing the URI data.") (define-public ghc-http-api-data (package (name "ghc-http-api-data") - (version "0.3.7.1") + (version "0.3.8.1") (source (origin (method url-fetch) @@ -9472,7 +9953,7 @@ parser that uses ByteStrings for parsing and representing the URI data.") "http-api-data-" version ".tar.gz")) (sha256 (base32 - "1zbmf0kkfsw7pfznisi205gh7jd284gfarxsyiavd2iw26akwqwc")))) + "1cq6459b8wz6nvkvpi89dg189n5q2xdq4rdq435hf150555vmskf")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Tests require QuickCheck >= 2.9 (inputs `(("ghc-attoparsec" ,ghc-attoparsec) @@ -9494,7 +9975,7 @@ Haskell data types to and from HTTP API data.") (define-public ghc-persistent (package (name "ghc-persistent") - (version "2.7.3.1") + (version "2.8.2") (source (origin (method url-fetch) @@ -9503,7 +9984,7 @@ Haskell data types to and from HTTP API data.") "persistent-" version ".tar.gz")) (sha256 (base32 - "1jbvavdvr9qz5ld7vf6l1jgiadhmxx6zc4vqsdk9ivfq6d5wlg1p")))) + "1h0yijbf1yiwl50klyafy4ln99j8bib4kgbzviw7fc4y4mwv4sv9")))) (build-system haskell-build-system) (inputs `(("ghc-old-locale" ,ghc-old-locale) ("ghc-text" ,ghc-text) @@ -9526,10 +10007,10 @@ Haskell data types to and from HTTP API data.") ("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))) + ("ghc-tagged" ,ghc-tagged) + ("ghc-void" ,ghc-void))) (native-inputs `(("ghc-hspec" ,ghc-hspec))) (home-page "https://www.yesodweb.com/book/persistent") (synopsis "Type-safe, multi-backend data serialization for Haskell") @@ -9541,7 +10022,7 @@ way.") (define-public ghc-aeson-compat (package (name "ghc-aeson-compat") - (version "0.3.7.1") + (version "0.3.8") (source (origin (method url-fetch) @@ -9550,7 +10031,7 @@ way.") "aeson-compat-" version ".tar.gz")) (sha256 (base32 - "1jya3lm9imclhb8qqihv39hhb62vvs3qpws7pc5fc23vwg0hsx2r")))) + "0j4v13pgk21zy8hqkbx8hw0n05jdl17qphxz9rj4h333pr547r3i")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: Tests require QuickCheck >= 2.10 (inputs `(("ghc-base-compat" ,ghc-base-compat) @@ -9576,7 +10057,7 @@ ghc-aeson.") (define-public ghc-persistent-template (package (name "ghc-persistent-template") - (version "2.5.3.1") + (version "2.5.4") (source (origin (method url-fetch) @@ -9585,8 +10066,11 @@ ghc-aeson.") "persistent-template-" version ".tar.gz")) (sha256 (base32 - "0449piw3n02q7dag7k1pakfmzmf3ms4wk1qmnagczpm1ckajinwd")))) + "008afcy7zbw7bzp9jww8gdldb51kfm0fg4p0x4xcp61gx4679bjc")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("2" "03qgwk32krldph3blw5agiqcpccr3649hajyn8wm9k71zz82dpn6"))) (inputs `(("ghc-persistent" ,ghc-persistent) ("ghc-monad-control" ,ghc-monad-control) ("ghc-text" ,ghc-text) @@ -9619,6 +10103,9 @@ functions for the ghc-persistent package.") (base32 "1193fplsjm1lcr05xwvkj1rsyzx74i755f6kw3ikmxbsv0bv0l3m")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" "16bjwcsaghqqmyi69rq65dn3ydifyfaabq3ns37apdm00mwqbcj2"))) (home-page "https://github.com/fpco/unliftio/tree/master/unliftio-core#readme") (synopsis "The MonadUnliftIO typeclass for unlifting monads to IO") @@ -9630,7 +10117,7 @@ functions.") (define-public ghc-microlens (package (name "ghc-microlens") - (version "0.4.8.3") + (version "0.4.9.1") (source (origin (method url-fetch) @@ -9639,7 +10126,7 @@ functions.") "microlens-" version ".tar.gz")) (sha256 (base32 - "17qx2mbqdrlnkc3gxq8njbp7qw8nh51drmz6fc8khgj9bls5ni2k")))) + "0j2nzf0vpx2anvsrg2w0vy2z4jn3kkcs2n6glkzblhn1j9piqh51")))) (build-system haskell-build-system) (home-page "https://github.com/aelve/microlens") @@ -9655,7 +10142,7 @@ stripped. As the result, this package has no dependencies.") (define-public ghc-microlens-th (package (name "ghc-microlens-th") - (version "0.4.1.3") + (version "0.4.2.2") (source (origin (method url-fetch) @@ -9664,9 +10151,10 @@ stripped. As the result, this package has no dependencies.") "microlens-th-" version ".tar.gz")) (sha256 (base32 - "15a12cqxlgbcn1n73zwrxnp2vfm8b0ma0a0sdd8zmjbs8zy3np4f")))) + "02nj7lnl61yffi3c6wn341arxhld5r0vj6nzcb5zmqjhnqsv8c05")))) (build-system haskell-build-system) - (inputs `(("ghc-microlens" ,ghc-microlens))) + (inputs `(("ghc-microlens" ,ghc-microlens) + ("ghc-th-abstraction" ,ghc-th-abstraction))) (home-page "https://github.com/aelve/microlens") (synopsis "Automatic generation of record lenses for @@ -9680,7 +10168,7 @@ used both from lens and microlens).") (define-public ghc-unliftio (package (name "ghc-unliftio") - (version "0.2.4.0") + (version "0.2.7.0") (source (origin (method url-fetch) @@ -9690,7 +10178,7 @@ used both from lens and microlens).") ".tar.gz")) (sha256 (base32 - "0vpncmwaq5zb6bziqfns4qdgxmq8ky0rlxna2yngxp170s5zxx9z")))) + "0qql93lq5w7qghl454cc3s1i8v1jb4h08n82fqkw0kli4g3g9njs")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH (inputs @@ -9709,7 +10197,7 @@ working with it.") (define-public ghc-persistent-sqlite (package (name "ghc-persistent-sqlite") - (version "2.6.4") + (version "2.8.2") (source (origin (method url-fetch) @@ -9718,7 +10206,7 @@ working with it.") "persistent-sqlite-" version ".tar.gz")) (sha256 (base32 - "16mc2ra0hbyyc8ckjlxxc11bpskdymbr8c3g6ih6wzik639xprbm")))) + "1chbmvjz46smhgnzhha3bbkhys3fys6dip1jr4v7xp1jf78zbyp6")))) (build-system haskell-build-system) (inputs `(("ghc-persistent" ,ghc-persistent) ("ghc-unliftio-core" ,ghc-unliftio-core) @@ -9745,7 +10233,7 @@ system dependencies.") (define-public ghc-email-validate (package (name "ghc-email-validate") - (version "2.3.2.1") + (version "2.3.2.6") (source (origin (method url-fetch) @@ -9756,7 +10244,7 @@ system dependencies.") ".tar.gz")) (sha256 (base32 - "0qvxysiap3r4mi3xff5nsk9qv6diqxfgwj186bypbamzvzlz0lav")))) + "0chgylvc8xmhp933rdbmpg5sv4y7yg2h6kbf0ip1dzmbd5p55pa5")))) (build-system haskell-build-system) (inputs `(("ghc-attoparsec" ,ghc-attoparsec) @@ -9771,26 +10259,10 @@ system dependencies.") address string against RFC 5322.") (license license:bsd-3))) -(define-public ghc-semigroupoids-5.2.2 - (package - (inherit ghc-semigroupoids) - (name "ghc-semigroupoids") - (version "5.2.2") - (source (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "semigroupoids-" version "/semigroupoids-" - version ".tar.gz")) - (sha256 - (base32 - "17i96y4iqj8clcs090lf6k0ij3j16nj14vsfwz0mm9nd6i4gbpp4")))) - (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers) - ,@(package-inputs ghc-semigroupoids))))) - (define-public ghc-bytes (package (name "ghc-bytes") - (version "0.15.4") + (version "0.15.5") (source (origin (method url-fetch) @@ -9801,12 +10273,11 @@ address string against RFC 5322.") (file-name (string-append name "-" version ".tar.gz")) (sha256 (base32 - "121x3iqlm8pghw8cd9g30cnqbl7jrdpfjxdanmqdqllajw6xivrm")))) + "063il2vrn0p88r9gzndh4ijs0mxj37khkc9ym9bqdsv7ngk3b683")))) (build-system haskell-build-system) (inputs `(("ghc-cereal" ,ghc-cereal) ("cabal-doctest" ,cabal-doctest) - ("ghc-doctest" ,ghc-doctest-0.13) - ("ghc-mtl" ,ghc-mtl) + ("ghc-doctest" ,ghc-doctest) ("ghc-scientific" ,ghc-scientific) ("ghc-text" ,ghc-text) ("ghc-transformers-compat" ,ghc-transformers-compat) @@ -9906,7 +10377,6 @@ This package provides an orphan instance.") (inputs `(("ghc-network" ,ghc-network) ("ghc-parsec" ,ghc-parsec) - ("ghc-mtl" ,ghc-mtl) ("ghc-hunit" ,ghc-hunit) ("ghc-regex-compat" ,ghc-regex-compat) ("ghc-hslogger" ,ghc-hslogger) @@ -9962,8 +10432,7 @@ example code on the home page for a quick introduction.") "1x2abg2q9d26h1vzj40r6k7k3gqgappbs4g9d853vvg77837km4i")))) (build-system haskell-build-system) (inputs - `(("ghc-mtl" ,ghc-mtl) - ("ghc-random" ,ghc-random))) + `(("ghc-random" ,ghc-random))) (home-page "http://wiki.haskell.org/Operational") (synopsis "Implementation of difficult monads made easy with operational semantics") (description @@ -10008,7 +10477,7 @@ tools are not needed to actually run Gtk2Hs programs.") (define-public ghc-chart (package (name "ghc-chart") - (version "1.8.3") + (version "1.9") (source (origin (method url-fetch) @@ -10016,11 +10485,10 @@ tools are not needed to actually run Gtk2Hs programs.") "Chart-" version ".tar.gz")) (sha256 (base32 - "13s64fhb2pmkdmx5bkgbgcn25qjihs364fvr47a1dw25f804kiy1")))) + "1f5azj17y8xsb3gjhf7gg1gnnlq12rxkmfjmgcly314d7vghs05z")))) (build-system haskell-build-system) (inputs `(("ghc-old-locale" ,ghc-old-locale) - ("ghc-mtl" ,ghc-mtl) ("ghc-lens" ,ghc-lens) ("ghc-colour" ,ghc-colour) ("ghc-data-default-class" ,ghc-data-default-class) @@ -10033,4 +10501,867 @@ tools are not needed to actually run Gtk2Hs programs.") 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))) + +(define-public ghc-wcwidth-bootstrap + (package + (inherit ghc-wcwidth) + (name "ghc-wcwidth-bootstrap") + (inputs + `(("ghc-setlocale" ,ghc-setlocale) + ("ghc-utf8-string" ,ghc-utf8-string) + ("ghc-attoparsec" ,ghc-attoparsec-bootstrap))) + (properties '(hidden? #t)))) + +(define-public ghc-rio + (package + (name "ghc-rio") + (version "0.1.5.0") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/rio/rio-" + version ".tar.gz")) + (sha256 + (base32 + "064h8a4hp53a479d3ak0vmqbx8hi0cpg7zn4wp23rjy26dka8p7g")))) + (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'add-setup-script + (lambda _ + ;; The usual "Setup.hs" script is missing from the source. + (with-output-to-file "Setup.hs" + (lambda () + (format #t "import Distribution.Simple~%") + (format #t "main = defaultMain~%")))))))) + (inputs + `(("ghc-exceptions" ,ghc-exceptions) + ("ghc-hashable" ,ghc-hashable) + ("ghc-microlens" ,ghc-microlens) + ("ghc-primitive" ,ghc-primitive) + ("ghc-text" ,ghc-text) + ("ghc-typed-process" ,ghc-typed-process) + ("ghc-unliftio" ,ghc-unliftio) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/commercialhaskell/rio#readme") + (synopsis "A standard library for Haskell") + (description "This package works as a prelude replacement for Haskell, +providing more functionality and types out of the box than the standard +prelude (such as common data types like @code{ByteString} and +@code{Text}), as well as removing common ``gotchas'', like partial +functions and lazy I/O. The guiding principle here is: +@itemize +@item If something is safe to use in general and has no expected naming +conflicts, expose it. +@item If something should not always be used, or has naming conflicts, +expose it from another module in the hierarchy. +@end itemize") + (license license:expat))) + +(define-public ghc-cairo + (package + (name "ghc-cairo") + (version "0.13.5.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/cairo/" + "cairo-" version ".tar.gz")) + (sha256 + (base32 + "1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2")))) + (build-system haskell-build-system) + (arguments + `(#:modules ((guix build haskell-build-system) + (guix build utils) + (ice-9 match) + (srfi srfi-26)) + #:phases + (modify-phases %standard-phases + ;; FIXME: This is a copy of the standard configure phase with a tiny + ;; difference: this package needs the -package-db flag to be passed + ;; to "runhaskell" in addition to the "configure" action, because it + ;; depends on gtk2hs-buildtools, which provide setup hooks. Without + ;; this option the Setup.hs file cannot be evaluated. The + ;; haskell-build-system should be changed to pass "-package-db" to + ;; "runhaskell" in any case. + (replace 'configure + (lambda* (#:key outputs inputs tests? (configure-flags '()) + #:allow-other-keys) + (let* ((out (assoc-ref outputs "out")) + (name-version (strip-store-file-name out)) + (input-dirs (match inputs + (((_ . dir) ...) + dir) + (_ '()))) + (ghc-path (getenv "GHC_PACKAGE_PATH")) + (params (append `(,(string-append "--prefix=" out)) + `(,(string-append "--libdir=" out "/lib")) + `(,(string-append "--bindir=" out "/bin")) + `(,(string-append + "--docdir=" out + "/share/doc/" name-version)) + '("--libsubdir=$compiler/$pkg-$version") + '("--package-db=../package.conf.d") + '("--global") + `(,@(map + (cut string-append "--extra-include-dirs=" <>) + (search-path-as-list '("include") input-dirs))) + `(,@(map + (cut string-append "--extra-lib-dirs=" <>) + (search-path-as-list '("lib") input-dirs))) + (if tests? + '("--enable-tests") + '()) + configure-flags))) + (unsetenv "GHC_PACKAGE_PATH") + (apply invoke "runhaskell" "-package-db=../package.conf.d" + "Setup.hs" "configure" params) + (setenv "GHC_PACKAGE_PATH" ghc-path) + #t)))))) + (inputs + `(("ghc-utf8-string" ,ghc-utf8-string) + ("ghc-text" ,ghc-text) + ("cairo" ,cairo))) + (native-inputs + `(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools) + ("pkg-config" ,pkg-config))) + (home-page "http://projects.haskell.org/gtk2hs/") + (synopsis "Haskell bindings to the Cairo vector graphics library") + (description + "Cairo is a library to render high quality vector graphics. There exist +various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG +documents, amongst others.") + (license license:bsd-3))) + +(define-public ghc-chart-cairo + (package + (name "ghc-chart-cairo") + (version "1.9") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/Chart-cairo/" + "Chart-cairo-" version ".tar.gz")) + (sha256 + (base32 + "0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr")))) + (build-system haskell-build-system) + (inputs + `(("ghc-old-locale" ,ghc-old-locale) + ("ghc-cairo" ,ghc-cairo) + ("ghc-colour" ,ghc-colour) + ("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-operational" ,ghc-operational) + ("ghc-lens" ,ghc-lens) + ("ghc-chart" ,ghc-chart))) + (home-page "https://github.com/timbod7/haskell-chart/wiki") + (synopsis "Cairo backend for Charts") + (description "This package provides a Cairo vector graphics rendering +backend for the Charts library.") + (license license:bsd-3))) + +(define-public ghc-atomic-write + (package + (name "ghc-atomic-write") + (version "0.2.0.5") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/atomic-write/atomic-write-" + version + ".tar.gz")) + (sha256 + (base32 + "1iaq0hprxcv0sl1sgwcgmm87zraf738va1bciwnx2jkk3k1v9iyv")))) + (build-system haskell-build-system) + (inputs + `(("ghc-temporary" ,ghc-temporary) + ("ghc-unix-compat" ,ghc-unix-compat) + ("ghc-text" ,ghc-text))) + (native-inputs + `(("ghc-temporary" ,ghc-temporary) + ("ghc-unix-compat" ,ghc-unix-compat) + ("ghc-text" ,ghc-text) + ("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/stackbuilders/atomic-write") + (synopsis "Atomically write to a file") + (description + "Atomically write to a file on POSIX-compliant systems while preserving +permissions. @code{mv} is an atomic operation. This makes it simple to write +to a file atomically just by using the @code{mv} operation. However, this +will destroy the permissions on the original file. This library preserves +permissions while atomically writing to a file.") + (license license:expat))) + +(define-public ghc-cereal-conduit + (package + (name "ghc-cereal-conduit") + (version "0.8.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "cereal-conduit/cereal-conduit-" + version ".tar.gz")) + (sha256 + (base32 + "1srr7agvgfw78q5s1npjq5sgynvhjgllpihiv37ylkwqm4c4ap6r")))) + (build-system haskell-build-system) + (inputs + `(("ghc-conduit" ,ghc-conduit) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-cereal" ,ghc-cereal))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit))) + (home-page "https://github.com/snoyberg/conduit") + (synopsis "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits") + (description + "This package turn @code{Data.Serialize} @code{Gets} and @code{Puts} into +@code{Sources}, @code{Sinks}, and @code{Conduits}.") + (license license:bsd-3))) + +(define-public ghc-lzma + (package + (name "ghc-lzma") + (version "0.0.0.3") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/lzma/" + "lzma-" version ".tar.gz")) + (sha256 + (base32 + "0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg")))) + (build-system haskell-build-system) + (arguments + '(#:tests? #f ; requires older versions of QuickCheck and tasty. + #:cabal-revision + ("3" "1sify6gnsalyp6dakfzi0mdy5jcz2kcp9jsdsgkmxd40nfzgd44m"))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + (home-page "https://github.com/hvr/lzma") + (synopsis "LZMA/XZ compression and decompression") + (description + "This package provides a pure interface for compressing and +decompressing LZMA streams of data represented as lazy @code{ByteString}s. A +monadic incremental interface is provided as well.") + (license license:bsd-3))) + +(define-public ghc-stm-conduit + (package + (name "ghc-stm-conduit") + (version "4.0.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/stm-conduit/" + "stm-conduit-" version ".tar.gz")) + (sha256 + (base32 + "0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z")))) + (build-system haskell-build-system) + (inputs + `(("ghc-stm" ,ghc-stm) + ("ghc-stm-chans" ,ghc-stm-chans) + ("ghc-cereal" ,ghc-cereal) + ("ghc-cereal-conduit" ,ghc-cereal-conduit) + ("ghc-conduit" ,ghc-conduit) + ("ghc-conduit-extra" ,ghc-conduit-extra) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-async" ,ghc-async) + ("ghc-monad-loops" ,ghc-monad-loops) + ("ghc-unliftio" ,ghc-unliftio))) + (native-inputs + `(("ghc-doctest" ,ghc-doctest) + ("ghc-quickcheck" ,ghc-quickcheck) + ("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/cgaebel/stm-conduit") + (synopsis "Introduces conduits to channels and promotes using conduits concurrently") + (description + "This package provides two simple conduit wrappers around STM channels: a +source and a sink.") + (license license:bsd-3))) + +(define-public ghc-bindings-dsl + (package + (name "ghc-bindings-dsl") + (version "1.0.25") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/bindings-DSL/" + "bindings-DSL-" version ".tar.gz")) + (sha256 + (base32 + "0kqrd78nspl3lk4a0fqn47d8dirjg3b24dkvkigcrlb81hw35pk3")))) + (build-system haskell-build-system) + (home-page "https://github.com/jwiegley/bindings-dsl/wiki") + (synopsis "FFI domain specific language, on top of hsc2hs") + (description + "This is a set of macros to be used when writing Haskell FFI. They were +designed to be able to fully describe C interfaces, so that @code{hsc2hs} can +extract from them all Haskell code needed to mimic such interfaces. All +Haskell names used are automatically derived from C names, structures are +mapped to Haskell instances of @code{Storable}, and there are also macros you +can use with C code to help write bindings to inline functions or macro +functions.") + (license license:bsd-3))) + +(define-public ghc-lzma-conduit + (package + (name "ghc-lzma-conduit") + (version "1.2.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/lzma-conduit/" + "lzma-conduit-" version ".tar.gz")) + (sha256 + (base32 + "0hm72da7xk9l3zxjh274yg444vf405djxqbkf3q3p2qhicmxlmg9")))) + (build-system haskell-build-system) + (inputs + `(("ghc-conduit" ,ghc-conduit) + ("ghc-lzma" ,ghc-lzma) + ("ghc-resourcet" ,ghc-resourcet))) + (native-inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) + ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2) + ("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://github.com/alphaHeavy/lzma-conduit") + (synopsis "Conduit interface for lzma/xz compression") + (description + "This package provides a @code{Conduit} interface for the LZMA +compression algorithm used in the @code{.xz} file format.") + (license license:bsd-3))) + +(define-public ghc-bzlib-conduit + (package + (name "ghc-bzlib-conduit") + (version "0.3.0.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/bzlib-conduit/" + "bzlib-conduit-" version ".tar.gz")) + (sha256 + (base32 + "0fd2hnr782s7qgipazg2yxwia9qqhkvm9bcm90773c3zkxa13n23")))) + (build-system haskell-build-system) + (inputs + `(("ghc-bindings-dsl" ,ghc-bindings-dsl) + ("ghc-conduit" ,ghc-conduit) + ("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-resourcet" ,ghc-resourcet))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-random" ,ghc-random))) + (home-page "https://github.com/snoyberg/bzlib-conduit") + (synopsis "Streaming compression/decompression via conduits") + (description + "This package provides Haskell bindings to bzlib and Conduit support for +streaming compression and decompression.") + (license license:bsd-3))) + +(define-public ghc-pqueue + (package + (name "ghc-pqueue") + (version "1.4.1.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "pqueue/pqueue-" version ".tar.gz")) + (sha256 + (base32 + "1zvwm1zcqqq5n101s1brjhgbay8rf9fviq6gxbplf40i63m57p1x")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://hackage.haskell.org/package/pqueue") + (synopsis "Reliable, persistent, fast priority queues") + (description + "This package provides a fast, reliable priority queue implementation +based on a binomial heap.") + (license license:bsd-3))) + +(define-public ghc-conduit-algorithms + (package + (name "ghc-conduit-algorithms") + (version "0.0.8.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "conduit-algorithms/conduit-algorithms-" + version ".tar.gz")) + (sha256 + (base32 + "07gx2q3d1bbfw14q41rmqg0i4m018pci10lswc0k1ij6lw7sb9fd")))) + (build-system haskell-build-system) + (inputs + `(("ghc-async" ,ghc-async) + ("ghc-bzlib-conduit" ,ghc-bzlib-conduit) + ("ghc-conduit" ,ghc-conduit) + ("ghc-conduit-combinators" ,ghc-conduit-combinators) + ("ghc-conduit-extra" ,ghc-conduit-extra) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-lzma-conduit" ,ghc-lzma-conduit) + ("ghc-monad-control" ,ghc-monad-control) + ("ghc-pqueue" ,ghc-pqueue) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-stm" ,ghc-stm) + ("ghc-stm-conduit" ,ghc-stm-conduit) + ("ghc-streaming-commons" ,ghc-streaming-commons) + ("ghc-unliftio-core" ,ghc-unliftio-core) + ("ghc-vector" ,ghc-vector))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) + ("ghc-test-framework-th" ,ghc-test-framework-th))) + (home-page "https://github.com/luispedro/conduit-algorithms#readme") + (synopsis "Conduit-based algorithms") + (description + "This package provides algorithms on @code{Conduits}, including higher +level asynchronous processing and some other utilities.") + (license license:expat))) + +(define-public ghc-interpolate + (package + (name "ghc-interpolate") + (version "0.2.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/interpolate/" + "interpolate-" version ".tar.gz")) + (sha256 + (base32 + "1gkaj98yz363v38fv78sqby236mp8yqwqcilx7kr2b9z0w3204bf")))) + (build-system haskell-build-system) + (inputs + `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta))) + (native-inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) + ("ghc-text" ,ghc-text) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/sol/interpolate") + (synopsis "String interpolation library") + (description "This package provides a string interpolation library for +Haskell.") + (license license:expat))) + +(define-public ghc-hpack + (package + (name "ghc-hpack") + (version "0.28.2") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/hpack/" + "hpack-" version ".tar.gz")) + (sha256 + (base32 + "18w0h76jdp3mk9vin8da9iz3cwhcxmw787xy8wlh8bxcpcr16q5r")))) + (build-system haskell-build-system) + (inputs + `(("ghc-aeson" ,ghc-aeson) + ("ghc-bifunctors" ,ghc-bifunctors) + ("ghc-cryptonite" ,ghc-cryptonite) + ("ghc-glob" ,ghc-glob) + ("ghc-http-client" ,ghc-http-client) + ("ghc-http-client-tls" ,ghc-http-client-tls) + ("ghc-http-types" ,ghc-http-types) + ("ghc-scientific" ,ghc-scientific) + ("ghc-text" ,ghc-text) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector) + ("ghc-yaml" ,ghc-yaml))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-hunit" ,ghc-hunit) + ("ghc-interpolate" ,ghc-interpolate) + ("ghc-mockery" ,ghc-mockery) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-temporary" ,ghc-temporary) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/sol/hpack") + (synopsis "Tools for an alternative Haskell package format") + (description + "Hpack is a format for Haskell packages. It is an alternative to the +Cabal package format and follows different design principles. Hpack packages +are described in a file named @code{package.yaml}. Both @code{cabal2nix} and +@code{stack} support @code{package.yaml} natively. For other build tools the +@code{hpack} executable can be used to generate a @code{.cabal} file from +@code{package.yaml}.") + (license license:expat))) + +(define-public ghc-raw-strings-qq + (package + (name "ghc-raw-strings-qq") + (version "1.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "raw-strings-qq/raw-strings-qq-" + version ".tar.gz")) + (sha256 + (base32 + "1lxy1wy3awf52968iy5y9r5z4qgnn2sxkdrh7js3m9gadb11w09f")))) + (build-system haskell-build-system) + (native-inputs `(("ghc-hunit" ,ghc-hunit))) + (home-page "https://github.com/23Skidoo/raw-strings-qq") + (synopsis "Raw string literals for Haskell") + (description + "This package provides a quasiquoter for raw string literals, i.e. string +literals that don't recognise the standard escape sequences. Basically, they +make your code more readable by freeing you from the responsibility to escape +backslashes. They are useful when working with regular expressions, +DOS/Windows paths and markup languages (such as XML).") + (license license:bsd-3))) + +(define-public ghc-inline-c + (package + (name "ghc-inline-c") + (version "0.6.1.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/inline-c/" + "inline-c-" version ".tar.gz")) + (sha256 + (base32 + "0vbfrsqsi7mdziqsnj68bsqlwbqxxhvrmy9rv6w8z18d1m8w3n6h")))) + (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'create-Setup.hs + (lambda _ + (with-output-to-file "Setup.hs" + (lambda _ + (display "\ +import Distribution.Simple +main = defaultMain"))) + #t))))) + (inputs + `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) + ("ghc-cryptohash" ,ghc-cryptohash) + ("ghc-hashable" ,ghc-hashable) + ("ghc-parsec" ,ghc-parsec) + ("ghc-parsers" ,ghc-parsers) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector))) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hspec" ,ghc-hspec) + ("ghc-raw-strings-qq" ,ghc-raw-strings-qq) + ("ghc-regex-posix" ,ghc-regex-posix))) + (home-page "http://hackage.haskell.org/package/inline-c") + (synopsis "Write Haskell source files including C code inline") + (description + "inline-c lets you seamlessly call C libraries and embed high-performance +inline C code in Haskell modules. Haskell and C can be freely intermixed in +the same source file, and data passed to and from code in either language with +minimal overhead. No FFI required.") + (license license:expat))) + +(define-public ghc-weigh + (package + (name "ghc-weigh") + (version "0.0.12") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/weigh/" + "weigh-" version ".tar.gz")) + (sha256 + (base32 + "0zw2a997gxgdzqmd7j730kxgynzmjvvlkw84dajmfzf1v9pbij7x")))) + (build-system haskell-build-system) + (inputs + `(("ghc-split" ,ghc-split) + ("ghc-temporary" ,ghc-temporary))) + (home-page "https://github.com/fpco/weigh#readme") + (synopsis "Measure allocations of a Haskell functions/values") + (description "This package provides tools to measure the memory usage of a +Haskell value or function.") + (license license:bsd-3))) + +(define-public ghc-linear + (package + (name "ghc-linear") + (version "1.20.8") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/linear/" + "linear-" version ".tar.gz")) + (sha256 + (base32 + "046vkvxlb0s286qr55s0c6db0rlwbm1cmlmwhrrkqbkzhfcipgay")))) + (build-system haskell-build-system) + (inputs + `(("ghc-adjunctions" ,ghc-adjunctions) + ("ghc-base-orphans" ,ghc-base-orphans) + ("ghc-bytes" ,ghc-bytes) + ("ghc-cereal" ,ghc-cereal) + ("ghc-distributive" ,ghc-distributive) + ("ghc-hashable" ,ghc-hashable) + ("ghc-lens" ,ghc-lens) + ("ghc-reflection" ,ghc-reflection) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-tagged" ,ghc-tagged) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector) + ("ghc-void" ,ghc-void))) + (native-inputs + `(("cabal-doctest" ,cabal-doctest) + ("ghc-doctest" ,ghc-doctest) + ("ghc-simple-reflect" ,ghc-simple-reflect) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) + ("ghc-hunit" ,ghc-hunit))) + (home-page "http://github.com/ekmett/linear/") + (synopsis "Linear algebra library for Haskell") + (description + "This package provides types and combinators for linear algebra on free +vector spaces.") + (license license:bsd-3))) + +(define-public ghc-safe-exceptions + (package + (name "ghc-safe-exceptions") + (version "0.1.7.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "safe-exceptions/safe-exceptions-" + version ".tar.gz")) + (sha256 + (base32 + "0sd0zfsm9pcll5bzzj523rbn45adjrnavdkz52hgmdjjgdcdrk8q")))) + (build-system haskell-build-system) + (arguments + '(#:cabal-revision + ("4" "0fid41gishzsyb47wzxhd5falandfirqcp760hcja81qjpfmqd32"))) + (inputs `(("ghc-exceptions" ,ghc-exceptions))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-void" ,ghc-void) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/fpco/safe-exceptions") + (synopsis "Safe, consistent, and easy exception handling") + (description "Runtime exceptions - as exposed in @code{base} by the +@code{Control.Exception} module - have long been an intimidating part of the +Haskell ecosystem. This package is intended to overcome this. It provides a +safe and simple API on top of the existing exception handling machinery. The +API is equivalent to the underlying implementation in terms of power but +encourages best practices to minimize the chances of getting the exception +handling wrong.") + (license license:expat))) + +(define-public ghc-inline-c-cpp + (package + (name "ghc-inline-c-cpp") + (version "0.2.2.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/inline-c-cpp/" + "inline-c-cpp-" version ".tar.gz")) + (sha256 + (base32 + "1rk7fmpkmxw9hhwr8df29kadnf0ybnwj64ggdbnsdrpfyhnkisci")))) + (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'create-Setup.hs + (lambda _ + (with-output-to-file "Setup.hs" + (lambda _ + (display "\ +import Distribution.Simple +main = defaultMain"))) + #t))))) + (inputs + `(("ghc-inline-c" ,ghc-inline-c) + ("ghc-safe-exceptions" ,ghc-safe-exceptions))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec))) + (home-page "https://hackage.haskell.org/package/inline-c-cpp") + (synopsis "Lets you embed C++ code into Haskell") + (description + "This package provides utilities to inline C++ code into Haskell using +@code{inline-c}.") + (license license:expat))) + +(define-public ghc-bytestring-lexing + (package + (name "ghc-bytestring-lexing") + (version "0.5.0.2") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "bytestring-lexing/bytestring-lexing-" + version ".tar.gz")) + (sha256 + (base32 + "0wrzniawhgpphc6yx1v972gyqxdbv0pizaz9bafahrshyb9svy81")))) + (build-system haskell-build-system) + (home-page "http://code.haskell.org/~wren/") + (synopsis "Parse and produce literals from strict or lazy bytestrings") + (description + "This package provides tools to parse and produce literals efficiently +from strict or lazy bytestrings.") + (license license:bsd-2))) + +(define-public ghc-configurator + (package + (name "ghc-configurator") + (version "0.3.0.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "configurator/configurator-" + version ".tar.gz")) + (sha256 + (base32 + "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf")))) + (build-system haskell-build-system) + (inputs + `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-hashable" ,ghc-hashable) + ("ghc-text" ,ghc-text) + ("ghc-unix-compat" ,ghc-unix-compat) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) + (home-page "http://github.com/bos/configurator") + (synopsis "Configuration management") + (description + "This package provides a configuration management library for programs +and daemons. The features include: + +@enumerate +@item Automatic, dynamic reloading in response to modifications to + configuration files. +@item A simple, but flexible, configuration language, supporting several of + the most commonly needed types of data, along with interpolation of strings + from the configuration or the system environment (e.g. @code{$(HOME)}). +@item Subscription-based notification of changes to configuration properties. +@item An @code{import} directive allows the configuration of a complex + application to be split across several smaller files, or common configuration + data to be shared across several applications. +@end enumerate\n") + (license license:bsd-3))) + +(define-public ghc-file-embed + (package + (name "ghc-file-embed") + (version "0.0.10.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/file-embed/" + "file-embed-" version ".tar.gz")) + (sha256 + (base32 + "0lj164cnzqyd487mli91nnr7137a4h4qsasfwsnsh77sx12fpk9k")))) + (build-system haskell-build-system) + (home-page "https://github.com/snoyberg/file-embed") + (synopsis "Use Template Haskell to embed file contents directly") + (description + "This package allows you to use Template Haskell to read a file or all +the files in a directory, and turn them into @code{(path, bytestring)} pairs +embedded in your Haskell code.") + (license license:bsd-3))) + +(define-public ghc-safeio + (package + (name "ghc-safeio") + (version "0.0.5.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/safeio/" + "safeio-" version ".tar.gz")) + (sha256 + (base32 + "04g3070cbjdqj0h9l9ii6470xcbn40xfv4fr89a8yvnkdim9nyfm")))) + (build-system haskell-build-system) + (inputs + `(("ghc-conduit" ,ghc-conduit) + ("ghc-conduit-combinators" ,ghc-conduit-combinators) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-resourcet" ,ghc-resourcet))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) + ("ghc-test-framework-th" ,ghc-test-framework-th))) + (home-page "https://github.com/luispedro/safeio") + (synopsis "Write output to disk atomically") + (description + "This package implements utilities to perform atomic output so as to +avoid the problem of partial intermediate files.") + (license license:expat))) + ;;; haskell.scm ends here |