;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
-;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
;;; Copyright © 2016, 2019 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com>
;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
+;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
+;;; Copyright © 2020 JoJo <jo@jo.zone>
+;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr>
+;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
;;;
;;; This file is part of GNU Guix.
;;;
#: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)
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")
(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
∀ 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")
(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.")
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")
`(("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}.
(define-public ghc-esqueleto
(package
(name "ghc-esqueleto")
- (version "3.0.0")
+ (version "3.3.1.1")
(source
(origin
(method url-fetch)
"esqueleto/esqueleto-" version ".tar.gz"))
(sha256
(base32
- "187c098h2xyf2nhifkdy2bqfl6iap7a93mzwd2kirl5yyicpc9zy"))))
+ "1qi28ma8j5kfygjxnixlazxsyrkdqv8ljz3icwqi5dlscsnj6v3v"))))
(build-system haskell-build-system)
(arguments
`(#:haddock? #f ; Haddock reports an internal error.
("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
(define-public ghc-extra
(package
(name "ghc-extra")
- (version "1.6.18")
+ (version "1.6.21")
(source
(origin
(method url-fetch)
".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
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")
(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")
(define-public ghc-haddock
(package
(name "ghc-haddock")
- (version "2.19.0.1")
+ (version "2.22.0")
(source
(origin
(method url-fetch)
".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"
((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")
(define-public ghc-haddock-api
(package
(name "ghc-haddock-api")
- (version "2.19.0.1")
+ (version "2.22.0")
(source
(origin
(method url-fetch)
"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
(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)))
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")
`(#: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
(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.")
(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)
(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
(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.")
("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
("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.")
`(#: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.")
(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
(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
can handle infinite lists.")
(license license:bsd-3)))
+(define-public ghc-llvm-hs-pure
+ (package
+ (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-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")
(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.
`(("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
\"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")
(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.")
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")
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")
("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.")
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")
(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")
(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")
(define-public ghc-persistent-template
(package
(name "ghc-persistent-template")
- (version "2.6.0")
+ (version "2.8.0")
(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/persistent-template/"
+ "persistent-template-" version ".tar.gz"))
(sha256
(base32
- "0wr1z2nfrl6jv1lprxb0d2jw4izqfcbcwvkdrhryzg95gjz8ryjv"))))
+ "16yjrl0gh4jbs4skr7iv6a55lny59bqhd6hjmvch1cl9j5d0c0g3"))))
(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)))
+ (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://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-pointedlist
+ (package
+ (name "ghc-pointedlist")
+ (version "0.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/pointedlist/"
+ "pointedlist-" version ".tar.gz"))
+ (sha256
+ (base32
+ "16xsrzqql7i4z6a3xy07sqnbyqdmcar1jiacla58y4mvkkwb0g3l"))))
+ (build-system haskell-build-system)
+ (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
(name "ghc-polyparse")
(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
(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")
@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")
(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
(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
`(("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.")
(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")
(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
("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}.")
("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}.")
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")
(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)))
(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}
("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\"
(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
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
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")
("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)))
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")
#: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
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")
(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)))
HCoop / jackhill / guix / guix.git / blobdiff