;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
-;;; Copyright © 2016 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2016, 2018 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2016, 2017 ng0 <ng0@infotropique.org>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
;;; Copyright © 2017 Peter Mikkelsen <petermikkelsen10@gmail.com>
-;;; Copyright © 2017 Alex Vong <alexvong1995@gmail.com>
+;;; Copyright © 2017, 2018 Alex Vong <alexvong1995@gmail.com>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;;
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (guix utils)
- #:use-module (ice-9 regex))
+ #:use-module (ice-9 regex)
+ #:use-module ((srfi srfi-1) #:select (alist-delete)))
(define-public cl-yale-haskell
(let ((commit "85f94c72a16c5f70301dd8db04cde9de2d7dd270")
(source (origin
(method git-fetch)
(uri (git-reference
- (url "http://git.elephly.net/software/yale-haskell.git")
+ (url "https://git.elephly.net/software/yale-haskell.git")
(commit commit)))
(file-name (string-append "yale-haskell-" commit "-checkout"))
(sha256
#t)))))
(inputs
`(("clisp" ,clisp)))
- (home-page "http://git.elephly.net/software/yale-haskell.git")
+ (home-page "https://git.elephly.net/software/yale-haskell.git")
(synopsis "Port of the Yale Haskell system to CLISP")
(description "This package provides the Yale Haskell system running on
top of CLISP.")
(mkdir-p libtinfo-dir)
(symlink
(string-append ncurses-lib "/libncursesw.so."
- ,(version-major+minor
- (package-version ncurses)))
+ ;; Extract "6.0" from "6.0-20170930".
+ ,(let* ((v (package-version ncurses))
+ (d (string-index v #\-)))
+ (version-major+minor (string-take v d))))
(string-append libtinfo-dir "/libtinfo.so.5"))
+
(setenv "PATH"
(string-append (getenv "PATH") ":"
ghc-bootstrap-prefix "/bin"))
(base32 "1c8qc4fhkycynk4g1f9hvk53dj6a1vvqi6bklqznns6hw59m8qhi"))
(patches
(search-patches
- "ghc-dont-pass-linker-flags-via-response-files.patch"))))
+ "ghc-dont-pass-linker-flags-via-response-files.patch"
+ "ghc-8.0-fall-back-to-madv_dontneed.patch"))))
(build-system gnu-build-system)
(supported-systems '("i686-linux" "x86_64-linux"))
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
- (uri (string-append "http://hackage.haskell.org/package/libxml/"
+ (uri (string-append "https://hackage.haskell.org/package/libxml/"
"libxml-" version ".tar.gz"))
(sha256
(base32
`(,(string-append "--extra-include-dirs="
(assoc-ref %build-inputs "libxml2")
"/include/libxml2"))))
- (home-page "http://hackage.haskell.org/package/libxml")
+ (home-page "https://hackage.haskell.org/package/libxml")
(synopsis "Haskell bindings to libxml2")
(description
"This library provides minimal Haskell binding to libxml2.")
`(("hspec-discover" ,hspec-discover)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "http://www.haskell.org/haddock/")
+ (home-page "https://www.haskell.org/haddock/")
(synopsis "Library exposing some functionality of Haddock")
(description
"Haddock is a documentation-generation tool for Haskell libraries. These
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://www.haskell.org/haddock/")
+ (home-page "https://www.haskell.org/haddock/")
(synopsis "API for documentation-generation tool Haddock")
(description "This package provides an API to Haddock, the
documentation-generation tool for Haskell libraries.")
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-haddock-test" ,ghc-haddock-test)))
- (home-page "http://www.haskell.org/haddock/")
+ (home-page "https://www.haskell.org/haddock/")
(synopsis
"Documentation-generation tool for Haskell libraries")
(description
"1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq"))))
(build-system haskell-build-system)
(home-page
- "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
+ "https://twanvl.nl/blog/haskell/simple-reflection-of-expressions")
(synopsis
"Simple reflection of expressions containing variables")
(description
"0bi1cs9b8ir33h1fl6x2xw4ymygapqbr713ridpf7rmk2wa7jqqs"))))
(build-system haskell-build-system)
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "http://www.haskell.org/alex/")
+ (home-page "https://www.haskell.org/alex/")
(synopsis
"Tool for generating lexical analysers in Haskell")
(description
(description
"Concatenative gives Haskell Factor-style combinators and arrows for
postfix notation. For more information on stack based languages, see
-@uref{http://concatenative.org}.")
+@uref{https://concatenative.org}.")
(license license:bsd-3)))
(define-public ghc-happy
(synopsis "Specify refactorings to perform with apply-refact")
(description
"This library provides a datatype which can be interpreted by
-@code{apply-refact}. It exists as a seperate library so that applications can
+@code{apply-refact}. It exists as a separate library so that applications can
specify refactorings without depending on GHC.")
(license license:bsd-3)))
("ghc-fixed" ,ghc-fixed)
("glu" ,glu)
("ghc-text" ,ghc-text)))
- (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Raw Haskell bindings for the OpenGL graphics system")
(description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
("ghc-opengl" ,ghc-opengl)
("ghc-openglraw" ,ghc-openglraw)
("freeglut" ,freeglut)))
- (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Haskell bindings for the OpenGL Utility Toolkit")
(description "This library provides Haskell bindings for the OpenGL
Utility Toolkit, a window system-independent toolkit for writing OpenGL
(build-system haskell-build-system)
(inputs
`(("ghc-openglraw" ,ghc-openglraw)))
- (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Raw Haskell bindings GLU")
(description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
("ghc-gluraw" ,ghc-gluraw)
("ghc-statevar" ,ghc-statevar)
("ghc-openglraw" ,ghc-openglraw)))
- (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://www.haskell.org/haskellwiki/Opengl")
(synopsis "Haskell bindings for the OpenGL graphics system")
(description "This package provides Haskell bindings for the OpenGL
graphics system (GL, version 4.5) and its accompanying utility library (GLU,
("ghc-random" ,ghc-random)
("ghc-stm" ,ghc-stm)
("ghc-zlib" ,ghc-zlib)))
- (home-page "http://www.haskell.org/cabal/")
+ (home-page "https://www.haskell.org/cabal/")
(synopsis "Command-line interface for Cabal and Hackage")
(description
"The cabal command-line program simplifies the process of managing
(base32
"1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa"))))
(build-system haskell-build-system)
+ ;; This is an official revision, relaxing the requirement transformers ==
+ ;; 0.4 to transformers >= 0.4 && < 0.6; see
+ ;; https://hackage.haskell.org/package/mtl-2.2.1/revision/1.cabal
(arguments
`(#:configure-flags (list "--allow-newer=transformers")))
- (inputs
- `(("ghc-transformers" ,ghc-transformers)))
(home-page "https://github.com/ekmett/mtl")
(synopsis
"Monad classes, using functional dependencies")
for various monad transformers, inspired by the paper 'Functional Programming
with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced
School of Functional Programming', 1995. See
-@uref{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
+@uref{https://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.")
(license license:bsd-3)))
(define-public ghc-paths
"0qk741yqnpd69sksgks2vb7zi50rglp9m498lzw4sh268a017rsi"))))
(build-system haskell-build-system)
(inputs `(("ghc-exceptions" ,ghc-exceptions)))
- (home-page "http://www.github.com/batterseapower/temporary")
+ (home-page "https://www.github.com/batterseapower/temporary")
(synopsis "Temporary file and directory support")
(description "The functions for creating temporary files and directories
in the Haskelll base library are quite limited. This library just repackages
(build-system haskell-build-system)
(inputs `(("ghc-exceptions" ,ghc-exceptions)))
(home-page
- "http://www.github.com/feuerbach/temporary")
+ "https://www.github.com/feuerbach/temporary")
(synopsis
"Portable temporary file and directory support")
(description
`(("ghc-mtl" ,ghc-mtl)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
+ (home-page "https://web.engr.oregonstate.edu/~erwig/fgl/haskell")
(synopsis
"Martin Erwig's Functional Graph Library")
(description "The functional graph library, FGL, is a collection of type
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
- (home-page "http://jaspervdj.be/blaze")
+ (home-page "https://jaspervdj.be/blaze")
(synopsis "Fast markup combinator library for Haskell")
(description "This library provides core modules of a markup combinator
library for Haskell.")
(synopsis "Test interactive Haskell examples")
(description "The doctest program checks examples in source code comments.
It is modeled after doctest for Python, see
-@uref{http://docs.python.org/library/doctest.html, the Doctest website}.")
+@uref{https://docs.python.org/library/doctest.html, the Doctest website}.")
(license license:expat)))
(define-public ghc-doctest-0.12
(description "This package provides @code{Data.Scientific}, which provides
the number type @code{Scientific}. Scientific numbers are arbitrary precision
and space efficient. They are represented using
-@uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific
+@uref{https://en.wikipedia.org/wiki/Scientific_notation, scientific
notation}.")
(license license:bsd-3)))
building up, manipulating and serialising @code{Pandoc} structures.")
(license license:bsd-3)))
+(define-public ghc-pandoc-types-for-pandoc-1
+ (package (inherit ghc-pandoc-types)
+ (version "1.17.0.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "pandoc-types/pandoc-types-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1csipjdq00iiq77k2wlrg4i7afrzlh8nl585q785xzw7nn45b0n8"))))
+ (inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-aeson" ,ghc-aeson-for-pandoc-1)
+ ("ghc-string-qq" ,ghc-string-qq)))))
+
(define-public ghc-texmath
(package
(name "ghc-texmath")
it can parse and apply LaTeX macros.")
(license license:gpl2+)))
+(define-public ghc-texmath-for-pandoc-1
+ (package (inherit ghc-texmath)
+ (version "0.9.4.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "texmath/texmath-" version ".tar.gz"))
+ (sha256
+ (base32
+ "129q33m56diiv35kdwfb07838wrg0mm88kxdqxfyl1zvf9nzkqkd"))))
+ (inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-split" ,ghc-split)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-xml" ,ghc-xml)))))
+
(define-public ghc-regex-pcre-builtin
(package
(name "ghc-regex-pcre-builtin")
(description
"This package is an enhancement of the @code{Text.Regex} library,
providing the PCRE backend to accompany regex-base, with bundled code from
-@url{http://www.pcre.org}.")
+@url{https://www.pcre.org}.")
(license license:bsd-3)))
(define-public ghc-diff
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "http://hub.darcs.net/sterlingclover/Diff")
+ (home-page "https://hub.darcs.net/sterlingclover/Diff")
(synopsis "O(ND) diff algorithm in Haskell")
(description
"This package provides an implementation of the standard diff algorithm,
(description
"Highlighting-kate is a syntax highlighting library with support for
nearly one hundred languages. The syntax parsers are automatically generated
-from @uref{http://kate-editor.org/, Kate syntax descriptions}, so any syntax
+from @uref{https://kate-editor.org/, Kate syntax descriptions}, so any syntax
supported by Kate can be added. An (optional) command-line program is
provided, along with a utility for generating new parsers from Kate XML syntax
descriptions.")
"This package provides a library to parse and render YAML documents.")
(license license:bsd-3)))
+(define-public ghc-yaml-for-pandoc-1
+ (package (inherit ghc-yaml)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
+ ,@(alist-delete "ghc-aeson" (package-inputs ghc-yaml))))))
+
(define-public ghc-filemanip
(package
(name "ghc-filemanip")
(synopsis "Lua language interpreter embedding in Haskell")
(description
"The Scripting.Lua module is a wrapper of the Lua language interpreter as
-described in @url{http://www.lua.org/}.")
+described in @url{https://www.lua.org/}.")
(license license:expat)))
+(define-public ghc-hslua-for-pandoc-1
+ (package (inherit ghc-hslua)
+ (version "0.4.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hslua/hslua-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid"))))
+ (inputs
+ `(("lua" ,lua-5.1)
+ ("ghc-text" ,ghc-text)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-contrib" ,ghc-hspec-contrib)
+ ("ghc-hunit" ,ghc-hunit)
+ ("hspec-discover" ,hspec-discover)))))
+
(define-public ghc-hslua-module-text
(package
(name "ghc-hslua-module-text")
(sha256
(base32 "0jkca97zyv23yyilp3jydcrzxqhyk27swhzh82llvban5zp8b21y"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags (list "--allow-newer=QuickCheck")))
(inputs
`(("ghc-random" ,ghc-random)
("ghc-test-framework" ,ghc-test-framework)
provided. Skylighting is intended to be the successor to highlighting-kate.")
(license license:gpl2)))
+(define-public ghc-skylighting-for-pandoc-1
+ (package (inherit ghc-skylighting)
+ (version "0.1.1.5")
+ (source (origin
+ (method git-fetch)
+ ;; We take the sources from Github, because the tarball on
+ ;; hackage does not include the XML files.
+ (uri (git-reference
+ (url "https://github.com/jgm/skylighting.git")
+ (commit version)))
+ (file-name (string-append "ghc-skylighting-" version "-checkout"))
+ (sha256
+ (base32
+ "0z3yv8v2fqqgv6lsf0ff3ld0h2vkg97b2jiry9wn2f1rizwdqmzl"))))
+ (arguments
+ `(#:configure-flags '("-fbootstrap")
+ #:phases
+ (modify-phases %standard-phases
+ ;; After building the skylighting-extract tool we use it to generate
+ ;; syntax source files from the included XML files. These are then
+ ;; added to the skylighting.cabal file.
+ (add-after 'build 'extract-xml
+ (lambda _
+ (make-file-writable "skylighting.cabal")
+ (apply invoke "./dist/build/skylighting-extract/skylighting-extract"
+ (find-files "xml" "\\.xml$"))
+ #t))
+ ;; Reconfigure without bootstrap flag
+ (add-after 'extract-xml 'configure-again
+ (lambda* (#:key outputs inputs tests? #:allow-other-keys)
+ ((assoc-ref %standard-phases 'configure)
+ #:outputs outputs
+ #:inputs inputs
+ #:tests? tests?
+ #:configure-flags '("-f-bootstrap"))))
+ (add-after 'configure-again 'build-again
+ (assoc-ref %standard-phases 'build)))))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-diff" ,ghc-diff)
+ ("ghc-hxt" ,ghc-hxt)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-pretty-show" ,ghc-pretty-show)
+ ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-text" ,ghc-text)
+ ("ghc-utf8-string" ,ghc-utf8-string)))))
+
(define-public ghc-doctemplates
(package
(name "ghc-doctemplates")
"This package provides a simple text templating system used by pandoc.")
(license license:bsd-3)))
+(define-public ghc-doctemplates-for-pandoc-1
+ (package (inherit ghc-doctemplates)
+ (version "0.1.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "doctemplates/doctemplates-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0swal6rjya1293mwvl63jch5fx9ghpsil7qs4v7rpansa0izalmp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-text" ,ghc-text)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-scientific" ,ghc-scientific)))))
+
(define-public ghc-pandoc
(package
(name "ghc-pandoc")
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://pandoc.org")
+ (home-page "https://pandoc.org")
(synopsis "Conversion between markup formats")
(description
"Pandoc is a Haskell library for converting from one markup format to
provided for those who need a drop-in replacement for Markdown.pl.")
(license license:gpl2+)))
+;; This is the last version of Pandoc 1.x, which is preferred for Rmarkdown.
+(define-public ghc-pandoc-1
+ (package (inherit ghc-pandoc)
+ (version "1.19.2.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/pandoc/pandoc-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0mim429mpakrcnm50csxyqk3ljcx2l26r5grk6w9isnggwgqrq5v"))))
+ (arguments
+ `(#:configure-flags (list "--allow-newer=skylighting")))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson-for-pandoc-1)
+ ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-cmark" ,ghc-cmark)
+ ("ghc-data-default" ,ghc-data-default)
+ ("ghc-deepseq-generics" ,ghc-deepseq-generics)
+ ("ghc-diff" ,ghc-diff)
+ ("ghc-doctemplates" ,ghc-doctemplates-for-pandoc-1)
+ ("ghc-executable-path" ,ghc-executable-path)
+ ("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+ ("ghc-filemanip" ,ghc-filemanip)
+ ("ghc-haddock-library" ,ghc-haddock-library)
+ ("ghc-hslua" ,ghc-hslua-for-pandoc-1)
+ ("ghc-http" ,ghc-http)
+ ("ghc-http-client" ,ghc-http-client)
+ ("ghc-http-client-tls" ,ghc-http-client-tls)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-juicypixels" ,ghc-juicypixels)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-network" ,ghc-network)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-old-time" ,ghc-old-time)
+ ("ghc-pandoc-types" ,ghc-pandoc-types-for-pandoc-1)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-random" ,ghc-random)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-sha" ,ghc-sha)
+ ("ghc-skylighting" ,ghc-skylighting-for-pandoc-1)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-tagsoup" ,ghc-tagsoup)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-texmath" ,ghc-texmath-for-pandoc-1)
+ ("ghc-text" ,ghc-text)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-xml" ,ghc-xml)
+ ("ghc-yaml" ,ghc-yaml-for-pandoc-1)
+ ("ghc-zip-archive" ,ghc-zip-archive)
+ ("ghc-zlib" ,ghc-zlib)))
+ (native-inputs
+ `(("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))))
+
(define-public ghc-hs-bibutils
(package
(name "ghc-hs-bibutils")
(base32
"0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/rfc5051")
+ (home-page "https://hackage.haskell.org/package/rfc5051")
(synopsis "Simple unicode collation as per RFC5051")
(description
"This library implements @code{unicode-casemap}, the simple, non
(base32
"03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/data-ordlist")
+ (home-page "https://hackage.haskell.org/package/data-ordlist")
(synopsis "Set and bag operations on ordered lists")
(description
"This module provides set and multiset operations on ordered lists.")
(inputs
`(("ghc-regex-base" ,ghc-regex-base)
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
- (home-page "http://hub.darcs.net/shelarcy/regex-compat-tdfa")
+ (home-page "https://hub.darcs.net/shelarcy/regex-compat-tdfa")
(synopsis "Unicode Support version of Text.Regex, using regex-tdfa")
(description
"One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-th" ,ghc-tasty-th)))
- (home-page "http://hackage.haskell.org/package/sandi")
+ (home-page "https://hackage.haskell.org/package/sandi")
(synopsis "Data encoding library")
(description "Reasonably fast data encoding library.")
(license license:bsd-3)))
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
- (home-page "http://hub.darcs.net/ganesh/bytestring-handle")
+ (home-page "https://hub.darcs.net/ganesh/bytestring-handle")
(synopsis "ByteString-backed Handles")
(description "ByteString-backed Handles") ; There is no description
(license license:bsd-3)))
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-array" ,ghc-array)))
- (home-page "http://hackage.haskell.org/package/tar")
+ (home-page "https://hackage.haskell.org/package/tar")
(synopsis "Reading, writing and manipulating \".tar\" archive files")
(description
"This library is for working with \\\"@.tar@\\\" archive files.
(base32
"1qkhi8ssf8c4jnmrw9dzym3igqbzq7h48iisaykdfzdsm09qfh3c"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/transformers")
+ (home-page "https://hackage.haskell.org/package/transformers")
(synopsis "Concrete functor and monad transformers")
(description
"A portable library of functor and monad transformers, inspired by the paper
(base32
"0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/patience")
+ (home-page "https://hackage.haskell.org/package/patience")
(synopsis "Patience diff and longest increasing subsequence")
(description
"This library implements the 'patience diff' algorithm, as well as the
(base32
"1wdhskwa6dw8qljbvwpyxj8ca6y95q2np7z4y4q6bpf4anmd5794"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/monads-tf")
+ (home-page "https://hackage.haskell.org/package/monads-tf")
(synopsis "Monad classes, using type families")
(description
"Monad classes using type families, with instances for various monad transformers,
(base32
"1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd"))))
(build-system haskell-build-system)
- (home-page "http://www.haskell.org/haskellwiki/Colour")
+ (home-page "https://www.haskell.org/haskellwiki/Colour")
(synopsis "Model for human colour perception")
(description
"This package provides a data type for colours and transparency.
(base32
"0ffhanigxrx5wpin8l0wfp7d24lpgsjwj0hxrfp8bpy2wj1snxny"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/directory")
+ (home-page "https://hackage.haskell.org/package/directory")
(synopsis "Platform-agnostic library for file system operations")
(description
"This library provides a basic set of operations for manipulating
(substitute* "System/Process/Posix.hs"
(("/bin/sh") (which "sh")))
#t)))))
- (home-page "http://hackage.haskell.org/package/process")
+ (home-page "https://hackage.haskell.org/package/process")
(synopsis "System process libraries")
(description
"This package contains libraries for dealing with system processes.")
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)))
- (home-page "http://hackage.haskell.org/package/wl-pprint-text")
+ (home-page "https://hackage.haskell.org/package/wl-pprint-text")
(synopsis "Wadler/Leijen Pretty Printer for Text values")
(description
"A clone of wl-pprint for use with the text library.")
`(("ghc-fgl" ,ghc-fgl)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)))
- (home-page "http://hackage.haskell.org/package/fgl-arbitrary")
+ (home-page "https://hackage.haskell.org/package/fgl-arbitrary")
(synopsis "QuickCheck support for fgl")
(description
"Provides Arbitrary instances for fgl graphs to avoid adding a
(synopsis "Bindings to Graphviz for graph visualisation")
(description
"This library provides bindings for the Dot language used by
-the @uref{http://graphviz.org/, Graphviz} suite of programs for
+the @uref{https://graphviz.org/, Graphviz} suite of programs for
visualising graphs, as well as functions to call those programs.
Main features of the graphviz library include:
"12v83s2imxb3p2crnlzrpjh0nk6lpysw9bdk9yahs6f37csa5jaj"))))
(build-system haskell-build-system)
(home-page
- "http://hackage.haskell.org/package/array")
+ "https://hackage.haskell.org/package/array")
(synopsis "Mutable and immutable arrays")
(description
"In addition to providing the @code{Data.Array} module, this package also defines
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/storable-complex/storable-complex-"
+ "https://hackage.haskell.org/package/storable-complex/storable-complex-"
version ".tar.gz"))
(sha256
(base32 "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb"))))
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/hmatrix/hmatrix-"
+ "https://hackage.haskell.org/package/hmatrix/hmatrix-"
version ".tar.gz"))
(sha256
(base32 "07zkwvg872hfk6jyn4s54ws8mvclynazaxf7fsbqi16dmf9dn61c"))))
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-"
+ "https://hackage.haskell.org/package/hmatrix-gsl/hmatrix-gsl-"
version ".tar.gz"))
(sha256
(base32 "0mflm7zg6c6a5vy092pa429rzpyv5drc1589r3x4fbmvcyqc79gx"))))
(method url-fetch)
(uri
(string-append
- "http://hackage.haskell.org/package/hmatrix-special/hmatrix-special-"
+ "https://hackage.haskell.org/package/hmatrix-special/hmatrix-special-"
version ".tar.gz"))
(sha256
(base32 "0kpcqdchi7ikzhqacy4rh4dxz3v37paxyb84wqa66sysb72wkabj"))))
(method url-fetch)
(uri
(string-append
- "http://hackage.haskell.org/package/hmatrix-gsl-stats/hmatrix-gsl-stats-"
+ "https://hackage.haskell.org/package/hmatrix-gsl-stats/hmatrix-gsl-stats-"
version ".tar.gz"))
(sha256
(base32 "1gslgk58lzin43cvbpivhw7nrn9qyaa6qwhy1z9ypvyal5p8n3sa"))))
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/easyplot/easyplot-"
+ "https://hackage.haskell.org/package/easyplot/easyplot-"
version ".tar.gz"))
(sha256
(base32 "18kndgvdj2apjpfga6fp7m16y1gx8zrwp3c5vfj03sx4v6jvciqk"))))
`(#:phases (modify-phases %standard-phases
(add-after 'unpack 'fix-setup-suffix
(lambda _ (rename-file "Setup.lhs" "Setup.hs") #t)))))
- (home-page "http://hub.darcs.net/scravy/easyplot")
+ (home-page "https://hub.darcs.net/scravy/easyplot")
(synopsis "Haskell plotting library based on gnuplot")
(description "This package provides a plotting library for
Haskell, using gnuplot for rendering.")
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/hashtables/hashtables-"
+ "https://hackage.haskell.org/package/hashtables/hashtables-"
version ".tar.gz"))
(sha256
(base32 "1b6w9xznk42732vpd8ili60k12yq190xnajgga0iwbdpyg424lgg"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags (list "--allow-newer=vector")))
(inputs
`(("ghc-hashable" ,ghc-hashable)
("ghc-primitive" ,ghc-primitive)
(sha256
(base32 "1vf2g1gac3rm32g97rl0fll51m88q7ry4m6khnl5j47qsmx24r9l"))))
(build-system haskell-build-system)
- (home-page "http://www.haskell.org/haskellwiki/Record_access")
+ (home-page "https://www.haskell.org/haskellwiki/Record_access")
(synopsis
"Haskell utilities for accessing and manipulating fields of records")
(description "This package provides Haskell modules for accessing and
(base32 "0yp030vafbpddl27m606aibbbr5ar5j5bsv4bksscz3cq4yq5j10"))))
(build-system haskell-build-system)
(inputs `(("ghc-data-accessor" ,ghc-data-accessor)))
- (home-page "http://www.haskell.org/haskellwiki/Record_access")
+ (home-page "https://www.haskell.org/haskellwiki/Record_access")
(synopsis "Use Accessor to access state in transformers State monad")
(description "This package provides Haskell modules to allow use of
Accessor to access state in transformers State monad.")
(substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
(("(gnuplotName = ).*$" all cmd)
(string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
- (home-page "http://www.haskell.org/haskellwiki/Gnuplot")
+ (home-page "https://www.haskell.org/haskellwiki/Gnuplot")
(synopsis "2D and 3D plots using gnuplot")
(description "This package provides a Haskell module for creating 2D and
3D plots using gnuplot.")
(base32
"0n4nvj3dbj9gxfnprgish45asn9z4dipv9j98s8i7g2n8yb3xhmm"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/terminal-size")
+ (home-page "https://hackage.haskell.org/package/terminal-size")
(synopsis "Get terminal window height and width")
(description "Get terminal window height and width without ncurses
dependency.")
(native-inputs
`(("ghc-happy" ,ghc-happy)
("ghc-alex" ,ghc-alex)))
- (home-page "http://visq.github.io/language-c/")
+ (home-page "https://visq.github.io/language-c/")
(synopsis "Analysis and generation of C code")
(description
"Language C is a Haskell library for the analysis and generation of C code.
(inputs
`(("ghc-mtl" ,ghc-mtl)
("ghc-network" ,ghc-network)
- ("ghc-directory", ghc-directory)
+ ("ghc-directory" ,ghc-directory)
("ghc-old-locale" ,ghc-old-locale)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
- (home-page "http://software.complete.org/hslogger")
+ (home-page "https://software.complete.org/hslogger")
(synopsis "Logging framework for Haskell, similar to Python's logging module")
(description "Hslogger lets each log message have a priority and source be
associated with it. The programmer can then define global handlers that route
("ghc-mtl" ,ghc-mtl)
("ghc-text" ,ghc-text)
("ghc-parsec" ,ghc-parsec)))
- (home-page "http://hackage.haskell.org/package/json")
+ (home-page "https://hackage.haskell.org/package/json")
(synopsis "Serializes Haskell data to and from JSON")
(description "This package provides a parser and pretty printer for
converting between Haskell values and JSON.
(base32
"1v31xiaivrrn0q2jz8919wvkjplv1kxna5ajhsj701fqxm1i5vhj"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/hex")
+ (home-page "https://hackage.haskell.org/package/hex")
(synopsis "Convert strings into hexadecimal and back")
(description "This package provides conversion functions between
bytestrings and their hexademical representation.")
(home-page "https://github.com/bttr/psqueues")
(synopsis "Pure priority search queues")
(description "The psqueues package provides
-@uref{http://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in
+@uref{https://en.wikipedia.org/wiki/Priority_queue, Priority Search Queues} in
three different flavors:
@itemize
Hinze's @uref{http://citeseer.ist.psu.edu/hinze01simple.html, A Simple
Implementation Technique for Priority Search Queues}.
-Hence, it is similar to the @uref{http://hackage.haskell.org/package/PSQueue,
+Hence, it is similar to the @uref{https://hackage.haskell.org/package/PSQueue,
PSQueue} library, although it is considerably faster and provides a slightly
different API.
@item @code{IntPSQ p v} is a far more efficient implementation. It fixes the
key type to @code{Int} and uses a
-@code{http://en.wikipedia.org/wiki/Radix_tree, radix tree} (like @code{IntMap})
+@code{https://en.wikipedia.org/wiki/Radix_tree, radix tree} (like @code{IntMap})
with an additional min-heap property.
@item @code{HashPSQ k p v} is a fairly straightforward extension
@itemize
@item Simple, single-ended, non-concurrent, bounded queues
-@item Double-ended, threadsafe, growable queues with important points
-inbetween (such as the queues used for work-stealing).
+@item Double-ended, thread-safe, growable queues with important points
+in between (such as the queues used for work stealing).
@end itemize
This package includes an interface for Deques that allows the programmer
-to use a single API for all of the above, while using the type-system to
+to use a single API for all of the above, while using the type system to
select an efficient implementation given the requirements (using type families).
This package also includes a simple reference implementation based on
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-ieee754", ghc-ieee754)
+ ("ghc-ieee754" ,ghc-ieee754)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(build-system haskell-build-system)
(inputs `(("ghc-tuple-th" ,ghc-tuple-th)
("ghc-contravariant" ,ghc-contravariant)
- ("ghc-base-prelude",ghc-base-prelude)))
+ ("ghc-base-prelude" ,ghc-base-prelude)))
(home-page "https://github.com/nikita-volkov/contravariant-extras")
(synopsis "Extras for the @code{ghc-contravariant} Haskell package")
(description "This Haskell package provides extras for the
(synopsis "Haskell type definitions for UUIDs")
(description "This Haskell library contains type definitions for
@dfn{Universally Unique Identifiers} or
-@uref{http://en.wikipedia.org/wiki/UUID, UUIDs}, and basic conversion
+@uref{https://en.wikipedia.org/wiki/UUID, UUIDs}, and basic conversion
functions.")
(license license:bsd-3)))
(base32
"09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags (list "--allow-newer=QuickCheck")))
(inputs `(("ghc-cryptohash-sha1" ,ghc-cryptohash-sha1)
("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
("ghc-entropy" ,ghc-entropy)
("ghc-vector-algorithms" ,ghc-vector-algorithms)
("ghc-split" ,ghc-split)))
(native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-hunit",ghc-hunit)
+ ("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-semigroups" ,ghc-semigroups)
("ghc-foldl" ,ghc-foldl)))