;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
-;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
;;; Copyright © 2016, 2019 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2016, 2017 David Craven <david@craven.ch>
;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
;;; Copyright © 2020 JoJo <jo@jo.zone>
+;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr>
+;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
;;;
;;; This file is part of GNU Guix.
;;;
style.")
(license license:bsd-3)))
+(define-public ghc-assoc
+ (package
+ (name "ghc-assoc")
+ (version "1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/assoc/assoc-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1m9n4vp190bvn2wcrd4ggfwa9pi93jp0zgx02mdgywn2zfidw020"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-tagged" ,ghc-tagged)))
+ (home-page
+ "http://hackage.haskell.org/package/assoc")
+ (synopsis
+ "Swap and assoc: Symmetric and Semigroupy Bifunctors")
+ (description
+ "Provides generalisations of @code{swap :: (a,b) -> (b,a)} and
+@code{assoc :: ((a,b),c) -> (a,(b,c))} to @code{Bifunctor}s supporting
+similar operations (e.g. @code{Either}, @code{These}).")
+ (license license:bsd-3)))
+
(define-public ghc-async
(package
(name "ghc-async")
(arguments
`(#:cabal-revision
("1" "15sn2qc8k0hxbb2nai341kkrci98hlhzcj2ci087m0zxcg5jcdbp")))
- (home-page "http://hackage.haskell.org/package/base-compat-batteries")
+ (home-page "https://hackage.haskell.org/package/base-compat-batteries")
(synopsis "base-compat with extra batteries")
(description "This library provides functions available in later
versions of @code{base} to a wider range of compilers, without requiring
∀ instead of @code{forall} and many others.")
(license license:bsd-3)))
+(define-public ghc-basic-prelude
+ (package
+ (name "ghc-basic-prelude")
+ (version "0.7.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/basic-prelude/"
+ "basic-prelude-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0yckmnvm6i4vw0mykj4fzl4ldsf67v8d2h0vp1bakyj84n4myx8h"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-unordered-containers"
+ ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/snoyberg/basic-prelude#readme")
+ (synopsis "Enhanced core prelude; a common foundation for alternate preludes")
+ (description
+ "The premise of basic-prelude is that there are a lot of very commonly
+desired features missing from the standard Prelude, such as commonly used
+operators (<$> and >=>, for instance) and imports for common datatypes
+(e.g., ByteString and Vector). At the same time, there are lots of other
+components which are more debatable, such as providing polymorphic versions
+of common functions.
+
+So basic-prelude is intended to give a common foundation for a number of
+alternate preludes. The package provides two modules: CorePrelude provides
+the common ground for other preludes to build on top of, while BasicPrelude
+exports CorePrelude together with commonly used list functions to provide a
+drop-in replacement for the standard Prelude.
+
+Users wishing to have an improved Prelude can use BasicPrelude. Developers
+wishing to create a new prelude should use CorePrelude.")
+ (license license:expat)))
+
(define-public ghc-bifunctors
(package
(name "ghc-bifunctors")
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://hackage.haskell.org/package/errorcall-eq-instance")
+ (home-page "https://hackage.haskell.org/package/errorcall-eq-instance")
(synopsis "Orphan Eq instance for ErrorCall")
(description
"Prior to @code{base-4.7.0.0} there was no @code{Eq} instance for @code{ErrorCall}.
(define-public ghc-esqueleto
(package
(name "ghc-esqueleto")
- (version "3.0.0")
+ (version "3.3.1.1")
(source
(origin
(method url-fetch)
"esqueleto/esqueleto-" version ".tar.gz"))
(sha256
(base32
- "187c098h2xyf2nhifkdy2bqfl6iap7a93mzwd2kirl5yyicpc9zy"))))
+ "1qi28ma8j5kfygjxnixlazxsyrkdqv8ljz3icwqi5dlscsnj6v3v"))))
(build-system haskell-build-system)
(arguments
`(#:haddock? #f ; Haddock reports an internal error.
("ghc-silently" ,ghc-silently)
("ghc-filemanip" ,ghc-filemanip)))
(home-page
- "http://hackage.haskell.org/package/ghc-exactprint")
+ "https://hackage.haskell.org/package/ghc-exactprint")
(synopsis "ExactPrint for GHC")
(description
"Using the API Annotations available from GHC 7.10.2, this library
(define-public ghc-extra
(package
(name "ghc-extra")
- (version "1.6.18")
+ (version "1.6.21")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0jvd4l0hi8pf5899pxc32yc638y0mrc357w0rph99k3hm277i0cy"))))
+ "1gjx98w4w61g043k6rzc8i34cbxpcigi8lb6i7pp1vwp8w8jm5vl"))))
(build-system haskell-build-system)
(inputs
`(("ghc-clock" ,ghc-clock)
("ghc-semigroups" ,ghc-semigroups)
- ("ghc-quickcheck" ,ghc-quickcheck)))
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
(home-page "https://github.com/ndmitchell/extra")
(synopsis "Extra Haskell functions")
(description "This library provides extra functions for the standard
(build-system haskell-build-system)
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
- (home-page "http://hackage.haskell.org/package/filepath-bytestring")
+ (home-page "https://hackage.haskell.org/package/filepath-bytestring")
(synopsis "Library for manipulating RawFilePaths in a cross-platform way")
(description "This package provides a drop-in replacement for the standard
@code{filepath} library, operating on @code{RawFilePath} values rather than
(sha256
(base32 "1wyxd8x33x4v5vxyzkhm610pl86gbkc8y439092fr1735q9g7kfq"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/haskell-lexer")
+ (home-page "https://hackage.haskell.org/package/haskell-lexer")
(synopsis "Fully compliant Haskell 98 lexer")
(description
"This package provides a fully compliant Haskell 98 lexer.")
(lambda* (#:key inputs outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(elisp-file "elisp/hindent.el")
- (dest (string-append out "/share/emacs/site-lisp"
- "/guix.d/hindent-" ,version))
+ (dest (string-append out "/share/emacs/site-lisp"))
(emacs (string-append (assoc-ref inputs "emacs")
"/bin/emacs")))
(make-file-writable elisp-file)
(base32
"1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/IfElse")
+ (home-page "https://hackage.haskell.org/package/IfElse")
(synopsis "Monadic control flow with anaphoric variants")
(description "This library provides functions for control flow inside of
monads with anaphoric variants on @code{if} and @code{when} and a C-like
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://hackage.haskell.org/package/infer-license")
+ (home-page "https://hackage.haskell.org/package/infer-license")
(synopsis "Infer software license from a given license file")
(description "This library provides tools to infer a software
license from a given license file.")
("ghc-hspec" ,ghc-hspec)
("ghc-raw-strings-qq" ,ghc-raw-strings-qq)
("ghc-regex-posix" ,ghc-regex-posix)))
- (home-page "http://hackage.haskell.org/package/inline-c")
+ (home-page "https://hackage.haskell.org/package/inline-c")
(synopsis "Write Haskell source files including C code inline")
(description
"inline-c lets you seamlessly call C libraries and embed high-performance
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-zlib" ,ghc-zlib)))
- (home-page "http://hackage.haskell.org/package/io-streams")
+ (home-page "https://hackage.haskell.org/package/io-streams")
(synopsis "Simple and composable stream I/O")
(description "This library contains simple and easy-to-use
primitives for I/O using streams.")
`(#:tests? #f
#:cabal-revision
("1" "10ac9pk4jy75k03j1ns4b5136l4kw8krr2d2nw2fdmpm5jzyghc5")))
- (home-page "http://hackage.haskell.org/package/language-glsl")
+ (home-page "https://hackage.haskell.org/package/language-glsl")
(synopsis "GLSL abstract syntax tree, parser, and pretty-printer")
(description "This package is a Haskell library for the
representation, parsing, and pretty-printing of GLSL 1.50 code.")
(build-system haskell-build-system)
(native-inputs `(("pkg-config" ,pkg-config)))
(inputs `(("libffi" ,libffi)))
- (home-page "http://hackage.haskell.org/package/libffi")
+ (home-page "https://hackage.haskell.org/package/libffi")
(synopsis "Haskell binding to libffi")
(description
"A binding to libffi, allowing C functions of types only known at runtime
(base32
"10p0gjjjwr1dda7hahwrwn5njbfhl67arq3v3nf1jr3vymlkn75j"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/magic")
+ (home-page "https://hackage.haskell.org/package/magic")
(synopsis "Interface to C file/magic library")
(description
"This package provides a full-featured binding to the C libmagic library.
\"cut\" monoids.")
(license license:bsd-3)))
+(define-public ghc-mtl-compat
+ (package
+ (name "ghc-mtl-compat")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/mtl-compat/mtl-compat-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "17iszr5yb4f17g8mq6i74hsamii8z6m2qfsmgzs78mhiwa7kjm8r"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/haskell-compat/mtl-compat")
+ (synopsis
+ "Backported Control.Monad.Except module from mtl")
+ (description
+ "This package backports the Control.Monad.Except module from mtl (if
+using mtl-2.2.0.1 or earlier), which reexports the ExceptT monad transformer
+and the MonadError class.
+
+This package should only be used if there is a need to use the
+Control.Monad.Except module specifically. If you just want the mtl class
+instances for ExceptT, use transformers-compat instead, since mtl-compat does
+nothing but reexport the instances from that package.
+
+Note that unlike how mtl-2.2 or later works, the Control.Monad.Except
+module defined in this package exports all of ExceptT's monad class instances.
+Therefore, you may have to declare @code{import Control.Monad.Except ()} at
+the top of your file to get all of the ExceptT instances in scope.")
+ (license license:bsd-3)))
+
(define-public ghc-murmur-hash
(package
(name "ghc-murmur-hash")
(build-system haskell-build-system)
(native-inputs
`(("ghc-doctest" ,ghc-doctest)))
- (home-page "http://hackage.haskell.org/package/network-byte-order")
+ (home-page "https://hackage.haskell.org/package/network-byte-order")
(synopsis "Network byte order utilities")
(description "This library provides peek and poke functions for network
byte order.")
of Peano numbers).")
(license license:gpl3+)))
+(define-public ghc-nonce
+ (package
+ (name "ghc-nonce")
+ (version "1.0.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/nonce/"
+ "nonce-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1q9ph0aq51mvdvydnriqd12sfin36pfb8f588zgac1ybn8r64ksb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-entropy" ,ghc-entropy)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)))
+ (home-page "https://github.com/prowdsponsor/nonce")
+ (synopsis "Generate cryptographic nonces in Haskell")
+ (description
+ "A nonce is an arbitrary number used only once in a cryptographic
+communication. This package contain helper functions for generating nonces.
+There are many kinds of nonces used in different situations. It's not
+guaranteed that by using the nonces from this package you won't have any
+security issues. Please make sure that the nonces generated via this
+package are usable on your design.")
+ (license license:bsd-3)))
+
(define-public ghc-numeric-extras
(package
(name "ghc-numeric-extras")
command line options in Haskell.")
(license license:bsd-3)))
+(define-public ghc-jira-wiki-markup
+ (package
+ (name "ghc-jira-wiki-markup")
+ (version "1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/jira-wiki-markup/"
+ "jira-wiki-markup-" version ".tar.gz"))
+ (sha256
+ (base32 "1sl2jjcsqg61si33mxjwpf8zdn56kbbgcwqqqzbgifx2qbv4wmf8"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/tarleb/jira-wiki-markup")
+ (synopsis "Handle Jira wiki markup")
+ (description
+ "Parse jira wiki text into an abstract syntax tree for easy transformation
+to other formats.")
+ (license license:expat)))
+
+(define-public ghc-emojis
+ (package
+ (name "ghc-emojis")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/emojis/"
+ "emojis-" version ".tar.gz"))
+ (sha256
+ (base32 "1c6zkj9gmk1y90gbdrn50hyp7mw1mggzhnr2khqd728ryipw60ss"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/jgm/emojis#readme")
+ (synopsis "Conversion between emoji characters and their names.")
+ (description
+ "This package provides functions for converting emoji names to emoji
+characters and vice versa.
+
+How does it differ from the @code{emoji} package?
+@itemize
+@item It supports a fuller range of emojis, including all those supported by
+GitHub
+@item It supports lookup of emoji aliases from emoji
+@item It uses Text rather than String
+@item It has a lighter dependency footprint: in particular, it does not
+require aeson
+@item It does not require TemplateHaskell
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public ghc-text-conversions
+ (package
+ (name "ghc-text-conversions")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/text-conversions/"
+ "text-conversions-" version ".tar.gz"))
+ (sha256
+ (base32 "089c56vdj9xysqfr1hnvbnrghlg83q6w10xk02gflpsidcpvwmhp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-errors" ,ghc-errors)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)))
+ (home-page "https://github.com/cjdev/text-conversions#readme")
+ (synopsis "Safe conversions between textual types")
+ (description "Safe conversions between textual types")
+ (license license:isc)))
+
+(define-public ghc-doclayout
+ (package
+ (name "ghc-doclayout")
+ (version "0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/doclayout/"
+ "doclayout-" version ".tar.gz"))
+ (sha256
+ (base32 "1wmnwq28jcyd6c80srivsnd5znmyl9sgmwwnlk2crwiiwqadbal7"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-safe" ,ghc-safe)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/jgm/doclayout")
+ (synopsis "Pretty-printing library for laying out text documents")
+ (description
+ "doclayout is a pretty-printing library for laying out text documents,
+with several features not present in pretty-printing libraries designed for
+code. It was designed for use in @code{Pandoc}.")
+ (license license:bsd-3)))
+
(define-public ghc-pandoc
(package
(name "ghc-pandoc")
("ghc-hspec" ,ghc-hspec)
("ghc-validity" ,ghc-validity)))
(home-page
- "http://hackage.haskell.org/package/path")
+ "https://hackage.haskell.org/package/path")
(synopsis "Support for well-typed paths")
(description "This package introduces a type for paths upholding useful
invariants.")
performance, nice output for humans, and simplicity of implementation.")
(license license:bsd-3)))
+(define-public ghc-pattern-arrows
+ (package
+ (name "ghc-pattern-arrows")
+ (version "0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/pattern-arrows/pattern-arrows-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "13q7bj19hd60rnjfc05wxlyck8llxy11z3mns8kxg197wxrdkhkg"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html")
+ (synopsis "Arrows for Pretty Printing")
+ (description
+ "A library for generating concise pretty printers based on precedence
+rules.")
+ (license license:expat)))
+
(define-public ghc-pcre-light
(package
(name "ghc-pcre-light")
(define-public ghc-persistent
(package
(name "ghc-persistent")
- (version "2.9.2")
+ (version "2.10.4")
(source
(origin
(method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "persistent-" version "/"
- "persistent-" version ".tar.gz"))
+ (uri (string-append
+ "https://hackage.haskell.org/package/persistent/"
+ "persistent-" version ".tar.gz"))
(sha256
(base32
- "1wsa3kn427v88a6r0vwr6mz23snik2krbsgc8zqp18xajqn5szj9"))))
+ "1cxswz72sqdg2z1nbpgp1k5qr41djgk8qbf8nz7wfppsrhacyffi"))))
(build-system haskell-build-system)
- (inputs `(("ghc-old-locale" ,ghc-old-locale)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-exceptions" ,ghc-exceptions)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-lifted-base" ,ghc-lifted-base)
- ("ghc-resource-pool" ,ghc-resource-pool)
- ("ghc-path-pieces" ,ghc-path-pieces)
- ("ghc-http-api-data" ,ghc-http-api-data)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-transformers-base" ,ghc-transformers-base)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-vector" ,ghc-vector)
- ("ghc-attoparsec" ,ghc-attoparsec)
- ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
- ("ghc-blaze-html" ,ghc-blaze-html)
- ("ghc-blaze-markup" ,ghc-blaze-markup)
- ("ghc-silently" ,ghc-silently)
- ("ghc-fast-logger" ,ghc-fast-logger)
- ("ghc-scientific" ,ghc-scientific)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-void" ,ghc-void)))
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-fast-logger" ,ghc-fast-logger)
+ ("ghc-http-api-data" ,ghc-http-api-data)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-path-pieces" ,ghc-path-pieces)
+ ("ghc-resource-pool" ,ghc-resource-pool)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unordered-containers"
+ ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
(native-inputs `(("ghc-hspec" ,ghc-hspec)))
(home-page "https://www.yesodweb.com/book/persistent")
(synopsis "Type-safe, multi-backend data serialization for Haskell")
(define-public ghc-persistent-sqlite
(package
(name "ghc-persistent-sqlite")
- (version "2.9.3")
+ (version "2.10.5.2")
(source
(origin
(method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "persistent-sqlite-" version "/"
- "persistent-sqlite-" version ".tar.gz"))
+ (uri (string-append
+ "https://hackage.haskell.org/package/persistent-sqlite/"
+ "persistent-sqlite-" version ".tar.gz"))
(sha256
(base32
- "13wbn88ixv4d4dfjl1gabm1q60fbcnygbmixz57pi3z84drrynwq"))))
+ "0agag3cgivl6mk38pqzr0qw5lxps9p2bgdwvi5658l46hs7bixxn"))))
(build-system haskell-build-system)
- (inputs `(("ghc-persistent" ,ghc-persistent)
- ("ghc-unliftio-core" ,ghc-unliftio-core)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-conduit" ,ghc-conduit)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-microlens-th" ,ghc-microlens-th)
- ("ghc-resourcet" ,ghc-resourcet)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-resource-pool" ,ghc-resource-pool)
- ("ghc-unordered-containers" ,ghc-unordered-containers)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-persistent-template" ,ghc-persistent-template)
- ("ghc-temporary" ,ghc-temporary)))
+ (inputs
+ `(("ghc-persistent" ,ghc-persistent)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-microlens-th" ,ghc-microlens-th)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-resource-pool" ,ghc-resource-pool)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)
+ ("ghc-unordered-containers"
+ ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-persistent-template"
+ ,ghc-persistent-template)
+ ("ghc-persistent-test" ,ghc-persistent-test)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-fast-logger" ,ghc-fast-logger)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-system-fileio" ,ghc-system-fileio)
+ ("ghc-system-filepath" ,ghc-system-filepath)
+ ("ghc-temporary" ,ghc-temporary)))
(home-page
"https://www.yesodweb.com/book/persistent")
(synopsis "Backend for the persistent library using sqlite3")
(define-public ghc-persistent-template
(package
(name "ghc-persistent-template")
- (version "2.6.0")
+ (version "2.8.0")
(source
(origin
(method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/"
- "persistent-template-" version "/"
- "persistent-template-" version ".tar.gz"))
+ (uri (string-append
+ "https://hackage.haskell.org/package/persistent-template/"
+ "persistent-template-" version ".tar.gz"))
(sha256
(base32
- "0wr1z2nfrl6jv1lprxb0d2jw4izqfcbcwvkdrhryzg95gjz8ryjv"))))
+ "16yjrl0gh4jbs4skr7iv6a55lny59bqhd6hjmvch1cl9j5d0c0g3"))))
(build-system haskell-build-system)
- (inputs `(("ghc-persistent" ,ghc-persistent)
- ("ghc-monad-control" ,ghc-monad-control)
- ("ghc-aeson" ,ghc-aeson)
- ("ghc-aeson-compat" ,ghc-aeson-compat)
- ("ghc-monad-logger" ,ghc-monad-logger)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
- ("ghc-tagged" ,ghc-tagged)
- ("ghc-path-pieces" ,ghc-path-pieces)
- ("ghc-http-api-data" ,ghc-http-api-data)))
- (native-inputs `(("ghc-hspec" ,ghc-hspec)
- ("ghc-quickcheck" ,ghc-quickcheck)))
+ (inputs
+ `(("ghc-persistent" ,ghc-persistent)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-http-api-data" ,ghc-http-api-data)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-path-pieces" ,ghc-path-pieces)
+ ("ghc-th-lift-instances" ,ghc-th-lift-instances)
+ ("ghc-unordered-containers"
+ ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://www.yesodweb.com/book/persistent")
(synopsis "Type-safe, non-relational, multi-backend persistence")
(description "This Haskell package provides interfaces and helper
functions for the ghc-persistent package.")
(license license:expat)))
+(define-public ghc-persistent-test
+ (package
+ (name "ghc-persistent-test")
+ (version "2.0.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/persistent-test/"
+ "persistent-test-" version ".tar.gz"))
+ (sha256
+ (base32
+ "11aq5cy0n43jamf6mg4sr4300bc2zdbjxsczzxwjkb4hzs0ijsdv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-aeson" ,ghc-aeson)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-path-pieces" ,ghc-path-pieces)
+ ("ghc-persistent" ,ghc-persistent)
+ ("ghc-persistent-template" ,ghc-persistent-template)
+ ("ghc-random" ,ghc-random)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unliftio-core" ,ghc-unliftio-core)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://www.yesodweb.com/book/persistent")
+ (synopsis "Tests for the Persistent database library")
+ (description
+ "This is only for use in developing libraries that should conform to
+the persistent interface, not for users of the persistent suite of database
+libraries.")
+ (license license:expat)))
+
(define-public ghc-pipes
(package
(name "ghc-pipes")
"16xsrzqql7i4z6a3xy07sqnbyqdmcar1jiacla58y4mvkkwb0g3l"))))
(build-system haskell-build-system)
(home-page
- "http://hackage.haskell.org/package/pointedlist")
+ "https://hackage.haskell.org/package/pointedlist")
(synopsis
"Zipper-like comonad which works as a list, tracking a position")
(description
(base32
"11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/prettyclass")
+ (home-page "https://hackage.haskell.org/package/prettyclass")
(synopsis "Pretty printing class similar to Show")
(description "This package provides a pretty printing class similar
to @code{Show}, based on the HughesPJ pretty printing library. It
(description "This library provides profunctors for Haskell.")
(license license:bsd-3)))
+(define-public ghc-project-template
+ (package
+ (name "ghc-project-template")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/project-template/project-template-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1p69ww4rhah2qxragl615wl4a6mk4x9w09am8knmz3s4lxpljlpb"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-resourcet" ,ghc-resourcet)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("hspec-discover" ,hspec-discover)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("1"
+ "0lq3sqnq0nr0gbvgzp0lqdl3j3mqdmdlf8xsw0j3pjh581xj3k0a")))
+ (home-page "https://github.com/fpco/haskell-ide")
+ (synopsis "Specify Haskell project templates and generate files")
+ (description
+ "Haskell library for both generating and consuming project templates.
+
+ost IDEs provide the concept of a project template: instead of writing all
+of the code for a project from scratch, you select a template, answer a few
+questions, and a bunch of files are automatically generated.
+
+project-template tries to provide a canonical Haskell library for implementing
+the ideal templating system.")
+ (license license:bsd-3)))
+
+(define-public ghc-protolude
+ (package
+ (name "ghc-protolude")
+ (version "0.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/protolude/protolude-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0zzkyxz0vmcbncpid7gp72fpjj0fla3gqhlfkij5c5lg12skjgfj"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-mtl-compat" ,ghc-mtl-compat)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)))
+ (home-page "https://github.com/protolude/protolude")
+ (synopsis "Sensible set of defaults for writing custom Preludes")
+ (description
+ "Protolude gives you sensible defaults for writing custom Preludes to
+replace the standard one provided by GHC.")
+ (license license:expat)))
+
(define-public ghc-psqueues
(package
(name "ghc-psqueues")
@end itemize")
(license license:bsd-3)))
+(define-public ghc-pwstore-fast
+ (package
+ (name "ghc-pwstore-fast")
+ (version "2.4.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/pwstore-fast/"
+ "pwstore-fast-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1cpvlwzg3qznhygrr78f75p65mnljd9v5cvnagfxjqppnrkay6bj"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-cryptohash" ,ghc-cryptohash)
+ ("ghc-random" ,ghc-random)
+ ("ghc-byteable" ,ghc-byteable)))
+ (home-page "https://github.com/PeterScott/pwstore")
+ (synopsis "Secure password storage")
+ (description
+ "To store passwords securely, they should be salted, then hashed with
+a slow hash function. This library uses PBKDF1-SHA256, and handles all the
+details. It uses the cryptohash package for speed; if you need a pure
+Haskell library, pwstore-purehaskell has the exact same API, but uses only
+pure Haskell. It is about 25 times slower than this package, but still quite
+usable.")
+ (license license:bsd-3)))
+
(define-public ghc-random
(package
(name "ghc-random")
(base32
"0v0zxcx29b8jxs2kgy9csykqcp8kzhdvyylw2xfwmj4pfxr2kl0a"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/refact")
+ (home-page "https://hackage.haskell.org/package/refact")
(synopsis "Specify refactorings to perform with apply-refact")
(description
"This library provides a datatype which can be interpreted by
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)))
- (home-page "https://github.com/ChrisKuklewicz/regex-tdfa")
+ (home-page "https://github.com/haskell-hvr/regex-tdfa")
(synopsis "POSIX extended regular expressions in Haskell.")
(description
"Regex-tdfa is a pure Haskell regular expression library implementing POSIX
`(("ghc-regex-base" ,ghc-regex-base)
("ghc-regex-tdfa" ,ghc-regex-tdfa)))
(home-page
- "http://hackage.haskell.org/package/regex-tdfa-text")
+ "https://hackage.haskell.org/package/regex-tdfa-text")
(synopsis "Text interface for regex-tdfa")
(description
"This provides an extra text interface for regex-tdfa.")
("sdl2-image" ,sdl2-image)))
(native-inputs
`(("pkg-config" ,pkg-config)))
- (home-page "http://hackage.haskell.org/package/sdl2-image")
+ (home-page "https://hackage.haskell.org/package/sdl2-image")
(synopsis "Bindings to SDL2_image")
(description "This package provides Haskell bindings to
@code{SDL2_image}.")
("sdl2-mixer" ,sdl2-mixer)))
(native-inputs
`(("pkg-config" ,pkg-config)))
- (home-page "http://hackage.haskell.org/package/sdl2-mixer")
+ (home-page "https://hackage.haskell.org/package/sdl2-mixer")
(synopsis "Bindings to SDL2 mixer")
(description "This package provides Haskell bindings to
@code{SDL2_mixer}.")
a memory chunk that will be auto-scrubbed after it run out of scope.")
(license license:bsd-3)))
+(define-public ghc-semialign
+ (package
+ (name "ghc-semialign")
+ (version "1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/semialign/semialign-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "004x0a80sqqdgvsyk4z0nasxpi6z3g1d8kgwj804bj9ka8dlc75m"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-these" ,ghc-these)
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)))
+ (arguments
+ `(#:cabal-revision
+ ("1"
+ "0qnqnyfng4kwy2h2anrcy5id2ijnawava3zcc5h5b8ri1y6ks6zi")))
+ (home-page
+ "https://github.com/isomorphism/these")
+ (synopsis
+ "Align and Zip type-classes from the common Semialign ancestor ")
+ (description
+ "The major use of @code{These} of this is provided by the
+@code{align} member of @code{Semialign} class, representing a
+generalized notion of \"zipping with padding\" that combines
+structures without truncating to the size of the smaller input. It
+turns out that @code{zip} operation fits well the @code{Semialign}
+class, forming lattice-like structure.")
+ (license license:bsd-3)))
+
(define-public ghc-semigroupoids
(package
(name "ghc-semigroupoids")
(home-page
"https://github.com/feuerbach/smallcheck")
(synopsis "Property-based testing library")
- (description "SmallCheck is a testing library that allows to verify
+ (description "SmallCheck is a testing library that verifies
properties for all test cases up to some depth. The test cases are generated
automatically by SmallCheck.")
(license license:bsd-3)))
(base32
"07ci2mh8cbjvipb576rxsj3iyhkj5c5dnsns4xkdppp2p3pv10d3"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/sop-core")
+ (home-page "https://hackage.haskell.org/package/sop-core")
(synopsis "True Sums of Products")
(description "This package provides an implementation of
@math{n}-ary sums and @math{n}-ary products. The module @code{Data.SOP}
("ghc-base-compat-batteries" ,ghc-base-compat-batteries)
("ghc-tf-random" ,ghc-tf-random)
("ghc-vector" ,ghc-vector)))
- (home-page "http://hackage.haskell.org/package/splitmix")
+ (home-page "https://hackage.haskell.org/package/splitmix")
(synopsis "Fast and splittable pseudorandom number generator")
(description "This package provides a Pure Haskell implementation of the
SplitMix pseudorandom number generator. SplitMix is a \"splittable\"
(build-system haskell-build-system)
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
- (home-page "http://hackage.haskell.org/package/string-qq")
+ (home-page "https://hackage.haskell.org/package/string-qq")
(synopsis
"QuasiQuoter for non-interpolated strings, texts and bytestrings.")
(description
occurrences of a substring (the first in case of overlaps) with another.")
(license license:bsd-3)))
-(define-public ghc-stylish-haskell
- (package
- (name "ghc-stylish-haskell")
- (version "0.9.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "mirror://hackage/package/stylish-haskell/stylish-haskell-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1ls11fdx6snvfx8yykpidz142zzxwi5bazl49hgfqlwx50rqcp7w"))))
- (build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "stylish-haskell.cabal"
- (("haskell-src-exts >= 1\\.18 && < 1\\.21,")
- "haskell-src-exts >= 1.18 && < 1.22,"))
- #t)))))
- (inputs
- `(("ghc-aeson" ,ghc-aeson)
- ("ghc-file-embed" ,ghc-file-embed)
- ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
- ("ghc-semigroups" ,ghc-semigroups)
- ("ghc-syb" ,ghc-syb)
- ("ghc-yaml" ,ghc-yaml)
- ("ghc-strict" ,ghc-strict)
- ("ghc-optparse-applicative"
- ,ghc-optparse-applicative)))
- (native-inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-test-framework" ,ghc-test-framework)
- ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "https://github.com/jaspervdj/stylish-haskell")
- (synopsis "Haskell code prettifier")
- (description "Stylish-haskell is a Haskell code prettifier. The goal is
-not to format all of the code in a file, to avoid \"getting in the way\".
-However, this tool can e.g. clean up import statements and help doing various
-tasks that get tedious very quickly. It can
-@itemize
-@item
-Align and sort @code{import} statements
-@item
-Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant
-pragmas
-@item
-Remove trailing whitespaces
-@item
-Align branches in @code{case} and fields in records
-@item
-Convert line endings (customisable)
-@item
-Replace tabs by four spaces (turned off by default)
-@item
-Replace some ASCII sequences by their Unicode equivalent (turned off by
-default)
-@end itemize")
- (license license:bsd-3)))
-
(define-public ghc-svg-builder
(package
(name "ghc-svg-builder")
package, and that's where the version number started.")
(license license:bsd-3)))
+(define-public ghc-these
+ (package
+ (name "ghc-these")
+ (version "1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/these/these-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1k0pi65g7cm9hzdw6my6bzz2zvddkmj1qs45ymqmi316bpiixk3r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-assoc" ,ghc-assoc)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("1"
+ "0923r86fnmgpx0msm68aszirh2n19nn5bccgjxfh2146jw4z7w3z")))
+ (home-page
+ "https://github.com/isomorphism/these")
+ (synopsis "Either-or-both data type")
+ (description
+ "This package provides a data type @code{These a b} which can
+hold a value of either type or values of each type. This is usually
+thought of as an \"inclusive or\" type (contrasting @code{Either a b} as
+\"exclusive or\") or as an \"outer join\" type (contrasting @code{(a, b)}
+as \"inner join\").
+
+@code{data These a b = This a | That b | These a b}
+
+Since version 1, this package was split into parts:
+
+@itemize
+@item
+https://hackage.haskell.org/package/semialign For @code{Align} and
+@code{Zip} type-classes.
+@item
+https://hackage.haskell.org/package/semialign-indexed For
+@code{SemialignWithIndex} class, providing @code{ialignWith} and
+@code{izipWith}
+@item
+https://hackage.haskell.org/package/these-lens For lens combinators.
+@item
+http://hackage.haskell.org/package/monad-chronicle For transformers
+variant of @code{These}.
+@end itemize")
+ (license license:bsd-3)))
+
(define-public ghc-threads
(package
(name "ghc-threads")
("1" "0k8ph4sydaiqp8dav4if6hpiaq8h1xsr93khmdr7a1mmfwdxr64r")))
(home-page "https://github.com/phadej/time-compat")
(synopsis "Compatibility package for time")
- (description "This packages tries to compat as many @code{time}
+ (description "This package tries to compat as many @code{time}
features as possible.")
(license license:bsd-3)))
man pages with practical examples.")
(license license:bsd-3)))
+(define-public ghc-transformers
+ (package
+ (name "ghc-transformers")
+ (version "0.5.6.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/transformers/transformers-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0v66j5k0xqk51pmca55wq192qyw2p43s2mgxlz4f95q2c1fpjs5n"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/transformers")
+ (synopsis "Concrete functor and monad transformers")
+ (description
+ "Transformers provides functor and monad transformers, inspired by the
+paper \"Functional Programming with Overloading and Higher-Order
+Polymorphism\", by Mark P Jones, in Advanced School of Functional Programming,
+1995 @url{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html}.
+
+This package contains:
+@itemize
+@item the monad transformer class (in @code{Control.Monad.Trans.Class})
+@item concrete functor and monad transformers, each with associated operations
+and functions to lift operations associated with other transformers.
+@end itemize
+
+This package can be used on its own in portable Haskell code, in which case
+operations need to be manually lifted through transformer stacks (see
+@code{Control.Monad.Trans.Class} for some examples). Alternatively, it can be
+used with the non-portable monad classes in the mtl or monads-tf packages,
+which automatically lift operations introduced by monad transformers through
+other transformers.")
+ (license license:bsd-3)))
+
(define-public ghc-transformers-base
(package
(name "ghc-transformers-base")
#:cabal-revision
("1"
"09pqi867wskwgc5lpn197f895mbn1174ydgllvcppcsmrz2b6yr6")))
- (home-page "http://hackage.haskell.org/package/unagi-chan")
+ (home-page "https://hackage.haskell.org/package/unagi-chan")
(synopsis "Fast concurrent queues with a Chan-like API, and more")
(description
"This library provides implementations of concurrent FIFO queues (for
parser that uses ByteStrings for parsing and representing the URI data.")
(license license:bsd-3)))
+(define-public ghc-utf8-light
+ (package
+ (name "ghc-utf8-light")
+ (version "0.4.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/utf8-light/utf8-light-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/utf8-light")
+ (synopsis "Lightweight unicode support for Haskell")
+ (description
+ "This package profides a class for encoding and decoding UTF8 strings
+with instances for several common types. It also includes several functions
+for working with UTF8. It aims to be lightweight, depending only on Base and
+including only one module.")
+ (license license:bsd-3)))
+
(define-public ghc-utf8-string
(package
(name "ghc-utf8-string")
(base32
"0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j"))))
(build-system haskell-build-system)
- (home-page "http://code.galois.com")
+ (home-page "https://github.com/GaloisInc/xml")
(synopsis "Simple XML library for Haskell")
(description "This package provides a simple XML library for Haskell.")
(license license:bsd-3)))
HCoop / jackhill / guix / guix.git / blobdiff