X-Git-Url: https://git.hcoop.net/jackhill/guix/guix.git/blobdiff_plain/f8d1790291895a07c5013060427e93d2723ae1c4..29e1553344864db55de6af225b16ac74d84a078a:/gnu/packages/haskell-xyz.scm diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm index 2e5f668a31..29d3077755 100644 --- a/gnu/packages/haskell-xyz.scm +++ b/gnu/packages/haskell-xyz.scm @@ -4,7 +4,7 @@ ;;; Copyright © 2015 Paul van der Walt ;;; Copyright © 2015, 2019 Eric Bavier ;;; Copyright © 2016, 2018, 2019 Ludovic Courtès -;;; Copyright © 2016, 2017 ng0 +;;; Copyright © 2016, 2017 Nikita ;;; Copyright © 2016, 2019 Efraim Flashner ;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus ;;; Copyright © 2016, 2017 David Craven @@ -22,6 +22,10 @@ ;;; Copyright © 2019 John Soo ;;; Copyright © 2019 Kyle Meyer ;;; Copyright © 2019 Alex Griffin +;;; Copyright © 2020 Brett Gilio +;;; Copyright © 2020 JoJo +;;; Copyright © 2020 Nicolas Goaziou +;;; Copyright © 2020 Alexandru-Sergiu Marton ;;; ;;; This file is part of GNU Guix. ;;; @@ -53,6 +57,7 @@ #:use-module (gnu packages haskell-web) #:use-module (gnu packages libffi) #:use-module (gnu packages linux) + #:use-module (gnu packages llvm) #:use-module (gnu packages lua) #:use-module (gnu packages maths) #:use-module (gnu packages ncurses) @@ -129,6 +134,36 @@ of @code{Par} functionality. See the @code{Control.Monad.Par.Class} module for more details.") (license license:bsd-3))) +(define-public ghc-active + (package + (name "ghc-active") + (version "0.2.0.14") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "active/active-" version ".tar.gz")) + (sha256 + (base32 + "0x3b4ln6csa554qls28wbxvclkbdz3yi60i1m0q5ing0cs16fifz")))) + (build-system haskell-build-system) + (inputs + `(("ghc-vector" ,ghc-vector) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-lens" ,ghc-lens) + ("ghc-linear" ,ghc-linear))) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://hackage.haskell.org/package/active") + (synopsis "Abstractions for animation") + (description "This package defines an @code{Active} abstraction for +time-varying values with finite start and end times. It is used for +describing animations within the +@url{https://archives.haskell.org/projects.haskell.org/diagrams/, +diagrams framework}.") + (license license:bsd-3))) + (define-public ghc-adjunctions (package (name "ghc-adjunctions") @@ -421,6 +456,34 @@ colored output using the ansi-terminal package.") style.") (license license:bsd-3))) +(define-public ghc-assoc + (package + (name "ghc-assoc") + (version "1.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/assoc/assoc-" + version + ".tar.gz")) + (sha256 + (base32 + "1m9n4vp190bvn2wcrd4ggfwa9pi93jp0zgx02mdgywn2zfidw020")))) + (build-system haskell-build-system) + (inputs + `(("ghc-bifunctors" ,ghc-bifunctors) + ("ghc-tagged" ,ghc-tagged))) + (home-page + "http://hackage.haskell.org/package/assoc") + (synopsis + "Swap and assoc: Symmetric and Semigroupy Bifunctors") + (description + "Provides generalisations of @code{swap :: (a,b) -> (b,a)} and +@code{assoc :: ((a,b),c) -> (a,(b,c))} to @code{Bifunctor}s supporting +similar operations (e.g. @code{Either}, @code{These}).") + (license license:bsd-3))) + (define-public ghc-async (package (name "ghc-async") @@ -756,7 +819,7 @@ pragmas in your code.") (arguments `(#:cabal-revision ("1" "15sn2qc8k0hxbb2nai341kkrci98hlhzcj2ci087m0zxcg5jcdbp"))) - (home-page "http://hackage.haskell.org/package/base-compat-batteries") + (home-page "https://hackage.haskell.org/package/base-compat-batteries") (synopsis "base-compat with extra batteries") (description "This library provides functions available in later versions of @code{base} to a wider range of compilers, without requiring @@ -872,6 +935,45 @@ stand for certain ASCII character sequences, i.e. → instead of @code{->}, ∀ instead of @code{forall} and many others.") (license license:bsd-3))) +(define-public ghc-basic-prelude + (package + (name "ghc-basic-prelude") + (version "0.7.0") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/basic-prelude/" + "basic-prelude-" version ".tar.gz")) + (sha256 + (base32 + "0yckmnvm6i4vw0mykj4fzl4ldsf67v8d2h0vp1bakyj84n4myx8h")))) + (build-system haskell-build-system) + (inputs + `(("ghc-hashable" ,ghc-hashable) + ("ghc-unordered-containers" + ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector))) + (home-page "https://github.com/snoyberg/basic-prelude#readme") + (synopsis "Enhanced core prelude; a common foundation for alternate preludes") + (description + "The premise of basic-prelude is that there are a lot of very commonly +desired features missing from the standard Prelude, such as commonly used +operators (<$> and >=>, for instance) and imports for common datatypes +(e.g., ByteString and Vector). At the same time, there are lots of other +components which are more debatable, such as providing polymorphic versions +of common functions. + +So basic-prelude is intended to give a common foundation for a number of +alternate preludes. The package provides two modules: CorePrelude provides +the common ground for other preludes to build on top of, while BasicPrelude +exports CorePrelude together with commonly used list functions to provide a +drop-in replacement for the standard Prelude. + +Users wishing to have an improved Prelude can use BasicPrelude. Developers +wishing to create a new prelude should use CorePrelude.") + (license license:expat))) + (define-public ghc-bifunctors (package (name "ghc-bifunctors") @@ -2766,7 +2868,7 @@ providing an @code{rnf} implementation.") (native-inputs `(("ghc-hspec" ,ghc-hspec) ("ghc-quickcheck" ,ghc-quickcheck))) - (home-page "http://hackage.haskell.org/package/dense-linear-algebra") + (home-page "https://hackage.haskell.org/package/dense-linear-algebra") (synopsis "Simple and incomplete implementation of linear algebra") (description "This library is simply a collection of linear-algebra related modules split from the statistics library.") @@ -2804,6 +2906,180 @@ related modules split from the statistics library.") and parsers with useful semantics.") (license license:bsd-3))) +(define-public ghc-diagrams-core + (package + (name "ghc-diagrams-core") + (version "1.4.2") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "diagrams-core/diagrams-core-" version ".tar.gz")) + (sha256 + (base32 + "0qgb43vy23g4fxh3nmxfq6jyp34imqvkhgflaa6rz0iq6d60gl43")))) + (build-system haskell-build-system) + (inputs + `(("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-monoid-extras" ,ghc-monoid-extras) + ("ghc-dual-tree" ,ghc-dual-tree) + ("ghc-lens" ,ghc-lens) + ("ghc-linear" ,ghc-linear) + ("ghc-adjunctions" ,ghc-adjunctions) + ("ghc-distributive" ,ghc-distributive) + ("ghc-profunctors" ,ghc-profunctors))) + (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + (synopsis "Core libraries for diagrams embedded domain-specific language") + (description "This package provides the core modules underlying +diagrams, an embedded domain-specific language for compositional, +declarative drawing.") + (license license:bsd-3))) + +(define-public ghc-diagrams-lib + (package + (name "ghc-diagrams-lib") + (version "1.4.2.3") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "diagrams-lib/diagrams-lib-" version ".tar.gz")) + (sha256 + (base32 + "175yzi5kw4yd8ykdkpf64q85c7j3p89l90m3h6qcsx9ipv6av9r5")))) + (build-system haskell-build-system) + (inputs + `(("ghc-semigroups" ,ghc-semigroups) + ("ghc-monoid-extras" ,ghc-monoid-extras) + ("ghc-dual-tree" ,ghc-dual-tree) + ("ghc-diagrams-core" ,ghc-diagrams-core) + ("ghc-diagrams-solve" ,ghc-diagrams-solve) + ("ghc-active" ,ghc-active) + ("ghc-colour" ,ghc-colour) + ("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-fingertree" ,ghc-fingertree) + ("ghc-intervals" ,ghc-intervals) + ("ghc-lens" ,ghc-lens) + ("ghc-tagged" ,ghc-tagged) + ("ghc-optparse-applicative" ,ghc-optparse-applicative) + ("ghc-juicypixels" ,ghc-juicypixels) + ("ghc-hashable" ,ghc-hashable) + ("ghc-linear" ,ghc-linear) + ("ghc-adjunctions" ,ghc-adjunctions) + ("ghc-distributive" ,ghc-distributive) + ("ghc-fsnotify" ,ghc-fsnotify) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-profunctors" ,ghc-profunctors) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-cereal" ,ghc-cereal))) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-numeric-extras" ,ghc-numeric-extras))) + (arguments + `(#:cabal-revision + ("3" "157y2qdsh0aczs81vzlm377mks976mpv6y3aqnchwsnr7apzp8ai"))) + (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + (synopsis "Embedded domain-specific language for declarative graphics") + (description "Diagrams is a flexible, extensible embedded +domain-specific language (EDSL) for creating graphics of many types. +Graphics can be created in arbitrary vector spaces and rendered with +multiple backends. This package provides a standard library of +primitives and operations for creating diagrams.") + (license license:bsd-3))) + +(define-public ghc-diagrams-solve + (package + (name "ghc-diagrams-solve") + (version "0.1.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "diagrams-solve/diagrams-solve-" + version ".tar.gz")) + (sha256 + (base32 + "17agchqkmj14b17sw50kzxq4hm056g5d8yy0wnqn5w8h1d0my7x4")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + (arguments + `(#:cabal-revision + ("5" "1yl8cs05fzqcz49p601am1ij66m9pa70yamhfxgcvya2pf8nimlf"))) + (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + (synopsis "Pure Haskell solver routines used by diagrams") + (description "This library provides Pure Haskell solver routines for +use by the +@url{https://archives.haskell.org/projects.haskell.org/diagrams/, +diagrams framework}. It currently includes routines for finding real +roots of low-degree (@math{n < 5}) polynomials, and solving tridiagonal +and cyclic tridiagonal linear systems.") + (license license:bsd-3))) + +(define-public ghc-diagrams-svg + (package + (name "ghc-diagrams-svg") + (version "1.4.2") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "diagrams-svg/diagrams-svg-" version ".tar.gz")) + (sha256 + (base32 + "1lnyxx45yawqas7hmvvannwaa3ycf1l9g40lsl2m8sl2ja6vcmal")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-colour" ,ghc-colour) + ("ghc-diagrams-core" ,ghc-diagrams-core) + ("ghc-diagrams-lib" ,ghc-diagrams-lib) + ("ghc-monoid-extras" ,ghc-monoid-extras) + ("ghc-svg-builder" ,ghc-svg-builder) + ("ghc-juicypixels" ,ghc-juicypixels) + ("ghc-split" ,ghc-split) + ("ghc-lens" ,ghc-lens) + ("ghc-hashable" ,ghc-hashable) + ("ghc-optparse-applicative" ,ghc-optparse-applicative) + ("ghc-semigroups" ,ghc-semigroups))) + (arguments + `(#:cabal-revision + ("2" "15sn85xaachw4cj56w61bjcwrbf4qmnkfl8mbgdapxi5k0y4f2qv"))) + (home-page "https://archives.haskell.org/projects.haskell.org/diagrams/") + (synopsis "Scalable Vector Grpahics backend for the diagrams framework") + (description "This package provides a modular backend for rendering +diagrams created with the diagrams embedded domain-specific +language (EDSL) to Scalable Vector Graphics (SVG) files.") + (license license:bsd-3))) + +(define-public ghc-dictionary-sharing + (package + (name "ghc-dictionary-sharing") + (version "0.1.0.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "dictionary-sharing/dictionary-sharing-" + version ".tar.gz")) + (sha256 + (base32 + "00aspv943qdqhlk39mbk00kb1dsa5r0caj8sslrn81fnsn252fwc")))) + (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("3" "1mn7jcc7h3b8f1pn9zigqp6mc2n0qb66lms5qnrx4zswdv5w9439"))) + (home-page "https://hackage.haskell.org/package/dictionary-sharing") + (synopsis "Sharing/memoization of class members") + (description "This library provides tools for ensuring that class +members are shared.") + (license license:bsd-3))) + (define-public ghc-diff (package (name "ghc-diff") @@ -2994,6 +3270,35 @@ It is modeled after doctest for Python, see between double precision floating point and text.") (license license:bsd-3))) +(define-public ghc-dual-tree + (package + (name "ghc-dual-tree") + (version "0.2.2.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "dual-tree/dual-tree-" version ".tar.gz")) + (sha256 + (base32 + "17kdfnf0df0z5pkiifxrlmyd1xd7hjjaazd2kzyajl0gd00vbszx")))) + (build-system haskell-build-system) + (inputs + `(("ghc-semigroups" ,ghc-semigroups) + ("ghc-newtype-generics" ,ghc-newtype-generics) + ("ghc-monoid-extras" ,ghc-monoid-extras))) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-testing-feat" ,ghc-testing-feat))) + (home-page "https://hackage.haskell.org/package/dual-tree") + (synopsis "Rose trees with cached and accumulating monoidal annotations") + (description "Rose (@math{n}-ary) trees with both upwards- (i.e. +cached) and downwards-traveling (i.e. accumulating) monoidal +annotations. This is used as the core data structure underlying the +@url{https://archives.haskell.org/projects.haskell.org/diagrams/, +diagrams framework}, but potentially has other applications as well.") + (license license:bsd-3))) + (define-public ghc-easy-file (package (name "ghc-easy-file") @@ -3340,7 +3645,7 @@ Double.") `(("ghc-quickcheck" ,ghc-quickcheck) ("ghc-hspec" ,ghc-hspec) ("hspec-discover" ,hspec-discover))) - (home-page "http://hackage.haskell.org/package/errorcall-eq-instance") + (home-page "https://hackage.haskell.org/package/errorcall-eq-instance") (synopsis "Orphan Eq instance for ErrorCall") (description "Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}. @@ -3375,7 +3680,7 @@ directly uses the type system, rather than out-of-band exceptions.") (define-public ghc-esqueleto (package (name "ghc-esqueleto") - (version "3.0.0") + (version "3.3.1.1") (source (origin (method url-fetch) @@ -3383,7 +3688,7 @@ directly uses the type system, rather than out-of-band exceptions.") "esqueleto/esqueleto-" version ".tar.gz")) (sha256 (base32 - "187c098h2xyf2nhifkdy2bqfl6iap7a93mzwd2kirl5yyicpc9zy")))) + "1qi28ma8j5kfygjxnixlazxsyrkdqv8ljz3icwqi5dlscsnj6v3v")))) (build-system haskell-build-system) (arguments `(#:haddock? #f ; Haddock reports an internal error. @@ -3456,7 +3761,7 @@ generated SQL and optimize it for your backend.") ("ghc-silently" ,ghc-silently) ("ghc-filemanip" ,ghc-filemanip))) (home-page - "http://hackage.haskell.org/package/ghc-exactprint") + "https://hackage.haskell.org/package/ghc-exactprint") (synopsis "ExactPrint for GHC") (description "Using the API Annotations available from GHC 7.10.2, this library @@ -3537,7 +3842,7 @@ versions of GHC (i.e., < 6.10).") (define-public ghc-extra (package (name "ghc-extra") - (version "1.6.18") + (version "1.6.21") (source (origin (method url-fetch) @@ -3547,12 +3852,13 @@ versions of GHC (i.e., < 6.10).") ".tar.gz")) (sha256 (base32 - "0jvd4l0hi8pf5899pxc32yc638y0mrc357w0rph99k3hm277i0cy")))) + "1gjx98w4w61g043k6rzc8i34cbxpcigi8lb6i7pp1vwp8w8jm5vl")))) (build-system haskell-build-system) (inputs `(("ghc-clock" ,ghc-clock) ("ghc-semigroups" ,ghc-semigroups) - ("ghc-quickcheck" ,ghc-quickcheck))) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances))) (home-page "https://github.com/ndmitchell/extra") (synopsis "Extra Haskell functions") (description "This library provides extra functions for the standard @@ -3765,6 +4071,29 @@ directories. It includes code for pattern matching, finding files, modifying file contents, and more.") (license license:bsd-3))) +(define-public ghc-filepath-bytestring + (package + (name "ghc-filepath-bytestring") + (version "1.4.2.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/filepath-bytestring/" + "filepath-bytestring-" version ".tar.gz")) + (sha256 + (base32 + "06shdskjj391hb9295slm9gg2rbn5fdq5v6fg0mgn3yl5dv8q5dx")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://hackage.haskell.org/package/filepath-bytestring") + (synopsis "Library for manipulating RawFilePaths in a cross-platform way") + (description "This package provides a drop-in replacement for the standard +@code{filepath} library, operating on @code{RawFilePath} values rather than +@code{FilePath} values to get the speed benefits of using @code{ByteStrings}.") + (license license:bsd-3))) + (define-public ghc-findbin (package (name "ghc-findbin") @@ -3907,6 +4236,16 @@ and are often as efficient as hand-written folds.") (base32 "0q6kx57ygmznlpf8n499hid4x6mj3180paijx0a8dgi9hh7man61")))) (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + ;; This test is broken. For details, see + ;; https://github.com/haskell-foundation/foundation/issues/530 + (add-after 'unpack 'patch-tests + (lambda _ + (substitute* "tests/Test/Foundation/Number.hs" + ((", testDividible proxy") "")) + #t))))) (inputs `(("ghc-basement" ,ghc-basement))) (home-page "https://github.com/haskell-foundation/foundation") (synopsis "Alternative prelude with batteries and no dependencies") @@ -4356,6 +4695,25 @@ and edge labels with positional information, etc. @end enumerate\n") (license license:bsd-3))) +(define-public ghc-groups + (package + (name "ghc-groups") + (version "0.4.1.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "groups/groups-" version ".tar.gz")) + (sha256 + (base32 + "0ggkygkyxw5ga4cza82bjvdraavl294k0h6b62d2px7z3nvqhifx")))) + (build-system haskell-build-system) + (home-page "https://hackage.haskell.org/package/groups") + (synopsis "Haskell 98 groups") + (description "This package provides Haskell 98 groups. A group is a +monoid with invertibility.") + (license license:bsd-3))) + (define-public ghc-gtk2hs-buildtools (package (name "ghc-gtk2hs-buildtools") @@ -4437,7 +4795,7 @@ Tor project}.") (define-public ghc-haddock (package (name "ghc-haddock") - (version "2.19.0.1") + (version "2.22.0") (source (origin (method url-fetch) @@ -4447,16 +4805,15 @@ Tor project}.") ".tar.gz")) (sha256 (base32 - "1g1j9j0hf2yhyyh0gwz6bzbvfvliqz9x8a8hnkmwghm7w3xa6sb7")))) + "1k42z2zh550rl93c8pa9cg2xsanp6wvb031xvan6cmngnplmdib6")))) (build-system haskell-build-system) (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 + ;; The release tarball for 2.22.0 is missing the test data for + ;; the Hoogle test, causing it to fail. This is fixed in the + ;; next release, but for now we disable it. + (add-before 'configure 'remove-hoogle-test (lambda _ (use-modules (ice-9 rdelim)) (with-atomic-file-replacement "haddock.cabal" @@ -4467,17 +4824,20 @@ Tor project}.") ((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")) + ((string=? line "test-suite hoogle-test\n") (loop (read-line in 'concat) #t)) (else (unless deleting? (display line out)) - (loop (read-line in 'concat) deleting?))))))))))) + (loop (read-line in 'concat) deleting?)))))))) + (add-before 'check 'add-haddock-to-path + (lambda _ + (setenv "PATH" (string-append (getcwd) "/dist/build/haddock" + ":" (getenv "PATH"))) + #t))))) (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") @@ -4488,7 +4848,7 @@ Tor project}.") (define-public ghc-haddock-api (package (name "ghc-haddock-api") - (version "2.19.0.1") + (version "2.22.0") (source (origin (method url-fetch) @@ -4496,9 +4856,10 @@ Tor project}.") "https://hackage.haskell.org/package/haddock-api/haddock-api-" version ".tar.gz")) + (patches (search-patches "ghc-haddock-api-fix-haddock.patch")) (sha256 (base32 - "0c6i7sljp7myz25d90gyw68a90i5jcrkajkxcciikp2hjirfaas3")))) + "149q4zlf4m7wcrr4af2n2flh0jxjsypshbc229vsj1m0kmz4z014")))) (build-system haskell-build-system) (arguments `(#:phases @@ -4506,10 +4867,10 @@ Tor project}.") (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"))))))) + (("QuickCheck \\^>= 2\\.11") + "QuickCheck ^>= 2.13") + (("hspec >= 2\\.4\\.4 && < 2\\.6") + "hspec >= 2.4.4 && < 2.8"))))))) (inputs `(("ghc-paths" ,ghc-paths) ("ghc-haddock-library" ,ghc-haddock-library))) @@ -4566,6 +4927,39 @@ project if you can't release often. For interacting with Haddock itself, see the ‘haddock’ package.") (license license:bsd-3))) +;; This package is needed for testing 'ghc-haddock'. It is no longer +;; published to Hackage, but it is maintained in the Haddock Git +;; repository. +(define ghc-haddock-test + (package + (name "ghc-haddock-test") + (version "2.22.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/haskell/haddock.git") + (commit (string-append "haddock-" version "-release")))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1ywxmqqan10gs0ppybdmdgsmvkzkpw7yirj2rw4qylg3x49a9zca")))) + (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'change-directory + (lambda _ + (chdir "haddock-test")))))) + (inputs + `(("ghc-syb" ,ghc-syb) + ("ghc-xml" ,ghc-xml))) + (home-page "http://www.haskell.org/haddock/") + (synopsis "Test utilities for Haddock") + (description "This package provides test utilities for Haddock.") + (license license:bsd-3) + (properties '((hidden? #t))))) + (define-public ghc-half (package (name "ghc-half") @@ -4686,7 +5080,7 @@ combine hash values.") `(#:cabal-revision ("2" "006phc5y9rrvsshdcmjmhxzxh8dpgs685mpqbkjm9c40xb1ydjbz"))) (inputs `(("ghc-hashable" ,ghc-hashable))) - (home-page "http://hackage.haskell.org/package/hashable-time") + (home-page "https://hackage.haskell.org/package/hashable-time") (synopsis "Hashable instances for Data.Time") (description "This package provides @code{Hashable} instances for types in @@ -4731,7 +5125,7 @@ a set of wrappers to use the hash tables in the IO monad.") (sha256 (base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq")))) (build-system haskell-build-system) - (home-page "http://hackage.haskell.org/package/haskell-lexer") + (home-page "https://hackage.haskell.org/package/haskell-lexer") (synopsis "Fully compliant Haskell 98 lexer") (description "This package provides a fully compliant Haskell 98 lexer.") @@ -4960,8 +5354,7 @@ descriptions.") (lambda* (#:key inputs outputs #:allow-other-keys) (let* ((out (assoc-ref outputs "out")) (elisp-file "elisp/hindent.el") - (dest (string-append out "/share/emacs/site-lisp" - "/guix.d/hindent-" ,version)) + (dest (string-append out "/share/emacs/site-lisp")) (emacs (string-append (assoc-ref inputs "emacs") "/bin/emacs"))) (make-file-writable elisp-file) @@ -5467,7 +5860,7 @@ for general types.") (base32 "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa")))) (build-system haskell-build-system) - (home-page "http://hackage.haskell.org/package/IfElse") + (home-page "https://hackage.haskell.org/package/IfElse") (synopsis "Monadic control flow with anaphoric variants") (description "This library provides functions for control flow inside of monads with anaphoric variants on @code{if} and @code{when} and a C-like @@ -5520,7 +5913,7 @@ lines continued at an indented level below.") (native-inputs `(("ghc-hspec" ,ghc-hspec) ("hspec-discover" ,hspec-discover))) - (home-page "http://hackage.haskell.org/package/infer-license") + (home-page "https://hackage.haskell.org/package/infer-license") (synopsis "Infer software license from a given license file") (description "This library provides tools to infer a software license from a given license file.") @@ -5551,7 +5944,7 @@ license from a given license file.") ("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") + (home-page "https://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 @@ -5683,6 +6076,35 @@ search for all keys containing a point or overlapping an interval. See the example code on the home page for a quick introduction.") (license license:bsd-3))) +(define-public ghc-intervals + (package + (name "ghc-intervals") + (version "0.8.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "intervals/intervals-" version ".tar.gz")) + (sha256 + (base32 + "00vyxf3ba9d7aas3npfapr53w71fslgh69fczjb25axr66fvzqww")))) + (build-system haskell-build-system) + (inputs + `(("ghc-distributive" ,ghc-distributive))) + (native-inputs + `(("cabal-doctest" ,cabal-doctest) + ("ghc-doctest" ,ghc-doctest) + ("ghc-quickcheck" ,ghc-quickcheck))) + (arguments + `(#:cabal-revision + ("4" "1qx3q0v13l1zaln9zdk8chxpxhshbz5x0vqm0qda7d1kpv7h6a7r"))) + (home-page "https://github.com/ekmett/intervals") + (synopsis "Interval arithmetic") + (description "This library provides +@code{Numeric.Interval.Interval}, which represets a closed, convex set +of floating point values.") + (license license:bsd-3))) + (define-public ghc-invariant (package (name "ghc-invariant") @@ -5746,7 +6168,7 @@ functors). For more information, see Edward Kmett's article ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2) ("ghc-zlib" ,ghc-zlib))) - (home-page "http://hackage.haskell.org/package/io-streams") + (home-page "https://hackage.haskell.org/package/io-streams") (synopsis "Simple and composable stream I/O") (description "This library contains simple and easy-to-use primitives for I/O using streams.") @@ -5987,7 +6409,7 @@ and a large set of GNU extensions.") `(#:tests? #f #:cabal-revision ("1" "10ac9pk4jy75k03j1ns4b5136l4kw8krr2d2nw2fdmpm5jzyghc5"))) - (home-page "http://hackage.haskell.org/package/language-glsl") + (home-page "https://hackage.haskell.org/package/language-glsl") (synopsis "GLSL abstract syntax tree, parser, and pretty-printer") (description "This package is a Haskell library for the representation, parsing, and pretty-printing of GLSL 1.50 code.") @@ -6091,7 +6513,7 @@ indexed variants.") (build-system haskell-build-system) (native-inputs `(("pkg-config" ,pkg-config))) (inputs `(("libffi" ,libffi))) - (home-page "http://hackage.haskell.org/package/libffi") + (home-page "https://hackage.haskell.org/package/libffi") (synopsis "Haskell binding to libffi") (description "A binding to libffi, allowing C functions of types only known at runtime @@ -6206,7 +6628,7 @@ compiler versions.") (inputs `(("ghc-conduit" ,ghc-conduit) ("ghc-resourcet" ,ghc-resourcet) - ("libyaml" ,libyaml-2.1))) + ("libyaml" ,libyaml))) (home-page "https://github.com/snoyberg/yaml#readme") (synopsis "Low-level, streaming YAML interface.") (description "This package provides a Haskell wrapper over the @@ -6353,24 +6775,90 @@ ByteString, for types that support input and output, and for types that can handle infinite lists.") (license license:bsd-3))) -(define-public ghc-logging-facade +(define-public ghc-llvm-hs-pure (package - (name "ghc-logging-facade") - (version "0.3.0") - (source (origin - (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "logging-facade/logging-facade-" - version ".tar.gz")) - (sha256 - (base32 - "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf")))) + (name "ghc-llvm-hs-pure") + (version "9.0.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/llvm-hs-pure/" + "llvm-hs-pure-" version ".tar.gz")) + (sha256 + (base32 + "0pxb5ah8r5pzpz2ibqw3g9g1isigb4z7pbzfrwr8kmcjn74ab3kf")))) (build-system haskell-build-system) + (inputs + `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-fail" ,ghc-fail) + ("ghc-unordered-containers" ,ghc-unordered-containers))) (native-inputs - `(("ghc-hspec" ,ghc-hspec) - ("hspec-discover" ,hspec-discover))) - (home-page "https://hackage.haskell.org/package/logging-facade") - (synopsis "Simple logging abstraction that allows multiple back-ends") + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + (home-page "https://github.com/llvm-hs/llvm-hs/") + (synopsis "Pure Haskell LLVM functionality (no FFI)") + (description "llvm-hs-pure is a set of pure Haskell types and functions +for interacting with LLVM. It includes an algebraic datatype (ADT) to represent +LLVM IR. The llvm-hs package builds on this one with FFI bindings to LLVM, but +llvm-hs-pure does not require LLVM to be available.") + (license license:bsd-3))) + +(define-public ghc-llvm-hs + (package + (name "ghc-llvm-hs") + (version "9.0.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/llvm-hs/llvm-hs-" + version ".tar.gz")) + (sha256 + (base32 + "0723xgh45h9cyxmmjsvxnsp8bpn1ljy4qgh7a7vqq3sj9d6wzq00")))) + (build-system haskell-build-system) + (inputs + `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-utf8-string" ,ghc-utf8-string) + ("ghc-llvm-hs-pure" ,ghc-llvm-hs-pure) + ("llvm" ,llvm-9))) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-temporary" ,ghc-temporary) + ("ghc-pretty-show" ,ghc-pretty-show) + ("ghc-temporary" ,ghc-temporary))) + (home-page "https://github.com/llvm-hs/llvm-hs/") + (synopsis "General purpose LLVM bindings for Haskell") + (description "llvm-hs is a set of Haskell bindings for LLVM. Unlike other +current Haskell bindings, it uses an algebraic datatype (ADT) to represent LLVM +IR, and so offers two advantages: it handles almost all of the stateful +complexities of using the LLVM API to build IR; and it supports moving IR not +only from Haskell into LLVM C++ objects, but the other direction - from LLVM C++ +into Haskell.") + (license license:bsd-3))) + +(define-public ghc-logging-facade + (package + (name "ghc-logging-facade") + (version "0.3.0") + (source (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "logging-facade/logging-facade-" + version ".tar.gz")) + (sha256 + (base32 + "0d0lwxxgd16is9aw6v3ps4r9prv3dj8xscmm45fvzq3nicjiawcf")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) + (home-page "https://hackage.haskell.org/package/logging-facade") + (synopsis "Simple logging abstraction that allows multiple back-ends") (description "This package provides a simple logging abstraction that allows multiple back-ends.") @@ -6479,7 +6967,7 @@ compression algorithm used in the @code{.xz} file format.") (base32 "10p0gjjjwr1dda7hahwrwn5njbfhl67arq3v3nf1jr3vymlkn75j")))) (build-system haskell-build-system) - (home-page "http://hackage.haskell.org/package/magic") + (home-page "https://hackage.haskell.org/package/magic") (synopsis "Interface to C file/magic library") (description "This package provides a full-featured binding to the C libmagic library. @@ -6843,7 +7331,7 @@ used both from lens and microlens).") `(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance) ("ghc-quickcheck" ,ghc-quickcheck) ("ghc-hunit" ,ghc-hunit))) - (home-page "http://software.complete.org/missingh") + (home-page "https://software.complete.org/missingh") (synopsis "Large utility library") (description "MissingH is a library of all sorts of utility functions for Haskell @@ -7143,6 +7631,69 @@ you are used to, it adds on an IsSequence typeclass and has code for marking data structures as non-empty.") (license license:expat))) +(define-public ghc-monoid-extras + (package + (name "ghc-monoid-extras") + (version "0.5.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "monoid-extras/monoid-extras-" version ".tar.gz")) + (sha256 + (base32 + "0xfrkgqn9d31z54l617m3w3kkd5m9vjb4yl247r3zzql3mpb1f37")))) + (build-system haskell-build-system) + (inputs + `(("ghc-groups" ,ghc-groups) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-semigroupoids" ,ghc-semigroupoids))) + (arguments + `(#:cabal-revision + ("1" "0b8x5d6vh7mpigvjvcd8f38a1nyzn1vfdqypslw7z9fgsr742913"))) + (home-page "https://hackage.haskell.org/package/monoid-extras") + (synopsis "Various extra monoid-related definitions and utilities") + (description "This package provides various extra monoid-related +definitions and utilities, such as monoid actions, monoid coproducts, +semi-direct products, \"deletable\" monoids, \"split\" monoids, and +\"cut\" monoids.") + (license license:bsd-3))) + +(define-public ghc-mtl-compat + (package + (name "ghc-mtl-compat") + (version "0.2.2") + (source + (origin + (method url-fetch) + (uri (string-append + "mirror://hackage/package/mtl-compat/mtl-compat-" + version + ".tar.gz")) + (sha256 + (base32 + "17iszr5yb4f17g8mq6i74hsamii8z6m2qfsmgzs78mhiwa7kjm8r")))) + (build-system haskell-build-system) + (home-page + "https://github.com/haskell-compat/mtl-compat") + (synopsis + "Backported Control.Monad.Except module from mtl") + (description + "This package backports the Control.Monad.Except module from mtl (if +using mtl-2.2.0.1 or earlier), which reexports the ExceptT monad transformer +and the MonadError class. + +This package should only be used if there is a need to use the +Control.Monad.Except module specifically. If you just want the mtl class +instances for ExceptT, use transformers-compat instead, since mtl-compat does +nothing but reexport the instances from that package. + +Note that unlike how mtl-2.2 or later works, the Control.Monad.Except +module defined in this package exports all of ExceptT's monad class instances. +Therefore, you may have to declare @code{import Control.Monad.Except ()} at +the top of your file to get all of the ExceptT instances in scope.") + (license license:bsd-3))) + (define-public ghc-murmur-hash (package (name "ghc-murmur-hash") @@ -7338,7 +7889,7 @@ network database () API.") (build-system haskell-build-system) (native-inputs `(("ghc-doctest" ,ghc-doctest))) - (home-page "http://hackage.haskell.org/package/network-byte-order") + (home-page "https://hackage.haskell.org/package/network-byte-order") (synopsis "Network byte order utilities") (description "This library provides peek and poke functions for network byte order.") @@ -7449,6 +8000,56 @@ class, and a lazy number type for non-negative numbers (a generalization of Peano numbers).") (license license:gpl3+))) +(define-public ghc-nonce + (package + (name "ghc-nonce") + (version "1.0.7") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/nonce/" + "nonce-" version ".tar.gz")) + (sha256 + (base32 + "1q9ph0aq51mvdvydnriqd12sfin36pfb8f588zgac1ybn8r64ksb")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-entropy" ,ghc-entropy) + ("ghc-unliftio" ,ghc-unliftio) + ("ghc-unliftio-core" ,ghc-unliftio-core))) + (home-page "https://github.com/prowdsponsor/nonce") + (synopsis "Generate cryptographic nonces in Haskell") + (description + "A nonce is an arbitrary number used only once in a cryptographic +communication. This package contain helper functions for generating nonces. +There are many kinds of nonces used in different situations. It's not +guaranteed that by using the nonces from this package you won't have any +security issues. Please make sure that the nonces generated via this +package are usable on your design.") + (license license:bsd-3))) + +(define-public ghc-numeric-extras + (package + (name "ghc-numeric-extras") + (version "0.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "numeric-extras/numeric-extras-" + version ".tar.gz")) + (sha256 + (base32 + "1mk11c0gz1yjy5b8dvq6czfny57pln0bs7x28fz38qyr44872067")))) + (build-system haskell-build-system) + (home-page "https://github.com/ekmett/numeric-extras") + (synopsis "Useful tools from the C standard library") + (description "This library provides some useful tools from the C +standard library.") + (license license:bsd-3))) + (define-public ghc-objectname (package (name "ghc-objectname") @@ -7698,6 +8299,114 @@ easily work with command-line options.") command line options in Haskell.") (license license:bsd-3))) +(define-public ghc-jira-wiki-markup + (package + (name "ghc-jira-wiki-markup") + (version "1.0.0") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/jira-wiki-markup/" + "jira-wiki-markup-" version ".tar.gz")) + (sha256 + (base32 "1sl2jjcsqg61si33mxjwpf8zdn56kbbgcwqqqzbgifx2qbv4wmf8")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit))) + (home-page "https://github.com/tarleb/jira-wiki-markup") + (synopsis "Handle Jira wiki markup") + (description + "Parse jira wiki text into an abstract syntax tree for easy transformation +to other formats.") + (license license:expat))) + +(define-public ghc-emojis + (package + (name "ghc-emojis") + (version "0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/emojis/" + "emojis-" version ".tar.gz")) + (sha256 + (base32 "1c6zkj9gmk1y90gbdrn50hyp7mw1mggzhnr2khqd728ryipw60ss")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-hunit" ,ghc-hunit))) + (home-page "https://github.com/jgm/emojis#readme") + (synopsis "Conversion between emoji characters and their names.") + (description + "This package provides functions for converting emoji names to emoji +characters and vice versa. + +How does it differ from the @code{emoji} package? +@itemize +@item It supports a fuller range of emojis, including all those supported by +GitHub +@item It supports lookup of emoji aliases from emoji +@item It uses Text rather than String +@item It has a lighter dependency footprint: in particular, it does not +require aeson +@item It does not require TemplateHaskell +@end itemize") + (license license:bsd-3))) + +(define-public ghc-text-conversions + (package + (name "ghc-text-conversions") + (version "0.3.0") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/text-conversions/" + "text-conversions-" version ".tar.gz")) + (sha256 + (base32 "089c56vdj9xysqfr1hnvbnrghlg83q6w10xk02gflpsidcpvwmhp")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base16-bytestring" ,ghc-base16-bytestring) + ("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-errors" ,ghc-errors))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) + (home-page "https://github.com/cjdev/text-conversions#readme") + (synopsis "Safe conversions between textual types") + (description "Safe conversions between textual types") + (license license:isc))) + +(define-public ghc-doclayout + (package + (name "ghc-doclayout") + (version "0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/doclayout/" + "doclayout-" version ".tar.gz")) + (sha256 + (base32 "1wmnwq28jcyd6c80srivsnd5znmyl9sgmwwnlk2crwiiwqadbal7")))) + (build-system haskell-build-system) + (inputs + `(("ghc-safe" ,ghc-safe))) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-golden" ,ghc-tasty-golden) + ("ghc-tasty-hunit" ,ghc-tasty-hunit))) + (home-page "https://github.com/jgm/doclayout") + (synopsis "Pretty-printing library for laying out text documents") + (description + "doclayout is a pretty-printing library for laying out text documents, +with several features not present in pretty-printing libraries designed for +code. It was designed for use in @code{Pandoc}.") + (license license:bsd-3))) + (define-public ghc-pandoc (package (name "ghc-pandoc") @@ -7992,7 +8701,7 @@ the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s ("ghc-hspec" ,ghc-hspec) ("ghc-validity" ,ghc-validity))) (home-page - "http://hackage.haskell.org/package/path") + "https://hackage.haskell.org/package/path") (synopsis "Support for well-typed paths") (description "This package introduces a type for paths upholding useful invariants.") @@ -8078,6 +8787,29 @@ of two versions of a source file. It provides a good balance between performance, nice output for humans, and simplicity of implementation.") (license license:bsd-3))) +(define-public ghc-pattern-arrows + (package + (name "ghc-pattern-arrows") + (version "0.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "mirror://hackage/package/pattern-arrows/pattern-arrows-" + version + ".tar.gz")) + (sha256 + (base32 + "13q7bj19hd60rnjfc05wxlyck8llxy11z3mns8kxg197wxrdkhkg")))) + (build-system haskell-build-system) + (home-page + "https://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html") + (synopsis "Arrows for Pretty Printing") + (description + "A library for generating concise pretty printers based on precedence +rules.") + (license license:expat))) + (define-public ghc-pcre-light (package (name "ghc-pcre-light") @@ -8108,41 +8840,36 @@ syntax and semantics as Perl 5.") (define-public ghc-persistent (package (name "ghc-persistent") - (version "2.9.2") + (version "2.10.4") (source (origin (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "persistent-" version "/" - "persistent-" version ".tar.gz")) + (uri (string-append + "https://hackage.haskell.org/package/persistent/" + "persistent-" version ".tar.gz")) (sha256 (base32 - "1wsa3kn427v88a6r0vwr6mz23snik2krbsgc8zqp18xajqn5szj9")))) + "1cxswz72sqdg2z1nbpgp1k5qr41djgk8qbf8nz7wfppsrhacyffi")))) (build-system haskell-build-system) - (inputs `(("ghc-old-locale" ,ghc-old-locale) - ("ghc-conduit" ,ghc-conduit) - ("ghc-resourcet" ,ghc-resourcet) - ("ghc-exceptions" ,ghc-exceptions) - ("ghc-monad-control" ,ghc-monad-control) - ("ghc-lifted-base" ,ghc-lifted-base) - ("ghc-resource-pool" ,ghc-resource-pool) - ("ghc-path-pieces" ,ghc-path-pieces) - ("ghc-http-api-data" ,ghc-http-api-data) - ("ghc-aeson" ,ghc-aeson) - ("ghc-monad-logger" ,ghc-monad-logger) - ("ghc-transformers-base" ,ghc-transformers-base) - ("ghc-base64-bytestring" ,ghc-base64-bytestring) - ("ghc-unordered-containers" ,ghc-unordered-containers) - ("ghc-vector" ,ghc-vector) - ("ghc-attoparsec" ,ghc-attoparsec) - ("ghc-haskell-src-meta" ,ghc-haskell-src-meta) - ("ghc-blaze-html" ,ghc-blaze-html) - ("ghc-blaze-markup" ,ghc-blaze-markup) - ("ghc-silently" ,ghc-silently) - ("ghc-fast-logger" ,ghc-fast-logger) - ("ghc-scientific" ,ghc-scientific) - ("ghc-tagged" ,ghc-tagged) - ("ghc-void" ,ghc-void))) + (inputs + `(("ghc-aeson" ,ghc-aeson) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-blaze-html" ,ghc-blaze-html) + ("ghc-conduit" ,ghc-conduit) + ("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-http-api-data" ,ghc-http-api-data) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-path-pieces" ,ghc-path-pieces) + ("ghc-resource-pool" ,ghc-resource-pool) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-scientific" ,ghc-scientific) + ("ghc-silently" ,ghc-silently) + ("ghc-unliftio-core" ,ghc-unliftio-core) + ("ghc-unliftio" ,ghc-unliftio) + ("ghc-unordered-containers" + ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector))) (native-inputs `(("ghc-hspec" ,ghc-hspec))) (home-page "https://www.yesodweb.com/book/persistent") (synopsis "Type-safe, multi-backend data serialization for Haskell") @@ -8154,68 +8881,191 @@ way.") (define-public ghc-persistent-sqlite (package (name "ghc-persistent-sqlite") - (version "2.9.3") + (version "2.10.5.2") (source (origin (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "persistent-sqlite-" version "/" - "persistent-sqlite-" version ".tar.gz")) + (uri (string-append + "https://hackage.haskell.org/package/persistent-sqlite/" + "persistent-sqlite-" version ".tar.gz")) (sha256 (base32 - "13wbn88ixv4d4dfjl1gabm1q60fbcnygbmixz57pi3z84drrynwq")))) + "0agag3cgivl6mk38pqzr0qw5lxps9p2bgdwvi5658l46hs7bixxn")))) (build-system haskell-build-system) - (inputs `(("ghc-persistent" ,ghc-persistent) - ("ghc-unliftio-core" ,ghc-unliftio-core) - ("ghc-aeson" ,ghc-aeson) - ("ghc-conduit" ,ghc-conduit) - ("ghc-monad-logger" ,ghc-monad-logger) - ("ghc-microlens-th" ,ghc-microlens-th) - ("ghc-resourcet" ,ghc-resourcet) - ("ghc-old-locale" ,ghc-old-locale) - ("ghc-resource-pool" ,ghc-resource-pool) - ("ghc-unordered-containers" ,ghc-unordered-containers))) - (native-inputs `(("ghc-hspec" ,ghc-hspec) - ("ghc-persistent-template" ,ghc-persistent-template) - ("ghc-temporary" ,ghc-temporary))) + (inputs + `(("ghc-persistent" ,ghc-persistent) + ("ghc-aeson" ,ghc-aeson) + ("ghc-conduit" ,ghc-conduit) + ("ghc-microlens-th" ,ghc-microlens-th) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-resource-pool" ,ghc-resource-pool) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-unliftio-core" ,ghc-unliftio-core) + ("ghc-unordered-containers" + ,ghc-unordered-containers))) + (native-inputs + `(("ghc-persistent-template" + ,ghc-persistent-template) + ("ghc-persistent-test" ,ghc-persistent-test) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-hspec" ,ghc-hspec) + ("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-system-fileio" ,ghc-system-fileio) + ("ghc-system-filepath" ,ghc-system-filepath) + ("ghc-temporary" ,ghc-temporary))) + (home-page + "https://www.yesodweb.com/book/persistent") + (synopsis "Backend for the persistent library using sqlite3") + (description "This Haskell package includes a thin sqlite3 wrapper based +on the direct-sqlite package, as well as the entire C library, so there are no +system dependencies.") + (license license:expat))) + +(define-public ghc-persistent-template + (package + (name "ghc-persistent-template") + (version "2.8.0") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/persistent-template/" + "persistent-template-" version ".tar.gz")) + (sha256 + (base32 + "16yjrl0gh4jbs4skr7iv6a55lny59bqhd6hjmvch1cl9j5d0c0g3")))) + (build-system haskell-build-system) + (inputs + `(("ghc-persistent" ,ghc-persistent) + ("ghc-aeson" ,ghc-aeson) + ("ghc-http-api-data" ,ghc-http-api-data) + ("ghc-monad-control" ,ghc-monad-control) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-path-pieces" ,ghc-path-pieces) + ("ghc-th-lift-instances" ,ghc-th-lift-instances) + ("ghc-unordered-containers" + ,ghc-unordered-containers))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://www.yesodweb.com/book/persistent") + (synopsis "Type-safe, non-relational, multi-backend persistence") + (description "This Haskell package provides interfaces and helper +functions for the ghc-persistent package.") + (license license:expat))) + +(define-public ghc-persistent-test + (package + (name "ghc-persistent-test") + (version "2.0.3.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/persistent-test/" + "persistent-test-" version ".tar.gz")) + (sha256 + (base32 + "11aq5cy0n43jamf6mg4sr4300bc2zdbjxsczzxwjkb4hzs0ijsdv")))) + (build-system haskell-build-system) + (inputs + `(("ghc-aeson" ,ghc-aeson) + ("ghc-blaze-html" ,ghc-blaze-html) + ("ghc-conduit" ,ghc-conduit) + ("ghc-monad-control" ,ghc-monad-control) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-path-pieces" ,ghc-path-pieces) + ("ghc-persistent" ,ghc-persistent) + ("ghc-persistent-template" ,ghc-persistent-template) + ("ghc-random" ,ghc-random) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-transformers-base" ,ghc-transformers-base) + ("ghc-unliftio" ,ghc-unliftio) + ("ghc-unliftio-core" ,ghc-unliftio-core) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) + ("ghc-hspec" ,ghc-hspec) + ("ghc-hspec-expectations" ,ghc-hspec-expectations) + ("ghc-hunit" ,ghc-hunit))) + (home-page "https://www.yesodweb.com/book/persistent") + (synopsis "Tests for the Persistent database library") + (description + "This is only for use in developing libraries that should conform to +the persistent interface, not for users of the persistent suite of database +libraries.") + (license license:expat))) + +(define-public ghc-pipes + (package + (name "ghc-pipes") + (version "4.3.13") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/pipes/" + "pipes-" version ".tar.gz")) + (sha256 + (base32 + "1ch3xr5f5if0psd3lsyrpkwrgh36synnzqcpimghprys68l4zfkn")))) + (build-system haskell-build-system) + (inputs + `(("ghc-exceptions" ,ghc-exceptions) + ("ghc-mmorph" ,ghc-mmorph) + ("ghc-void" ,ghc-void) + ("ghc-semigroups" ,ghc-semigroups))) + (native-inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-quickcheck2" + ,ghc-test-framework-quickcheck2))) (home-page - "https://www.yesodweb.com/book/persistent") - (synopsis "Backend for the persistent library using sqlite3") - (description "This Haskell package includes a thin sqlite3 wrapper based -on the direct-sqlite package, as well as the entire C library, so there are no -system dependencies.") - (license license:expat))) + "https://hackage.haskell.org/package/pipes") + (synopsis "Compositional pipelines") + (description + "A clean and powerful stream processing library that lets you build +and connect reusable streaming components. Advantages over traditional streaming +libraries: +@itemize +@item Concise API: Use simple commands like @code{for}, (@code{>->}), @code{await}, +and @code{yield} +@item Blazing fast: Implementation tuned for speed, including shortcut fusion +@item Lightweight Dependency: pipes is small and compiles very rapidly, including +dependencies +@item Elegant semantics: Use practical category theory +@item ListT: Correct implementation of @code{ListT} that interconverts with pipes +@item Bidirectionality: Implement duplex channels +@end itemize") + (license license:bsd-3))) -(define-public ghc-persistent-template +(define-public ghc-pointedlist (package - (name "ghc-persistent-template") - (version "2.6.0") + (name "ghc-pointedlist") + (version "0.6.1") (source (origin (method url-fetch) - (uri (string-append "https://hackage.haskell.org/package/" - "persistent-template-" version "/" - "persistent-template-" version ".tar.gz")) + (uri (string-append + "https://hackage.haskell.org/package/pointedlist/" + "pointedlist-" version ".tar.gz")) (sha256 (base32 - "0wr1z2nfrl6jv1lprxb0d2jw4izqfcbcwvkdrhryzg95gjz8ryjv")))) + "16xsrzqql7i4z6a3xy07sqnbyqdmcar1jiacla58y4mvkkwb0g3l")))) (build-system haskell-build-system) - (inputs `(("ghc-persistent" ,ghc-persistent) - ("ghc-monad-control" ,ghc-monad-control) - ("ghc-aeson" ,ghc-aeson) - ("ghc-aeson-compat" ,ghc-aeson-compat) - ("ghc-monad-logger" ,ghc-monad-logger) - ("ghc-unordered-containers" ,ghc-unordered-containers) - ("ghc-tagged" ,ghc-tagged) - ("ghc-path-pieces" ,ghc-path-pieces) - ("ghc-http-api-data" ,ghc-http-api-data))) - (native-inputs `(("ghc-hspec" ,ghc-hspec) - ("ghc-quickcheck" ,ghc-quickcheck))) - (home-page "https://www.yesodweb.com/book/persistent") - (synopsis "Type-safe, non-relational, multi-backend persistence") - (description "This Haskell package provides interfaces and helper -functions for the ghc-persistent package.") - (license license:expat))) + (home-page + "https://hackage.haskell.org/package/pointedlist") + (synopsis + "Zipper-like comonad which works as a list, tracking a position") + (description + "A PointedList tracks the position in a non-empty list which works +similarly to a zipper. A current item is always required, and therefore +the list may never be empty. A circular PointedList wraps around to the +other end when progressing past the actual edge.") + (license license:bsd-3))) (define-public ghc-polyparse (package @@ -8302,7 +9152,7 @@ reduce @code{UndecidableInstances}.") (base32 "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5")))) (build-system haskell-build-system) - (home-page "http://hackage.haskell.org/package/prettyclass") + (home-page "https://hackage.haskell.org/package/prettyclass") (synopsis "Pretty printing class similar to Show") (description "This package provides a pretty printing class similar to @code{Show}, based on the HughesPJ pretty printing library. It @@ -8442,6 +9292,73 @@ API.") (description "This library provides profunctors for Haskell.") (license license:bsd-3))) +(define-public ghc-project-template + (package + (name "ghc-project-template") + (version "0.2.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/project-template/project-template-" + version ".tar.gz")) + (sha256 + (base32 + "1p69ww4rhah2qxragl615wl4a6mk4x9w09am8knmz3s4lxpljlpb")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-conduit" ,ghc-conduit) + ("ghc-conduit-extra" ,ghc-conduit-extra) + ("ghc-resourcet" ,ghc-resourcet))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover) + ("ghc-quickcheck" ,ghc-quickcheck))) + (arguments + `(#:cabal-revision + ("1" + "0lq3sqnq0nr0gbvgzp0lqdl3j3mqdmdlf8xsw0j3pjh581xj3k0a"))) + (home-page "https://github.com/fpco/haskell-ide") + (synopsis "Specify Haskell project templates and generate files") + (description + "Haskell library for both generating and consuming project templates. + +ost IDEs provide the concept of a project template: instead of writing all +of the code for a project from scratch, you select a template, answer a few +questions, and a bunch of files are automatically generated. + +project-template tries to provide a canonical Haskell library for implementing +the ideal templating system.") + (license license:bsd-3))) + +(define-public ghc-protolude + (package + (name "ghc-protolude") + (version "0.2.3") + (source + (origin + (method url-fetch) + (uri (string-append + "mirror://hackage/package/protolude/protolude-" + version + ".tar.gz")) + (sha256 + (base32 + "0zzkyxz0vmcbncpid7gp72fpjj0fla3gqhlfkij5c5lg12skjgfj")))) + (build-system haskell-build-system) + (inputs + `(("ghc-async" ,ghc-async) + ("ghc-hashable" ,ghc-hashable) + ("ghc-mtl-compat" ,ghc-mtl-compat) + ("ghc-transformers-compat" ,ghc-transformers-compat))) + (home-page "https://github.com/protolude/protolude") + (synopsis "Sensible set of defaults for writing custom Preludes") + (description + "Protolude gives you sensible defaults for writing custom Preludes to +replace the standard one provided by GHC.") + (license license:expat))) + (define-public ghc-psqueues (package (name "ghc-psqueues") @@ -8507,6 +9424,36 @@ Typical applications of Priority Search Queues include: @end itemize") (license license:bsd-3))) +(define-public ghc-pwstore-fast + (package + (name "ghc-pwstore-fast") + (version "2.4.4") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/pwstore-fast/" + "pwstore-fast-" version ".tar.gz")) + (sha256 + (base32 + "1cpvlwzg3qznhygrr78f75p65mnljd9v5cvnagfxjqppnrkay6bj")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-cryptohash" ,ghc-cryptohash) + ("ghc-random" ,ghc-random) + ("ghc-byteable" ,ghc-byteable))) + (home-page "https://github.com/PeterScott/pwstore") + (synopsis "Secure password storage") + (description + "To store passwords securely, they should be salted, then hashed with +a slow hash function. This library uses PBKDF1-SHA256, and handles all the +details. It uses the cryptohash package for speed; if you need a pure +Haskell library, pwstore-purehaskell has the exact same API, but uses only +pure Haskell. It is about 25 times slower than this package, but still quite +usable.") + (license license:bsd-3))) + (define-public ghc-random (package (name "ghc-random") @@ -8669,7 +9616,7 @@ containers and a general map/reduce framework for Haskell.") (base32 "0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a")))) (build-system haskell-build-system) - (home-page "http://hackage.haskell.org/package/refact") + (home-page "https://hackage.haskell.org/package/refact") (synopsis "Specify refactorings to perform with apply-refact") (description "This library provides a datatype which can be interpreted by @@ -8911,7 +9858,7 @@ Haskell library @code{regex-base}.") (build-system haskell-build-system) (inputs `(("ghc-regex-base" ,ghc-regex-base))) - (home-page "https://github.com/ChrisKuklewicz/regex-tdfa") + (home-page "https://github.com/haskell-hvr/regex-tdfa") (synopsis "POSIX extended regular expressions in Haskell.") (description "Regex-tdfa is a pure Haskell regular expression library implementing POSIX @@ -8937,7 +9884,7 @@ inspired by libtre.") `(("ghc-regex-base" ,ghc-regex-base) ("ghc-regex-tdfa" ,ghc-regex-tdfa))) (home-page - "http://hackage.haskell.org/package/regex-tdfa-text") + "https://hackage.haskell.org/package/regex-tdfa-text") (synopsis "Text interface for regex-tdfa") (description "This provides an extra text interface for regex-tdfa.") @@ -9292,6 +10239,40 @@ are not exception safe and can be broken by @code{killThread}.") (description "Reasonably fast data encoding library.") (license license:bsd-3))) +(define-public ghc-say + (package + (name "ghc-say") + (version "0.1.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/say/say-" + version + ".tar.gz")) + (sha256 + (base32 + "1r5kffjfwpas45g74sip8glrj1m9nygrnxjm7xgw898rq9pnafgn")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover) + ("ghc-unliftio" ,ghc-unliftio))) + (home-page "https://github.com/fpco/say") + (synopsis + "Send textual messages to a Handle in a thread-friendly way") + (description + "A thread safe API to write a line of textual data to a Handle, such +as sending some messages to the terminal - that has the following properties: +@itemize +@item Properly handle character encoding settings on the Handle +@item For reasonably sized messages, ensure that the entire message is written + in one chunk to avoid interleaving data with other threads +@item Avoid unnecessary memory allocations and copies +@item Minimize locking. +@end itemize") + (license license:expat))) + (define-public ghc-scientific (package (name "ghc-scientific") @@ -9389,7 +10370,7 @@ award winning Linux port of \"Civilization: Call To Power.\"") (native-inputs `(("ghc-weigh" ,ghc-weigh) ("pkg-config" ,pkg-config))) - (home-page "http://hackage.haskell.org/package/sdl2") + (home-page "https://hackage.haskell.org/package/sdl2") (synopsis "High- and low-level bindings to the SDL library") (description "This package contains bindings to the SDL 2 library, in both high- and @@ -9420,7 +10401,7 @@ programming.") ("sdl2-image" ,sdl2-image))) (native-inputs `(("pkg-config" ,pkg-config))) - (home-page "http://hackage.haskell.org/package/sdl2-image") + (home-page "https://hackage.haskell.org/package/sdl2-image") (synopsis "Bindings to SDL2_image") (description "This package provides Haskell bindings to @code{SDL2_image}.") @@ -9448,7 +10429,7 @@ programming.") ("sdl2-mixer" ,sdl2-mixer))) (native-inputs `(("pkg-config" ,pkg-config))) - (home-page "http://hackage.haskell.org/package/sdl2-mixer") + (home-page "https://hackage.haskell.org/package/sdl2-mixer") (synopsis "Bindings to SDL2 mixer") (description "This package provides Haskell bindings to @code{SDL2_mixer}.") @@ -9538,6 +10519,46 @@ Haskell") a memory chunk that will be auto-scrubbed after it run out of scope.") (license license:bsd-3))) +(define-public ghc-semialign + (package + (name "ghc-semialign") + (version "1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/semialign/semialign-" + version + ".tar.gz")) + (sha256 + (base32 + "004x0a80sqqdgvsyk4z0nasxpi6z3g1d8kgwj804bj9ka8dlc75m")))) + (build-system haskell-build-system) + (inputs + `(("ghc-these" ,ghc-these) + ("ghc-base-compat" ,ghc-base-compat) + ("ghc-hashable" ,ghc-hashable) + ("ghc-tagged" ,ghc-tagged) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector) + ("ghc-semigroupoids" ,ghc-semigroupoids))) + (arguments + `(#:cabal-revision + ("1" + "0qnqnyfng4kwy2h2anrcy5id2ijnawava3zcc5h5b8ri1y6ks6zi"))) + (home-page + "https://github.com/isomorphism/these") + (synopsis + "Align and Zip type-classes from the common Semialign ancestor ") + (description + "The major use of @code{These} of this is provided by the +@code{align} member of @code{Semialign} class, representing a +generalized notion of \"zipping with padding\" that combines +structures without truncating to the size of the smaller input. It +turns out that @code{zip} operation fits well the @code{Semialign} +class, forming lattice-like structure.") + (license license:bsd-3))) + (define-public ghc-semigroupoids (package (name "ghc-semigroupoids") @@ -9807,6 +10828,32 @@ them.") are the bottleneck of web servers.") (license license:bsd-3))) +(define-public ghc-size-based + (package + (name "ghc-size-based") + (version "0.1.2.0") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "size-based/size-based-" version ".tar.gz")) + (sha256 + (base32 + "06hmlic0n73ncwlkpx49xlv09bzsrr27ncnp5byhzlknak2gd7vp")))) + (build-system haskell-build-system) + (inputs + `(("ghc-dictionary-sharing" ,ghc-dictionary-sharing) + ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers) + ("ghc-semigroups" ,ghc-semigroups))) + (arguments + `(#:cabal-revision + ("1" "0kax1ypjyglkn6iff1x4yz12y7f2n249m95xvdhrc63hsa4xlcqv"))) + (home-page "https://hackage.haskell.org/package/size-based") + (synopsis "Sized functors for size-based enumerations") + (description "This library provides a framework for size-based +enumerations.") + (license license:bsd-3))) + (define-public ghc-skylighting-core (package (name "ghc-skylighting-core") @@ -9886,7 +10933,7 @@ provided. Skylighting is intended to be the successor to highlighting-kate.") (home-page "https://github.com/feuerbach/smallcheck") (synopsis "Property-based testing library") - (description "SmallCheck is a testing library that allows to verify + (description "SmallCheck is a testing library that verifies properties for all test cases up to some depth. The test cases are generated automatically by SmallCheck.") (license license:bsd-3))) @@ -9926,7 +10973,7 @@ automatically by SmallCheck.") (base32 "07ci2mh8cbjvipb576rxsj3iyhkj5c5dnsns4xkdppp2p3pv10d3")))) (build-system haskell-build-system) - (home-page "http://hackage.haskell.org/package/sop-core") + (home-page "https://hackage.haskell.org/package/sop-core") (synopsis "True Sums of Products") (description "This package provides an implementation of @math{n}-ary sums and @math{n}-ary products. The module @code{Data.SOP} @@ -9985,7 +11032,7 @@ mainstream languages.") ("ghc-base-compat-batteries" ,ghc-base-compat-batteries) ("ghc-tf-random" ,ghc-tf-random) ("ghc-vector" ,ghc-vector))) - (home-page "http://hackage.haskell.org/package/splitmix") + (home-page "https://hackage.haskell.org/package/splitmix") (synopsis "Fast and splittable pseudorandom number generator") (description "This package provides a Pure Haskell implementation of the SplitMix pseudorandom number generator. SplitMix is a \"splittable\" @@ -10380,7 +11427,7 @@ literals.") (build-system haskell-build-system) (native-inputs `(("ghc-hunit" ,ghc-hunit))) - (home-page "http://hackage.haskell.org/package/string-qq") + (home-page "https://hackage.haskell.org/package/string-qq") (synopsis "QuasiQuoter for non-interpolated strings, texts and bytestrings.") (description @@ -10414,68 +11461,30 @@ functions for breaking or splitting on substrings and replacing all occurrences of a substring (the first in case of overlaps) with another.") (license license:bsd-3))) -(define-public ghc-stylish-haskell +(define-public ghc-svg-builder (package - (name "ghc-stylish-haskell") - (version "0.9.2.1") + (name "ghc-svg-builder") + (version "0.1.1") (source - (origin - (method url-fetch) - (uri (string-append - "mirror://hackage/package/stylish-haskell/stylish-haskell-" - version - ".tar.gz")) - (sha256 - (base32 - "1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w")))) + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/" + "svg-builder/svg-builder-" version ".tar.gz")) + (sha256 + (base32 + "1k420f497lzkymmxin88ql6ib8dziic43avykv31yq65rgrf7l2g")))) (build-system haskell-build-system) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "stylish-haskell.cabal" - (("haskell-src-exts >= 1\\.18 && < 1\\.21,") - "haskell-src-exts >= 1.18 && < 1.22,")) - #t))))) (inputs - `(("ghc-aeson" ,ghc-aeson) - ("ghc-file-embed" ,ghc-file-embed) - ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) - ("ghc-semigroups" ,ghc-semigroups) - ("ghc-syb" ,ghc-syb) - ("ghc-yaml" ,ghc-yaml) - ("ghc-strict" ,ghc-strict) - ("ghc-optparse-applicative" - ,ghc-optparse-applicative))) - (native-inputs - `(("ghc-hunit" ,ghc-hunit) - ("ghc-test-framework" ,ghc-test-framework) - ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) - (home-page "https://github.com/jaspervdj/stylish-haskell") - (synopsis "Haskell code prettifier") - (description "Stylish-haskell is a Haskell code prettifier. The goal is -not to format all of the code in a file, to avoid \"getting in the way\". -However, this tool can e.g. clean up import statements and help doing various -tasks that get tedious very quickly. It can -@itemize -@item -Align and sort @code{import} statements -@item -Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant -pragmas -@item -Remove trailing whitespaces -@item -Align branches in @code{case} and fields in records -@item -Convert line endings (customisable) -@item -Replace tabs by four spaces (turned off by default) -@item -Replace some ASCII sequences by their Unicode equivalent (turned off by -default) -@end itemize") + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-hashable" ,ghc-hashable) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (arguments + `(#:cabal-revision + ("1" "1bhp9gvid2iis411k1vvyj5krzc4ahxcqcd9cwx9h37jxg180xw1"))) + (home-page "https://github.com/diagrams/svg-builder.git") + (synopsis "Domain-specific language for building Scalable Vector Graphics") + (description "Easy-to-write domain-specific language (DSL) for +building Scalable Vector Graphics (SVG).") (license license:bsd-3))) (define-public ghc-syb @@ -11031,6 +12040,63 @@ and @code{Eq} instances. These instances used to live in the haskell-src-meta package, and that's where the version number started.") (license license:bsd-3))) +(define-public ghc-these + (package + (name "ghc-these") + (version "1.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/these/these-" + version + ".tar.gz")) + (sha256 + (base32 + "1k0pi65g7cm9hzdw6my6bzz2zvddkmj1qs45ymqmi316bpiixk3r")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-hashable" ,ghc-hashable) + ("ghc-aeson" ,ghc-aeson) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-assoc" ,ghc-assoc) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-quickcheck" ,ghc-quickcheck))) + (arguments + `(#:cabal-revision + ("1" + "0923r86fnmgpx0msm68aszirh2n19nn5bccgjxfh2146jw4z7w3z"))) + (home-page + "https://github.com/isomorphism/these") + (synopsis "Either-or-both data type") + (description + "This package provides a data type @code{These a b} which can +hold a value of either type or values of each type. This is usually +thought of as an \"inclusive or\" type (contrasting @code{Either a b} as +\"exclusive or\") or as an \"outer join\" type (contrasting @code{(a, b)} +as \"inner join\"). + +@code{data These a b = This a | That b | These a b} + +Since version 1, this package was split into parts: + +@itemize +@item +https://hackage.haskell.org/package/semialign For @code{Align} and +@code{Zip} type-classes. +@item +https://hackage.haskell.org/package/semialign-indexed For +@code{SemialignWithIndex} class, providing @code{ialignWith} and +@code{izipWith} +@item +https://hackage.haskell.org/package/these-lens For lens combinators. +@item +http://hackage.haskell.org/package/monad-chronicle For transformers +variant of @code{These}. +@end itemize") + (license license:bsd-3))) + (define-public ghc-threads (package (name "ghc-threads") @@ -11121,7 +12187,7 @@ function which generates instances.") ("1" "0k8ph4sydaiqp8dav4if6hpiaq8h1xsr93khmdr7a1mmfwdxr64r"))) (home-page "https://github.com/phadej/time-compat") (synopsis "Compatibility package for time") - (description "This packages tries to compat as many @code{time} + (description "This package tries to compat as many @code{time} features as possible.") (license license:bsd-3))) @@ -11271,6 +12337,45 @@ from a shell. The @code{tldr} pages are a community effort to simplify the man pages with practical examples.") (license license:bsd-3))) +(define-public ghc-transformers + (package + (name "ghc-transformers") + (version "0.5.6.2") + (source + (origin + (method url-fetch) + (uri (string-append + "mirror://hackage/package/transformers/transformers-" + version + ".tar.gz")) + (sha256 + (base32 + "0v66j5k0xqk51pmca55wq192qyw2p43s2mgxlz4f95q2c1fpjs5n")))) + (build-system haskell-build-system) + (home-page + "http://hackage.haskell.org/package/transformers") + (synopsis "Concrete functor and monad transformers") + (description + "Transformers provides functor and 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 @url{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html}. + +This package contains: +@itemize +@item the monad transformer class (in @code{Control.Monad.Trans.Class}) +@item concrete functor and monad transformers, each with associated operations +and functions to lift operations associated with other transformers. +@end itemize + +This package can be used on its own in portable Haskell code, in which case +operations need to be manually lifted through transformer stacks (see +@code{Control.Monad.Trans.Class} for some examples). Alternatively, it can be +used with the non-portable monad classes in the mtl or monads-tf packages, +which automatically lift operations introduced by monad transformers through +other transformers.") + (license license:bsd-3))) + (define-public ghc-transformers-base (package (name "ghc-transformers-base") @@ -11483,7 +12588,7 @@ upon it.") #:cabal-revision ("1" "09pqi867wskwgc5lpn197f895mbn1174ydgllvcppcsmrz2b6yr6"))) - (home-page "http://hackage.haskell.org/package/unagi-chan") + (home-page "https://hackage.haskell.org/package/unagi-chan") (synopsis "Fast concurrent queues with a Chan-like API, and more") (description "This library provides implementations of concurrent FIFO queues (for @@ -11815,6 +12920,31 @@ a style ready for qualification, that is, you should import them by parser that uses ByteStrings for parsing and representing the URI data.") (license license:bsd-3))) +(define-public ghc-utf8-light + (package + (name "ghc-utf8-light") + (version "0.4.2") + (source + (origin + (method url-fetch) + (uri (string-append + "mirror://hackage/package/utf8-light/utf8-light-" + version + ".tar.gz")) + (sha256 + (base32 + "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q")))) + (build-system haskell-build-system) + (home-page + "http://hackage.haskell.org/package/utf8-light") + (synopsis "Lightweight unicode support for Haskell") + (description + "This package profides a class for encoding and decoding UTF8 strings +with instances for several common types. It also includes several functions +for working with UTF8. It aims to be lightweight, depending only on Base and +including only one module.") + (license license:bsd-3))) + (define-public ghc-utf8-string (package (name "ghc-utf8-string") @@ -12494,7 +13624,7 @@ parts.") (base32 "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j")))) (build-system haskell-build-system) - (home-page "http://code.galois.com") + (home-page "https://github.com/GaloisInc/xml") (synopsis "Simple XML library for Haskell") (description "This package provides a simple XML library for Haskell.") (license license:bsd-3)))