;;; 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 © 2018, 2019 Gabriel Hondet <gabrielhondet@gmail.com>
;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
;;; Copyright © 2019 Jacob MacDonald <jaccarmac@gmail.com>
-;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
-;;; Copyright © 2019 Kyle Meyer <kyle@kyleam.com>
+;;; Copyright © 2019,2020 John Soo <jsoo1@asu.edu>
+;;; Copyright © 2019, 2020 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>
#:use-module (gnu packages base)
#:use-module (gnu packages compression)
#:use-module (gnu packages emacs)
- #:use-module (gnu packages gcc)
#:use-module (gnu packages gl)
#:use-module (gnu packages graphviz)
#:use-module (gnu packages gtk)
+ #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-apps)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
#:use-module (guix git-download)
#:use-module (guix utils)
#:use-module ((guix licenses) #:prefix license:)
- #:use-module (guix packages))
+ #:use-module (guix packages)
+ #:use-module (srfi srfi-1))
(define-public ghc-abstract-deque
(package
(base32
"1avh4a419h9d2zsslg6j8hm87ppgsgqafz8ll037rk2yy1g4jl7b"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("alsa-lib")))
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
("alsa-lib" ,alsa-lib)))
(native-inputs
`(("pkg-config" ,pkg-config)))
- (home-page "http://www.haskell.org/haskellwiki/ALSA")
+ (home-page "https://wiki.haskell.org/ALSA")
(synopsis "Binding to the ALSA Library API (Exceptions)")
(description "This package provides access to ALSA infrastructure, that is
needed by both alsa-seq and alsa-pcm.")
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")
permissions while atomically writing to a file.")
(license license:expat)))
+(define-public ghc-atomic-write-0.2.0.7
+ (package
+ (inherit ghc-atomic-write)
+ (version "0.2.0.7")
+ (source
+ (origin
+ (inherit (package-source ghc-atomic-write))
+ (uri (string-append
+ "https://hackage.haskell.org/package/atomic-write/atomic-write-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm"))))))
+
(define-public ghc-attoparsec
(package
(name "ghc-attoparsec")
(base32
"0hgvlqcr852hfp52jp99snhbj550mvxxpi8qn15d8ml9aqhyl2lr"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
(base32
"0srlws74yiraqaapgcjd9p5d1fwb3zr9swcz74jpjm55fls2nn37"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(home-page "https://github.com/haskell-foundation/foundation")
(synopsis "Basic primitives for Foundation starter pack")
(description
(base32
"1zk728sd09hh2r4xwz4lazsrrgg5cshydn64932sm0vckplndk73"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(home-page "https://github.com/nikita-volkov/base-prelude")
(synopsis "The most complete prelude formed solely from the Haskell's base
package")
(base32
"1ia6li7qjg1zkak4gf6mnbshw45mq9bfjr0jch58ds0lscmvwyzf"))))
(build-system haskell-build-system)
- (home-page "http://www.haskell.org/haskellwiki/Unicode-symbols")
+ (home-page "https://wiki.haskell.org/Unicode-symbols")
(synopsis "Unicode alternatives for common functions and operators")
(description "This package defines new symbols for a number of functions,
operators and types in the base package. All symbols are documented with
∀ 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")
`(("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-hunit" ,ghc-hunit)
- ("ghc-shelly" ,ghc-shelly)
- ("gcc" ,gcc)))
+ ("ghc-shelly" ,ghc-shelly)))
(arguments
- `(;; XXX: Test failures are induced by a parse error in <bits/floatn.h>
- ;; of glibc 2.28.
- #:tests? #f
-
- #:phases
+ `(#:phases
(modify-phases %standard-phases
(add-before 'check 'set-cc
;; add a cc executable in the path, needed for some tests to pass
(package
(name "ghc-case-insensitive")
(version "1.2.0.11")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
the resulting type will be insensitive to cases.")
(license license:bsd-3)))
+(define-public ghc-cborg
+ (package
+ (name "ghc-cborg")
+ (version "0.2.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/cborg/cborg-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1rdnvy0w17s70ikmbyrnwax5rvqh19l95sh8i7ipgxi23z1r0bp1"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-half" ,ghc-half)
+ ("ghc-primitive" ,ghc-primitive)))
+ (native-inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "http://hackage.haskell.org/package/cborg")
+ (synopsis "Concise Binary Object Representation")
+ (description
+ "This package (formerly binary-serialise-cbor) provides an
+efficient implementation of the Concise Binary Object
+Representation (CBOR), as specified by RFC 7049 at
+https://tools.ietf.org/html/rfc7049.
+
+If you are looking for a library for serialisation of Haskell values, have a
+look at the @url{https://hackage.haskell.org/package/serialise} package, which
+is built upon this library.
+
+An implementation of the standard bijection between CBOR and JSON is provided
+by the @url{https://hackage.haskell.org/package/cborg-json} package.
+
+Also see @code{https://hackage.haskell.org/package/cbor-tool} for a convenient
+command-line utility for working with CBOR data.")
+ (license license:bsd-3)))
+
+(define-public ghc-cborg-json
+ (package
+ (name "ghc-cborg-json")
+ (version "0.2.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/cborg-json/cborg-json-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0ysilz7rrjk94sqr3a61s98hr9qfi1xg13bskmlpc6mpgi2s4s5b"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-aeson-pretty" ,ghc-aeson-pretty)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-cborg" ,ghc-cborg)))
+ (home-page "https://github.com/well-typed/cborg")
+ (synopsis "A library for encoding JSON as CBOR")
+ (description
+ "This package implements the bijection between JSON and CBOR
+defined in the CBOR specification, RFC 7049.")
+ (license license:bsd-3)))
+
(define-public ghc-cereal
(package
(name "ghc-cereal")
(base32
"0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(home-page
"http://community.haskell.org/~ndm/cmdargs/")
(synopsis "Command line argument processing")
;; ghc-test-framework -> ghc-ansi-terminal -> ghc-colour.
`(#:tests? #f))
(build-system haskell-build-system)
- (home-page "https://www.haskell.org/haskellwiki/Colour")
+ (home-page "https://wiki.haskell.org/Colour")
(synopsis "Model for human colour perception")
(description
"This package provides a data type for colours and transparency.
(base32
"18izjgff4pmrknc8py06yvg3g6x27nx0rzmlwjxcflwm5v4szpw4"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-exceptions" ,ghc-exceptions)
("ghc-lifted-base" ,ghc-lifted-base)
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "http://github.com/bos/configurator")
+ (home-page "https://github.com/bos/configurator")
(synopsis "Configuration management")
(description
"This package provides a configuration management library for programs
(sha256
(base32 "1fq4gygxbz0bd0mzgvc1sl3m4gjnsv8nbgpnmdpa29zj5lb9agxc"))))
(build-system haskell-build-system)
- (home-page "https://www.haskell.org/haskellwiki/Record_access")
+ (home-page "https://wiki.haskell.org/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 "https://www.haskell.org/haskellwiki/Record_access")
+ (home-page "https://wiki.haskell.org/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.")
package.")
(license license:bsd-3)))
+(define-public ghc-data-fix
+ (package
+ (name "ghc-data-fix")
+ (version "0.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/data-fix/"
+ "data-fix-" version ".tar.gz"))
+ (sha256
+ (base32 "14hk6hq5hdb3l5bhmzhw086jpzlvp9qbw9dzw30wlz5jbh2ihmvy"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/spell-music/data-fix")
+ (synopsis "Fixpoint data types")
+ (description
+ "Fixpoint types and recursion schemes. If you define your AST as
+fixpoint type, you get fold and unfold operations for free.
+
+Thanks for contribution to: Matej Kollar, Herbert Valerio Riedel")
+ (license license:bsd-3)))
+
(define-public ghc-data-hash
(package
(name "ghc-data-hash")
(define-public ghc-distributive
(package
(name "ghc-distributive")
- (version "0.6.1")
+ (version "0.6.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1wnayzzb4vk8rhh9gzhdpd9f64366k4vmbhximavmqqmp3cv2jbp"))))
+ "1j93zkfffm6s16kgr0j0z87y5ds28rw0r2gyc5ncwcylvrqy4kl2"))))
(build-system haskell-build-system)
(inputs
`(("ghc-tagged" ,ghc-tagged)
@uref{https://docs.python.org/library/doctest.html, the Doctest website}.")
(license license:expat)))
+(define-public ghc-dotgen
+ (package
+ (name "ghc-dotgen")
+ (version "0.4.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/dotgen/dotgen-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "148q93qsmqgr5pzdwvpjqfd6bdm1pwzcp2rblfwswx2x8c5f43fg"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/ku-fpg/dotgen")
+ (synopsis
+ "Simple interface for building .dot graph files")
+ (description
+ "This package provides a simple interface for building .dot graph
+files, for input into the dot and graphviz tools. It includes a
+monadic interface for building graphs.")
+ (license license:bsd-3)))
+
(define-public ghc-double-conversion
(package
(name "ghc-double-conversion")
(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.
(package
(name "ghc-fgl")
(version "5.7.0.1")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(base32
"19qjmzc7gaxfwgqbgy0kq4vhbxvh3qjnwsxnc7pzwws2if5bv80b"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
("ghc-primitive" ,ghc-primitive)
("ghc-vector" ,ghc-vector)
(substitute* "tests/Test/Foundation/Number.hs"
((", testDividible proxy") ""))
#t)))))
+ (outputs '("out" "static" "doc"))
(inputs `(("ghc-basement" ,ghc-basement)))
(home-page "https://github.com/haskell-foundation/foundation")
(synopsis "Alternative prelude with batteries and no dependencies")
(base32
"0vlf3f2ckl3cr7z2zl8c9c8qkdlfgvmh04gxkp2fg0z9dz80nlyb"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-prelude-extras" ,ghc-prelude-extras)
("ghc-profunctors" ,ghc-profunctors)
(base32
"0vdg9qdq35jl3m11a87wk8cq1y71qm4i1g1b2pxki0wk70yw20a4"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-th-abstraction" ,ghc-th-abstraction)))
(native-inputs
deriving mechanism in Haskell to arbitrary classes.")
(license license:bsd-3)))
+(define-public ghc-generic-random
+ (package
+ (name "ghc-generic-random")
+ (version "1.2.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/generic-random/"
+ "generic-random-" version ".tar.gz"))
+ (sha256
+ (base32 "130lmblycxnpqbsl7vf6a90zccibnvcb5zaclfajcn3by39007lv"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (native-inputs
+ `(("ghc-inspection-testing" ,ghc-inspection-testing)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1d0hx41r7yq2a86ydnfh2fv540ah8cz05l071s2z4wxcjw0ymyn4")))
+ (home-page
+ "https://github.com/lysxia/generic-random")
+ (synopsis
+ "Generic random generators for QuickCheck")
+ (description
+ "Derive instances of @code{Arbitrary} for QuickCheck, with various options
+to customize implementations.
+
+Automating the arbitrary boilerplate also ensures that when a type changes to
+have more or fewer constructors, then the generator either fixes itself to
+generate that new case (when using the uniform distribution) or causes a
+compilation error so you remember to fix it (when using an explicit
+distribution).
+
+This package also offers a simple (optional) strategy to ensure termination
+for recursive types: make @code{Test.QuickCheck.Gen}'s size parameter decrease
+at every recursive call; when it reaches zero, sample directly from a
+trivially terminating generator given explicitly (@code{genericArbitraryRec}
+and @code{withBaseCase}) or implicitly (@code{genericArbitrary'}).")
+ (license license:expat)))
+
+(define-public ghc-generic-random-1.3.0.1
+ (package
+ (inherit ghc-generic-random)
+ (version "1.3.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/generic-random/"
+ "generic-random-" version ".tar.gz"))
+ (sha256
+ (base32 "0d9w7xcmsb31b95fr9d5jwbsajcl1yi4347dlbw4bybil2vjwd7k"))))
+ (arguments '())))
+
(define-public ghc-generics-sop
(package
(name "ghc-generics-sop")
(base32
"160knr2phnzh2gldfv954lz029jzc7y8kz5xpmbf4z3vb5ngm6fw"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-sop-core" ,ghc-sop-core)
("ghc-transformers-compat" ,ghc-transformers-compat)))
(build-system haskell-build-system)
(inputs
`(("ghc-openglraw" ,ghc-openglraw)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/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-opengl" ,ghc-opengl)
("ghc-openglraw" ,ghc-openglraw)
("freeglut" ,freeglut)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/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
(substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
(("(gnuplotName = ).*$" all cmd)
(string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
- (home-page "https://www.haskell.org/haskellwiki/Gnuplot")
+ (home-page "https://wiki.haskell.org/Gnuplot")
(synopsis "2D and 3D plots using gnuplot")
(description "This package provides a Haskell module for creating 2D and
3D plots using gnuplot.")
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/haskell/haddock.git")
+ (url "https://github.com/haskell/haddock")
(commit (string-append "haddock-" version "-release"))))
(file-name (git-file-name name version))
(sha256
(inputs
`(("ghc-syb" ,ghc-syb)
("ghc-xml" ,ghc-xml)))
- (home-page "http://www.haskell.org/haddock/")
+ (home-page "https://www.haskell.org/haddock/")
(synopsis "Test utilities for Haddock")
(description "This package provides test utilities for Haddock.")
(license license:bsd-3)
(package
(name "ghc-hashable")
(version "1.2.7.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
a set of wrappers to use the hash tables in the IO monad.")
(license license:bsd-3)))
+(define-public ghc-haskeline-0.8
+ (package
+ (name "ghc-haskeline")
+ (version "0.8.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haskeline/haskeline-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0gqsa5s0drim9m42hv4wrq61mnvcdylxysfxfw3acncwilfrn9pb"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-exceptions" ,ghc-exceptions)))
+ (native-inputs `(("ghc-hunit" ,ghc-hunit)))
+ ;; FIXME: Tests failing
+ (arguments `(#:tests? #f))
+ (home-page "https://github.com/judah/haskeline")
+ (synopsis
+ "Command-line interface for user input, written in Haskell")
+ (description
+ "Haskeline provides a user interface for line input in command-line
+programs. This library is similar in purpose to readline, but since it is
+written in Haskell it is (hopefully) more easily used in other Haskell
+programs.
+
+Haskeline runs both on POSIX-compatible systems and on Windows.")
+ (license license:bsd-3)))
+
(define-public ghc-haskell-lexer
(package
(name "ghc-haskell-lexer")
(base32
"0q1y8n3d82gid9bcx8wxsqqmj9mq11fg3gp5yzpfbw958dhi3j9f"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("cpphs" ,cpphs)
("ghc-happy" ,ghc-happy)
("ghc-utf8-string" ,ghc-utf8-string)
("ghc-microlens-platform" ,ghc-microlens-platform)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://github.com/MarcWeber/hasktags")
+ (home-page "https://github.com/MarcWeber/hasktags")
(synopsis "Make @code{Ctags} and @code{Etags} files for Haskell programs")
(description
"This package provides a means of generating tag files for Emacs and
(sha256
(base32 "1sqy1aci5zfagkb34mz3xdil7cl96z4b4cx28cha54vc5sx1lhpg"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("lapack")))
(inputs
`(("ghc-random" ,ghc-random)
("ghc-split" ,ghc-split)
(sha256
(base32 "0v6dla426x4ywaq59jm89ql1i42n39iw6z0j378xwb676v9kfxhm"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("gsl")))
(inputs
`(("ghc-hmatrix" ,ghc-hmatrix)
("ghc-vector" ,ghc-vector)
"183bgl5jcx5y2r94lviqfw0a5w9089nxjd1z40k8vx9y2h60pm6j"))))
(build-system haskell-build-system)
(arguments
- `(#:configure-flags '("-fsystem-lua")))
+ `(#:configure-flags '("-fsystem-lua")
+ #:extra-directories ("lua")))
(inputs
`(("lua" ,lua)
("ghc-exceptions" ,ghc-exceptions)
(sha256
(base32 "0khmfwql4vwj55idsxmhjhrbqzfir3g9wm5lmpvnf77mm95cfpdz"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("wireless-tools")))
(inputs
`(("wireless-tools" ,wireless-tools)))
(home-page "https://github.com/jaor/iwlib")
(base32
"0qacrnz2qcykj3f6c4k2p8qd31pa2slpv3ykfblgizrfh3401q6x"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-zlib" ,ghc-zlib)
("ghc-vector" ,ghc-vector)
(base32
"1gpkc53l2cggnfrgg5k4ih82rycjbdvpj9pnbi5cq8ms0dbvs4a7"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-base-orphans" ,ghc-base-orphans)
("ghc-bifunctors" ,ghc-bifunctors)
indexed variants.")
(license license:bsd-3)))
+(define-public ghc-lens-family-core
+ (package
+ (name "ghc-lens-family-core")
+ (version "1.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/lens-family-core/lens-family-core-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "009rf10pj1cb50v44cc1pq7qvfrmkkk9dikahs9qmvbvgl3mykwi"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/lens-family-core")
+ (synopsis "Haskell 98 Lens Families")
+ (description
+ "This package provides first class functional references. In addition to
+the usual operations of getting, setting and composition, plus integration
+with the state monad, lens families provide some unique features:
+
+@itemize
+@item Polymorphic updating
+@item Traversals
+@item Cast projection functions to read-only lenses
+@item Cast @code{toList} functions to read-only traversals
+@item Cast semantic editor combinators to modify-only traversals
+@end itemize
+
+For optimal first-class support use the lens-family package with rank 2/rank N
+polymorphism. @code{Lens.Family.Clone} allows for first-class support of
+lenses and traversals for those who require Haskell 98.")
+ (license license:bsd-3)))
+
(define-public ghc-libffi
(package
(name "ghc-libffi")
(base32
"12gsh994pr13bsybwlravmi21la66dyw74pk74yfw2pnz682wv10"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc")) ; documentation is 39M
(native-inputs
`(("ghc-alex" ,ghc-alex)
("ghc-happy" ,ghc-happy)))
#t))))
(build-system haskell-build-system)
(arguments
- `(#:configure-flags `("--flags=system-libyaml")))
+ `(#:configure-flags `("--flags=system-libyaml")
+ #:extra-directories ("libyaml")))
(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
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://github.com/ekmett/linear/")
+ (home-page "https://github.com/ekmett/linear/")
(synopsis "Linear algebra library for Haskell")
(description
"This package provides types and combinators for linear algebra on free
than its name.")
(license license:bsd-3)))
+(define-public ghc-managed
+ (package
+ (name "ghc-managed")
+ (version "1.0.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/managed/managed-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1kbrw99yh5x5blykmx2n88mplbbi4ss1ij5j17b7asw6q0ihm9zi"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/managed")
+ (synopsis "Monad for managed values")
+ (description
+ "In Haskell you very often acquire values using the with... idiom using
+functions of type (a -> IO r) -> IO r. This idiom forms a Monad, which is a
+special case of the ContT monad (from transformers) or the Codensity
+monad (from kan-extensions). The main purpose behind this package is to
+provide a restricted form of these monads specialized to this unusually common
+case.
+
+The reason this package defines a specialized version of these types
+is to:
+
+@itemize
+@item be more beginner-friendly,
+@item simplify inferred types and error messages, and:
+@item provide some additional type class instances that would otherwise be
+orphan instances
+@end itemize")
+ (license license:bsd-3)))
+
(define-public ghc-markdown-unlit
(package
(name "ghc-markdown-unlit")
`(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)))
- (home-page "https://software.complete.org/missingh")
+ ;; ‘Official’ <http://software.complete.org/missingh> redirects to a 404.
+ (home-page "https://github.com/haskell-hvr/missingh")
(synopsis "Large utility library")
(description
"MissingH is a library of all sorts of utility functions for Haskell
(base32
"1bqy982lpdb83lacfy76n8kqw5bvd31avxj25kg8gkgycdh0g0ma"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-hashable" ,ghc-hashable)
("ghc-vector" ,ghc-vector)
\"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")
"0gsyyaqyh5r9zc0rhwpj5spyd6i4w2vj61h4nihgmmh0yyqvf3z5"))))
(build-system haskell-build-system)
(arguments
- '(#:phases
+ '(#:extra-directories ("ncurses")
+ #:phases
(modify-phases %standard-phases
(add-before 'build 'fix-includes
(lambda _
(package
(name "ghc-network")
(version "2.8.0.1")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(package
(name "ghc-network-uri")
(version "2.6.1.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://github.com/sjakobi/newtype-generics")
+ (home-page "https://github.com/sjakobi/newtype-generics")
(synopsis "Typeclass and set of functions for working with newtypes")
(description "The @code{Newtype} typeclass represents the packing and
unpacking of a newtype, and allows you to operate under that newtype with
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")
("ghc-gluraw" ,ghc-gluraw)
("ghc-statevar" ,ghc-statevar)
("ghc-openglraw" ,ghc-openglraw)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/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,
(base32
"0zgllb4bcash2i2cispa3j565aw3dpxs41ghmhpvyvi4a6xmyldx"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("glu")))
(inputs
`(("ghc-half" ,ghc-half)
("ghc-fixed" ,ghc-fixed)
("glu" ,glu)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/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
DSLs, etc.")
(license license:bsd-3)))
+(define-public ghc-optional-args
+ (package
+ (name "ghc-optional-args")
+ (version "1.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/optional-args/optional-args-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1r5hhn6xvc01grggxdyy48daibwzi0aikgidq0ahpa6bfynm8d1f"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/optional-args")
+ (synopsis "Optional function arguments")
+ (description
+ "This library provides a type for specifying @code{Optional} function
+arguments.")
+ (license license:bsd-3)))
+
(define-public ghc-options
(package
(name "ghc-options")
(base32
"0dpjrr40h54cljzhvixyym07z792a9izg6b9dmqpjlgcg4rj0xx8"))))
(build-system haskell-build-system)
- (inputs
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'find-library
+ (lambda _
+ (substitute* "test/Tests/Command.hs"
+ (("= dynlibEnv")
+ (format #f "= [(\"LD_LIBRARY_PATH\" , \"~a/dist/build\")]"
+ (getcwd))))
+ #t)))))
+ (outputs '("out" "static" "doc"))
+ (inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-aeson-pretty" ,ghc-aeson-pretty)
("ghc-base64-bytestring" ,ghc-base64-bytestring)
provided for those who need a drop-in replacement for Markdown.pl.")
(license license:gpl2+)))
+(define-public pandoc
+ (package
+ (inherit ghc-pandoc)
+ (name "pandoc")
+ (arguments
+ `(#:configure-flags
+ (list "-fstatic"
+ ;; Do not build trypandoc; this is the default but it's better to
+ ;; be explicit.
+ "-f-trypandoc"
+ ;; TODO: Without these we cannot link the Haskell libraries
+ ;; statically. It would be nice if we could also build the
+ ;; shared libraries.
+ "--disable-shared"
+ "--disable-executable-dynamic"
+ ;; That's where we place all static libraries
+ "--extra-lib-dirs=static-libs/"
+ "--ghc-option=-static")
+ #:modules ((guix build haskell-build-system)
+ (guix build utils)
+ (ice-9 match)
+ (srfi srfi-1))
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'create-simple-paths-module
+ (lambda* (#:key outputs #:allow-other-keys)
+ (call-with-output-file "Paths_pandoc.hs"
+ (lambda (port)
+ (format port "\
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE NoRebindableSyntax #-}
+{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
+module Paths_pandoc (version,getDataDir,getDataFileName) where
+import Prelude
+import Data.Version (Version(..))
+import System.Info
+version :: Version
+version = Version [~a] []
+
+datadir :: FilePath
+datadir = \"~a/share/\" ++
+ arch ++ \"-\" ++
+ os ++ \"-\" ++
+ compilerName ++ \"-~a/pandoc-~a\"
+
+getDataDir :: IO FilePath
+getDataDir = return datadir
+
+getDataFileName :: FilePath -> IO FilePath
+getDataFileName name = do
+ dir <- getDataDir
+ return (dir ++ \"/\" ++ name)
+"
+ (string-map (lambda (chr) (if (eq? chr #\.) #\, chr))
+ ,(package-version ghc-pandoc))
+ (assoc-ref outputs "out")
+ ,(package-version ghc)
+ ,(package-version ghc-pandoc))))
+ #t))
+ (add-after 'unpack 'prepare-static-libraries
+ (lambda* (#:key inputs #:allow-other-keys)
+ (mkdir-p (string-append (getcwd) "/static-libs"))
+ (for-each
+ (lambda (input)
+ (when (or (string-prefix? "static-" (car input))
+ (string-prefix? "ghc" (car input)))
+ (match (find-files (cdr input) "\\.a$")
+ ((and (first . rest) libs)
+ (for-each (lambda (lib)
+ (let ((target (string-append (getcwd) "/static-libs/"
+ (basename lib))))
+ (unless (file-exists? target)
+ (symlink first target))))
+ libs))
+ (_ #f))))
+ inputs)
+ #t))
+ (delete 'check)
+ (add-after 'install 'post-install-check
+ (assoc-ref %standard-phases 'check)))))
+ (outputs '("out" "lib" "static" "doc"))
+ (inputs
+ (let* ((direct-inputs (package-inputs ghc-pandoc))
+ (all-static-inputs
+ (map (lambda (pkg)
+ (list (string-append "static-" (package-name pkg))
+ pkg "static"))
+ (delete-duplicates
+ (append (map cadr direct-inputs)
+ (filter (lambda (pkg)
+ (string-prefix? "ghc-" (package-name pkg)))
+ (package-closure
+ (map cadr direct-inputs))))))))
+ `(("zlib:static" ,zlib "static")
+ ,@all-static-inputs
+ ,@direct-inputs)))
+ (native-inputs
+ (let* ((direct-inputs (package-native-inputs ghc-pandoc))
+ (all-static-inputs
+ (map (lambda (pkg)
+ (list (string-append "static-" (package-name pkg))
+ pkg "static"))
+ (delete-duplicates
+ (append (map cadr direct-inputs)
+ (filter (lambda (pkg)
+ (string-prefix? "ghc-" (package-name pkg)))
+ (package-closure
+ (map cadr direct-inputs))))))))
+ `(,@all-static-inputs
+ ,@direct-inputs)))))
+
(define-public ghc-pandoc-citeproc
(package
(name "ghc-pandoc-citeproc")
suitable for inclusion in pandoc YAML metadata.")
(license license:bsd-3)))
+(define-public pandoc-citeproc
+ (package (inherit ghc-pandoc-citeproc)
+ (name "pandoc-citeproc")
+ (arguments
+ `(#:configure-flags
+ (list "-fstatic"
+ "--disable-shared"
+ "--disable-executable-dynamic"
+ ;; That's where we place all static libraries
+ "--extra-lib-dirs=static-libs/"
+ "--ghc-option=-static")
+ #:modules ((guix build haskell-build-system)
+ (guix build utils)
+ (ice-9 match)
+ (srfi srfi-1))
+ #:phases
+ (modify-phases %standard-phases
+ ;; Many YAML tests (44) are failing do to changes in ghc-yaml:
+ ;; <https://github.com/jgm/pandoc-citeproc/issues/342>.
+ (add-before 'configure 'patch-tests
+ (lambda _
+ (substitute* "tests/test-pandoc-citeproc.hs"
+ (("let allTests = citeprocTests \\+\\+ biblio2yamlTests")
+ "let allTests = citeprocTests"))))
+ ;; Tests need to be run after installation.
+ (delete 'check)
+ (add-after 'install 'post-install-check
+ (assoc-ref %standard-phases 'check))
+ (add-after 'unpack 'create-simple-paths-module
+ (lambda* (#:key outputs #:allow-other-keys)
+ (call-with-output-file "Paths_pandoc_citeproc.hs"
+ (lambda (port)
+ (format port "\
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE NoRebindableSyntax #-}
+{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
+module Paths_pandoc_citeproc (version,getDataFileName) where
+import Prelude
+import Data.Version (Version(..))
+import System.Info
+version :: Version
+version = Version [~a] []
+
+datadir :: FilePath
+datadir = \"~a/share/\" ++
+ arch ++ \"-\" ++
+ os ++ \"-\" ++
+ compilerName ++ \"-~a/pandoc-citeproc-~a\"
+
+getDataDir :: IO FilePath
+getDataDir = return datadir
+
+getDataFileName :: FilePath -> IO FilePath
+getDataFileName name = do
+ dir <- getDataDir
+ return (dir ++ \"/\" ++ name)
+"
+ (string-map (lambda (chr) (if (eq? chr #\.) #\, chr))
+ ,(package-version ghc-pandoc-citeproc))
+ (assoc-ref outputs "out")
+ ,(package-version ghc)
+ ,(package-version ghc-pandoc-citeproc))))
+ #t))
+ (add-after 'unpack 'prepare-static-libraries
+ (lambda* (#:key inputs #:allow-other-keys)
+ (mkdir-p (string-append (getcwd) "/static-libs"))
+ (for-each
+ (lambda (input)
+ (when (or (string-prefix? "static-" (car input))
+ (string-prefix? "ghc" (car input)))
+ (match (find-files (cdr input) "\\.a$")
+ ((and (first . rest) libs)
+ (for-each (lambda (lib)
+ (let ((target (string-append (getcwd) "/static-libs/"
+ (basename lib))))
+ (unless (file-exists? target)
+ (symlink first target))))
+ libs))
+ (_ #f))))
+ inputs)
+ #t)))))
+ (inputs
+ (let* ((direct-inputs
+ (cons `("ghc-pandoc" ,pandoc)
+ (alist-delete "ghc-pandoc"
+ (package-inputs ghc-pandoc-citeproc))))
+ (all-static-inputs
+ (map (lambda (pkg)
+ (list (string-append "static-" (package-name pkg))
+ pkg "static"))
+ (delete-duplicates
+ (append (map cadr direct-inputs)
+ (filter (lambda (pkg)
+ (string-prefix? "ghc-" (package-name pkg)))
+ (package-closure
+ (map cadr direct-inputs))))))))
+ `(("zlib:static" ,zlib "static")
+ ("pandoc" ,pandoc "lib")
+ ,@all-static-inputs
+ ,@direct-inputs)))
+ (synopsis "Pandoc filter for bibliographic references")))
+
(define-public ghc-pandoc-types
(package
(name "ghc-pandoc-types")
(base32
"1d6ygq991ddria71l7hg9yd7lq94sjy4m71rdws1v8hq943c4d0q"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; None of the directory names are actually used. By generating a
+ ;; simpler module without references to store names we avoid
+ ;; introducing references in the pandoc executable.
+ (add-after 'unpack 'create-simple-paths-module
+ (lambda _
+ (call-with-output-file "Paths_pandoc_types.hs"
+ (lambda (port)
+ (format port "\
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE NoRebindableSyntax #-}
+{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
+module Paths_pandoc_types (version) where
+import Data.Version (Version(..))
+version :: Version
+version = Version [~a] []
+" (string-map (lambda (chr) (if (eq? chr #\.) #\, chr)) ,version))))
+ #t)))))
(inputs
`(("ghc-syb" ,ghc-syb)
("ghc-aeson" ,ghc-aeson)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://johnmacfarlane.net/pandoc")
+ (home-page "https://johnmacfarlane.net/pandoc")
(synopsis "Types for representing a structured document")
(description
"This module defines the @code{Pandoc} data structure, which is used by
(package
(name "ghc-parallel")
(version "3.2.2.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(package
(name "ghc-paths")
(version "0.1.0.12")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
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")
(base32
"0xcyi1fivwg7a92mch5bcqzmrfxzqj42rmb3m8kgs61x4qwpxj82"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("pcre")))
(inputs
`(("pcre" ,pcre)))
(native-inputs
(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-pgp-wordlist
+ (package
+ (name "ghc-pgp-wordlist")
+ (version "0.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/pgp-wordlist/pgp-wordlist-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "15g6qh0fb7kjj3l0w8cama7cxgnhnhybw760md9yy7cqfq15cfzg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-doctest" ,ghc-doctest)))
+ (home-page
+ "https://github.com/quchen/pgp-wordlist")
+ (synopsis
+ "Translate between binary data and a human-readable collection of words")
+ (description
+ "The PGP Word List consists of two phonetic alphabets, each with one word
+per possible byte value. A string of bytes is translated with these
+alphabets, alternating between them at each byte.
+
+The PGP words corresponding to the bytes 5B 1D CA 6E are \"erase breakaway
+spellbind headwaters\", for example.
+
+For further information, see
+@url{http://en.wikipedia.org/wiki/PGP_word_list}.")
+ (license license:bsd-3)))
+
(define-public ghc-pipes
(package
(name "ghc-pipes")
types.")
(license license:bsd-3)))
+(define-public ghc-prettyprinter
+ (package
+ (name "ghc-prettyprinter")
+ (version "1.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/prettyprinter/prettyprinter-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "1p9c3q55hba4c0zyxc624g5df7wgsclpsmd8wqpdnmib882q9d1v"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-pgp-wordlist" ,ghc-pgp-wordlist)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/quchen/prettyprinter")
+ (synopsis
+ "Modern, easy to use, well-documented, extensible pretty-printer")
+ (description
+ "A prettyprinter/text rendering engine. Easy to use, well-documented,
+ANSI terminal backend exists, HTML backend is trivial to implement, no name
+clashes, @code{Text}-based, extensible.")
+ (license license:bsd-2)))
+
+(define-public ghc-prettyprinter-1.6
+ (package
+ (inherit ghc-prettyprinter)
+ (version "1.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/prettyprinter/prettyprinter-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "10fphxh8lvdaw7i8jyllwmj87w02db92mf99zfw5vddp9mv6b5rz"))))
+ (inputs
+ `(("ghc-quickckeck-instances" , ghc-quickcheck-instances)
+ ,@(package-inputs ghc-prettyprinter)))))
+
+(define-public ghc-prettyprinter-ansi-terminal
+ (package
+ (name "ghc-prettyprinter-ansi-terminal")
+ (version "1.1.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/prettyprinter-ansi-terminal/"
+ "prettyprinter-ansi-terminal-" version ".tar.gz"))
+ (sha256
+ (base32 "0ha6vz707qzb5ky7kdsnw2zgphg2dnxrpbrxy8gaw119vwhb9q6k"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-prettyprinter" ,ghc-prettyprinter-1.6)))
+ (native-inputs `(("ghc-doctest" ,ghc-doctest)))
+ (home-page
+ "https://github.com/quchen/prettyprinter")
+ (synopsis
+ "ANSI terminal backend for the prettyprinter package")
+ (description "ANSI terminal backend for the prettyprinter package.")
+ (license license:bsd-2)))
+
(define-public ghc-pretty-hex
(package
(name "ghc-pretty-hex")
(inputs
`(("ghc-haskell-lexer" ,ghc-haskell-lexer)
("ghc-happy" ,ghc-happy)))
- (home-page "http://wiki.github.com/yav/pretty-show")
+ (home-page "https://wiki.github.com/yav/pretty-show")
(synopsis "Tools for working with derived `Show` instances")
(description
"This package provides a library and an executable for working with
examination.")
(license license:expat)))
+(define-public ghc-pretty-simple
+ (package
+ (name "ghc-pretty-simple")
+ (version "2.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/pretty-simple/"
+ "pretty-simple-" version ".tar.gz"))
+ (sha256
+ (base32 "0wsi9235ihm15s145lxi7325vv2k4bhighc5m88kn1lk0pl81aqq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-glob" ,ghc-glob)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-aeson" ,ghc-aeson)))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)))
+ (home-page "https://github.com/cdepillabout/pretty-simple")
+ (synopsis "Pretty printer for data types with a 'Show' instance")
+ (description
+ "Pretty-simple is a pretty printer for Haskell data types that have a
+Show instance.")
+ (license license:bsd-3)))
+
(define-public ghc-primitive
(package
(name "ghc-primitive")
(version "0.6.4.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(base32
"1dx3nkc27yxsrbrhh3iwhq7dl1xn6bj7n62yx6nh8vmpbg62lqvl"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-base-orphans" ,ghc-base-orphans)
("ghc-bifunctors" ,ghc-bifunctors)
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-psqueue
+ (package
+ (name "ghc-psqueue")
+ (version "1.1.0.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "mirror://hackage/package/PSQueue-"
+ version "/PSQueue-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1cik7sw10sacsijmfhghzy54gm1qcyxw14shlp86lx8z89kcnkza"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/PSQueue")
+ (synopsis "Priority search queue")
+ (description
+ "A @dfn{priority search queue} efficiently supports the operations of
+both a search tree and a priority queue. A @code{Binding} is a product of
+a key and a priority. Bindings can be inserted, deleted, modified and queried
+in logarithmic time, and the binding with the least priority can be retrieved
+in constant time. A queue can be built from a list of bindings, sorted by
+keys, in linear time.")
+ (license license:bsd-3)))
+
(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")
(version "1.1")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(base32
"0q4m2fa7wkgxs0grir8rlqwibasmi3s1x7c107ynndwfm62nzv0a"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs `(("ghc-hashable" ,ghc-hashable)
("ghc-vector" ,ghc-vector)
("ghc-unordered-containers" ,ghc-unordered-containers)
(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}.
-@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
-This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
-this problem.")
+ "One module layer over @code{regex-tdfa} to replace @code{Text.Regex}.
+@code{regex-compat} can't use Unicode characters correctly because of using regex-posix.
+This is not good for Unicode users. This modified regex-compat uses regex-tdfa to solve
+this problem.")
+ (license license:bsd-3)))
+
+(define-public ghc-regex-pcre
+ (package
+ (name "ghc-regex-pcre")
+ (version "0.94.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "regex-pcre/regex-pcre-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1h16w994g9s62iwkdqa7bar2n9cfixmkzz2rm8svm960qr57valf"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("pcre")))
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("pcre" ,pcre)))
+ (home-page "https://hackage.haskell.org/package/regex-pcre")
+ (synopsis "Enhancement of the builtin Text.Regex library")
+ (description
+ "This package is an enhancement of the @code{Text.Regex} library.
+It wraps the @code{PCRE} C library providing Perl-compatible regular
+expressions.")
(license license:bsd-3)))
(define-public ghc-regex-pcre-builtin
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)))
- (home-page "https://hackage.haskell.org/package/regex-pcre")
+ (home-page "https://hackage.haskell.org/package/regex-pcre-builtin")
(synopsis "Enhancement of the builtin Text.Regex library")
(description
"This package is an enhancement of the @code{Text.Regex} library,
(base32
"03yhpqrqz977nwlnhnyz9dacnbzw8xb6j18h365rkgmbc05sb3hf"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(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
"This provides an extra text interface for regex-tdfa.")
(license license:bsd-3)))
+(define-public ghc-repline
+ (package
+ (name "ghc-repline")
+ (version "0.2.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/repline/repline-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ph21kbbanlcs8n5lwk16g9vqkb98mkbz5mzwrp8j2rls2921izc"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/sdiehl/repline")
+ (synopsis "Haskeline wrapper for GHCi-like REPL interfaces")
+ (description
+ "Haskeline wrapper for GHCi-like REPL interfaces. Composable with
+normal mtl transformers.")
+ (license license:expat)))
+
+(define-public ghc-repline-0.3
+ (package
+ (inherit ghc-repline)
+ (version "0.3.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/repline/repline-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0niihfyggg2qisadg7w49cr5k5qyyynia93iip0ng2bbmzwi88g8"))))
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-haskeline" ,ghc-haskeline-0.8)))))
+
(define-public ghc-rerebase
(package
(name "ghc-rerebase")
(base32
"1jbqif6k249rkknm2zwk8v8jil3kgi9ar53358v8l4ffx346rm82"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-rebase" ,ghc-rebase)))
(home-page "https://github.com/nikita-volkov/rerebase")
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-hedgehog" ,ghc-tasty-hedgehog)
("ghc-hedgehog" ,ghc-hedgehog)))
- (home-page "http://github.com/Soostone/retry")
+ (home-page "https://github.com/Soostone/retry")
(synopsis "Retry combinators for monadic actions that may fail")
(description "This package exposes combinators that can wrap
arbitrary monadic actions. They run the action and potentially retry
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")
(base32
"016hc4imr9l4szs3p7f1aahvxr5wv4clvr3qzrm3nibssg5vrs61"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-base-orphans" ,ghc-base-orphans)
("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-hashable" ,ghc-hashable-bootstrap)))
(properties '((hidden? #t)))))
+(define-public ghc-serialise
+ (package
+ (name "ghc-serialise")
+ (version "0.2.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/serialise/serialise-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "19ary6ivzk8z7wcxhm860qmh7pwqj0qjqzav1h42y85l608zqgh4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-cborg" ,ghc-cborg)
+ ("ghc-half" ,ghc-half)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1rknhad1i8bpknsnphmcmb6dnb48c2p2c13ia2qqch3hkhsvfpr6")))
+ (home-page "https://github.com/well-typed/cborg")
+ (synopsis "Binary serialisation library for Haskell values")
+ (description
+ "This package (formerly binary-serialise-cbor) provides pure,
+efficient serialization of Haskell values directly into ByteStrings for
+storage or transmission purposes. By providing a set of type class instances,
+you can also serialise any custom data type you have as well.
+
+The underlying binary format used is the 'Concise Binary Object
+Representation', or CBOR, specified in RFC 7049. As a result, serialised
+Haskell values have implicit structure outside of the Haskell program itself,
+meaning they can be inspected or analyzed without custom tools.
+
+An implementation of the standard bijection between CBOR and JSON is
+provided by the https://hackage.haskell.org/package/cborg-json
+package. Also see https://hackage.haskell.org/package/cbor-tool for a
+convenient command-line utility for working with CBOR data.")
+ (license license:bsd-3)))
+
(define-public ghc-setenv
(package
(name "ghc-setenv")
(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)))
generics-sop}.")
(license license:bsd-3)))
+(define-public ghc-special-values
+ (package
+ (name "ghc-special-values")
+ (version "0.1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/special-values/"
+ "special-values-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1kkdw2c4d2hha99v9f89ahmifjxp7fxmxyfwq9a8xk6s0h9xs51w"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-scientific" ,ghc-scientific)
+ ("ghc-ieee754" ,ghc-ieee754)
+ ("ghc-nats" ,ghc-nats)))
+ (home-page
+ "https://github.com/minad/special-values#readme")
+ (synopsis "Typeclass providing special values")
+ (description
+ "Special values are provided by a SpecialValues typeclass. Those can be
+used for example by QuickCheck, see quickcheck-special." )
+ (license license:expat)))
+
(define-public ghc-split
(package
(name "ghc-split")
(version "0.2.3.3")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(native-inputs '())
(properties '((hidden? #t)))))
+(define-public ghc-spoon
+ (package
+ (name "ghc-spoon")
+ (version "0.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/spoon/spoon-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1m41k0mfy6fpfrv2ym4m5jsjaj9xdfl2iqpppd3c4d0fffv51cxr"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1"
+ "09s5jjcsg4g4qxchq9g2l4i9d5zh3rixpkbiysqcgl69kj8mwv74")))
+ (home-page
+ "http://hackage.haskell.org/package/spoon")
+ (synopsis
+ "Catch errors thrown from pure computations")
+ (description
+ "Takes an error-throwing expression and puts it back in the Maybe it
+belongs in.
+
+Note that this suffers from the
+@url{https://ghc.haskell.org/trac/ghc/ticket/5902}. Buyer beware.")
+ (license license:bsd-3)))
+
(define-public ghc-statevar
(package
(name "ghc-statevar")
("ghc-unsafe" ,ghc-unsafe)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-syb" ,ghc-syb)))
- (home-page "https://www.haskell.org/haskellwiki/Storable_Vector")
+ (home-page "https://wiki.haskell.org/Storable_Vector")
(synopsis "Fast, packed, strict storable arrays with a list interface")
(description "This library provides fast, packed, strict storable
arrays with a list interface, a chunky lazy list interface with variable
(package
(name "ghc-syb")
(version "0.7.1")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
text package.")
(license license:bsd-2)))
+(define-public ghc-text-manipulate
+ (package
+ (name "ghc-text-manipulate")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/text-manipulate"
+ "/text-manipulate-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0bwxyjj3ll45srxhsp2ihikgqglvjc6m02ixr8xpvyqwkcfwgsg0"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page
+ "https://github.com/brendanhay/text-manipulate")
+ (synopsis
+ "Case conversion, word boundary manipulation, and textual subjugation")
+ (description
+ "Manipulate identifiers and structurally non-complex pieces of text by
+delimiting word boundaries via a combination of whitespace,
+control-characters, and case-sensitivity.
+
+Has support for common idioms like casing of programmatic variable names,
+taking, dropping, and splitting by word, and modifying the first character of
+a piece of text.
+
+Caution: this library makes heavy use of the text library's internal loop
+optimisation framework. Since internal modules are not guaranteed to have a
+stable API there is potential for build breakage when the text dependency is
+upgraded. Consider yourself warned!")
+ (license license:mpl2.0)))
+
(define-public ghc-text-metrics
(package
(name "ghc-text-metrics")
(package
(name "ghc-tf-random")
(version "0.5")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
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")
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")
statically known size.")
(license license:bsd-3)))
+(define-public ghc-turtle
+ (package
+ (name "ghc-turtle")
+ (version "1.5.15")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/turtle/turtle-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0yckgsc2a4g5x867gni80ldp226bsnhncfbil4ql6v2zwm4r8p7f"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-async" ,ghc-async)
+ ("ghc-clock" ,ghc-clock)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-foldl" ,ghc-foldl)
+ ("ghc-hostname" ,ghc-hostname)
+ ("ghc-managed" ,ghc-managed)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-system-filepath" ,ghc-system-filepath)
+ ("ghc-system-fileio" ,ghc-system-fileio)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-optional-args" ,ghc-optional-args)
+ ("ghc-unix-compat" ,ghc-unix-compat)))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-fail" ,ghc-fail)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "02q1rv7zx31xz9wnmcqwd4w3iw7623p07iyi21zr0cqlignic5pg")))
+ (home-page
+ "http://hackage.haskell.org/package/turtle")
+ (synopsis "Shell programming, Haskell-style")
+ (description
+ "Turtle is a reimplementation of the Unix command line environment in
+Haskell so that you can use Haskell as both a shell and a scripting
+language. Features include:
+
+@itemize
+@item Batteries included: Command an extended suite of predefined utilities.
+@item Interoperability: You can still run external shell commands.
+@item Portability: Works on Windows, OS X, and Linux.
+@item Exception safety: Safely acquire and release resources.
+@item Streaming: Transform or fold command output in constant space.
+@item Patterns: Use typed regular expressions that can parse structured values.
+@item Formatting: Type-safe printf-style text formatting.
+@item Modern: Supports text and system-filepath.
+@end itemize
+
+Read \"Turtle.Tutorial\" for a detailed tutorial or \"Turtle.Prelude\" for a
+quick-start guide. Turtle is designed to be beginner-friendly, but as a
+result lacks certain features, like tracing commands. If you feel comfortable
+using turtle then you should also check out the Shelly library which provides
+similar functionality.")
+ (license license:bsd-3)))
+
(define-public ghc-typed-process
(package
(name "ghc-typed-process")
`(("ghc-syb" ,ghc-syb)
("ghc-hashable" ,ghc-hashable)
("ghc-unordered-containers" ,ghc-unordered-containers)))
- (home-page "http://community.haskell.org/~ndm/uniplate/")
+ (home-page "https://github.com/ndmitchell/uniplate")
(synopsis "Simple, concise and fast generic operations")
(description "Uniplate is a library for writing simple and concise generic
operations. Uniplate has similar goals to the original Scrap Your Boilerplate
"02gy1zrxgzg4xmzm8lafsf1nyr3as1q20r8ld73xg3q7rkag9acg"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: hspec-discover not in PATH
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-async" ,ghc-async)
("ghc-unliftio-core" ,ghc-unliftio-core)))
(package
(name "ghc-unordered-containers")
(version "0.2.10.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
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")
(package
(name "ghc-vector")
(version "0.12.0.3")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(sha256
(base32 "0gg6852mrlgl8zng1j84fismz7k81jr5fk92glgkscf8q6ryg0bm"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories
+ ("libx11" "libxrandr" "libxinerama" "libxscrnsaver")))
(inputs
`(("libx11" ,libx11)
("libxrandr" ,libxrandr)
"X11-xft-" version ".tar.gz"))
(sha256
(base32 "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf"))))
+ (arguments
+ `(#:extra-directories ("libx11" "libxft" "xorgproto")))
(inputs
`(("ghc-x11" ,ghc-x11)
("ghc-utf8-string" ,ghc-utf8-string)
(base32
"0azlzaxp2dn4l1nr7shsxah2magk1szf6fx0mv75az00qsjw6qg4"))))
(build-system haskell-build-system)
- (home-page "http://github.com/willdonnelly/xdg-basedir")
+ (home-page "https://github.com/willdonnelly/xdg-basedir")
(synopsis "XDG Base Directory library for Haskell")
(description "This package provides a library implementing the XDG Base Directory spec.")
(license license:bsd-3)))
documents.")
(license license:expat)))
+(define-public ghc-xml-hamlet
+ (package
+ (name "ghc-xml-hamlet")
+ (version "0.5.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/xml-hamlet/"
+ "xml-hamlet-" version ".tar.gz"))
+ (sha256
+ (base32 "0jrhcjy7ww59dafg857f2g2df1fw2jmbwcs1q379ph0pc5rxj3lj"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-shakespeare" ,ghc-shakespeare)
+ ("ghc-xml-conduit" ,ghc-xml-conduit)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://www.yesodweb.com/")
+ (synopsis "Hamlet-style quasiquoter for XML content")
+ (description "This package provides a type-safe tool for generating XML
+code via quasi-quoting built on top of @code{ghc-shakespeare}.")
+ (license license:bsd-3)))
+
(define-public ghc-yaml
(package
(name "ghc-yaml")
(package
(name "ghc-zlib")
(version "0.6.2.1")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
"1l11jraslcrp9d4wnhwfyhwk4fsiq1aq8i6vj81vcq1m2zzi1y7h"))))
(build-system haskell-build-system)
(arguments
- `(#:phases
+ `(#:extra-directories ("zlib")
+ #:phases
(modify-phases %standard-phases
(add-before 'configure 'strip-test-framework-constraints
(lambda _
HCoop / jackhill / guix / guix.git / blobdiff