me
/
guix
Archived
1
0
Fork 0
Code

Upgrade Haskell packages. 

Script-aided bulk change.
Lars-Dominik Braun 2023-01-15 10:09:44 +01:00
parent 9262c14d73
commit 49a320aaa6
No known key found for this signature in database
GPG Key ID: F663943E08D8092A
21 changed files with 6891 additions and 6525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gnu/local.mk
View File

@ -955,8 +955,6 @@ dist_patch_DATA = \
%D%/packages/patches/breezy-fix-gio.patch \ %D%/packages/patches/breezy-fix-gio.patch \
%D%/packages/patches/byobu-writable-status.patch \ %D%/packages/patches/byobu-writable-status.patch \
%D%/packages/patches/bubblewrap-fix-locale-in-tests.patch \ %D%/packages/patches/bubblewrap-fix-locale-in-tests.patch \
%D%/packages/patches/cabal-install-base16-bytestring1.0.patch \
%D%/packages/patches/cabal-install-ghc8.10.patch \
%D%/packages/patches/cairo-CVE-2018-19876.patch \ %D%/packages/patches/cairo-CVE-2018-19876.patch \
%D%/packages/patches/cairo-CVE-2020-35492.patch \ %D%/packages/patches/cairo-CVE-2020-35492.patch \
%D%/packages/patches/calibre-no-updates-dialog.patch \ %D%/packages/patches/calibre-no-updates-dialog.patch \
@ -1200,6 +1198,8 @@ dist_patch_DATA = \
%D%/packages/patches/geoclue-config.patch \ %D%/packages/patches/geoclue-config.patch \
%D%/packages/patches/ghc-8.0-fall-back-to-madv_dontneed.patch \ %D%/packages/patches/ghc-8.0-fall-back-to-madv_dontneed.patch \
%D%/packages/patches/ghc-testsuite-dlopen-pie.patch \ %D%/packages/patches/ghc-testsuite-dlopen-pie.patch \
%D%/packages/patches/ghc-bloomfilter-ghc9.2.patch \
%D%/packages/patches/ghc-bytestring-handle-ghc9.patch \
%D%/packages/patches/ghc-language-haskell-extract-ghc-8.10.patch \ %D%/packages/patches/ghc-language-haskell-extract-ghc-8.10.patch \
%D%/packages/patches/ghostscript-no-header-id.patch \ %D%/packages/patches/ghostscript-no-header-id.patch \
%D%/packages/patches/ghostscript-no-header-uuid.patch \ %D%/packages/patches/ghostscript-no-header-uuid.patch \
@ -1576,7 +1576,6 @@ dist_patch_DATA = \
%D%/packages/patches/nix-dont-build-html-doc.diff \ %D%/packages/patches/nix-dont-build-html-doc.diff \
%D%/packages/patches/nfs4-acl-tools-0.3.7-fixpaths.patch \ %D%/packages/patches/nfs4-acl-tools-0.3.7-fixpaths.patch \
%D%/packages/patches/ngircd-handle-zombies.patch \ %D%/packages/patches/ngircd-handle-zombies.patch \
%D%/packages/patches/ngless-unliftio.patch \
%D%/packages/patches/network-manager-plugin-path.patch \ %D%/packages/patches/network-manager-plugin-path.patch \
%D%/packages/patches/network-manager-meson.patch \ %D%/packages/patches/network-manager-meson.patch \
%D%/packages/patches/nginx-socket-cloexec.patch \ %D%/packages/patches/nginx-socket-cloexec.patch \
@ -2012,7 +2011,6 @@ dist_patch_DATA = \
%D%/packages/patches/xfce4-settings-defaults.patch \ %D%/packages/patches/xfce4-settings-defaults.patch \
%D%/packages/patches/xgboost-use-system-dmlc-core.patch \ %D%/packages/patches/xgboost-use-system-dmlc-core.patch \
%D%/packages/patches/xmonad-dynamic-linking.patch \ %D%/packages/patches/xmonad-dynamic-linking.patch \
%D%/packages/patches/xmonad-next-dynamic-linking.patch \
%D%/packages/patches/xnnpack-system-libraries.patch \ %D%/packages/patches/xnnpack-system-libraries.patch \
%D%/packages/patches/xplanet-1.3.1-cxx11-eof.patch \ %D%/packages/patches/xplanet-1.3.1-cxx11-eof.patch \
%D%/packages/patches/xplanet-1.3.1-libdisplay_DisplayOutput.cpp.patch \ %D%/packages/patches/xplanet-1.3.1-libdisplay_DisplayOutput.cpp.patch \

211
gnu/packages/bioinformatics.scm
View File

@ -14823,110 +14823,121 @@ datasets.")
(define-public ngless (define-public ngless
(package (package
(name "ngless") (name "ngless")
(version "1.3.0") (version "1.5.0")
(source (source (origin
(origin (method url-fetch)
(method git-fetch) (uri (hackage-uri "NGLess" version))
(uri (git-reference (sha256
(url "https://github.com/ngless-toolkit/ngless.git") (base32
(commit (string-append "v" version)))) "0pljyrlpr9r3cl5311dhgxdl8y40szyi4vprn34i3piy0qrldymi"))))
(file-name (git-file-name name version))
(sha256
(base32
"0pb9f6b0yk9p4cdwiym8r190q1bcdiwvc7i2s6rw54qgi8r3g6pj"))
(patches (search-patches "ngless-unliftio.patch"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(arguments (arguments
(list `(#:phases
#:haddock? #f ;The haddock phase fails with: NGLess/CmdArgs.hs:20:1: (modify-phases %standard-phases
;error: parse error on input import (add-before 'configure 'update-constraints
;import Options.Applicative (lambda _
#:phases (substitute* "NGLess.cabal"
#~(modify-phases %standard-phases (("\\b(base)\\s+[^,]+" all dep)
(add-after 'unpack 'create-Versions.hs dep))))
(lambda _ (add-after 'unpack 'create-Versions.hs
(substitute* "Makefile" (lambda _
(("BWA_VERSION = .*") (substitute* "NGLess/Dependencies/Versions.hs"
(string-append "BWA_VERSION = " (("bwaVersion = .+")
#$(package-version bwa) "\n")) (string-append "bwaVersion = \""
(("SAM_VERSION = .*") ,(package-version bwa) "\""))
(string-append "SAM_VERSION = " (("samtoolsVersion = .+")
#$(package-version samtools) "\n")) (string-append "samtoolsVersion = \""
(("PRODIGAL_VERSION = .*") ,(package-version samtools) "\""))
(string-append "PRODIGAL_VERSION = " (("prodigalVersion = .+")
#$(package-version prodigal) "\n")) (string-append "prodigalVersion = \""
(("MINIMAP2_VERSION = .*") ,(package-version prodigal) "\""))
(string-append "MINIMAP2_VERSION = " (("megahitVersion = .+")
#$(package-version minimap2) "\n"))) (string-append "megahitVersion = \""
(invoke "make" "NGLess/Dependencies/Versions.hs"))) ,(package-version megahit) "\""))
(add-after 'create-Versions.hs 'create-cabal-file (("minimap2Version = .+")
(lambda _ (invoke "hpack"))) (string-append "minimap2Version = \""
;; These tools are expected to be installed alongside ngless. ,(package-version minimap2) "\"")))))
(add-after 'install 'link-tools ;; See NGLess/FileManagement.hs.
(lambda* (#:key inputs #:allow-other-keys) (add-after 'install 'wrap-program
(let ((bin (string-append #$output "/bin/"))) (lambda* (#:key inputs outputs #:allow-other-keys)
(symlink (search-input-file inputs "/bin/prodigal") (let* ((out (assoc-ref outputs "out"))
(string-append bin "ngless-" #$version "-prodigal")) (bwa (search-input-file inputs "/bin/bwa"))
(symlink (search-input-file inputs "/bin/minimap2") (samtools (search-input-file inputs "/bin/samtools"))
(string-append bin "ngless-" #$version "-minimap2")) (prodigal (search-input-file inputs "/bin/prodigal"))
(symlink (search-input-file inputs "/bin/samtools") (minimap2 (search-input-file inputs "/bin/minimap2"))
(string-append bin "ngless-" #$version "-samtools")) (megahit (search-input-file inputs "/bin/megahit")))
(symlink (search-input-file inputs "/bin/bwa") (wrap-program (string-append out "/bin/ngless")
(string-append bin "ngless-" #$version "-bwa")))))))) `("NGLESS_BWA_BIN" " " = (,bwa))
(inputs `("NGLESS_SAMTOOLS_BIN" " " = (,samtools))
(list prodigal `("NGLESS_PRODIGAL_BIN" " " = (,prodigal))
bwa `("NGLESS_MINIMAP2_BIN" " " = (,minimap2))
samtools `("NGLESS_MEGAHIT_BIN" " " = (,megahit))))))
minimap2 ;; Sanity check.
ghc-aeson (add-after 'wrap-program 'check-install
ghc-ansi-terminal (lambda* (#:key outputs #:allow-other-keys)
ghc-async (let* ((ngless (string-append (assoc-ref outputs "out") "/bin/ngless")))
ghc-atomic-write (invoke ngless "--check-install")))))))
ghc-bytestring-lexing (inputs (list prodigal
ghc-conduit bwa
ghc-conduit-algorithms samtools
ghc-conduit-extra minimap2
ghc-configurator megahit
ghc-convertible ghc-missingh
ghc-data-default ghc-aeson
ghc-diagrams-core ghc-ansi-terminal
ghc-diagrams-lib ghc-async
ghc-diagrams-svg ghc-atomic-write
ghc-double-conversion ghc-bytestring-lexing
ghc-edit-distance ghc-conduit
ghc-either ghc-conduit-algorithms
ghc-errors ghc-conduit-extra
ghc-extra ghc-configurator
ghc-filemanip ghc-convertible
ghc-file-embed ghc-data-default
ghc-gitrev ghc-edit-distance
ghc-hashtables ghc-either
ghc-http-conduit ghc-errors
ghc-inline-c ghc-extra
ghc-inline-c-cpp ghc-file-embed
ghc-int-interval-map ghc-filemanip
ghc-missingh ghc-hashable
ghc-optparse-applicative ghc-hashtables
ghc-regex ghc-hostname
ghc-safe ghc-http-client
ghc-safeio ghc-http-conduit
ghc-strict ghc-inline-c
ghc-tar ghc-inline-c-cpp
ghc-tar-conduit ghc-int-interval-map
ghc-unliftio ghc-network
ghc-unliftio-core ghc-optparse-applicative
ghc-vector ghc-primitive
ghc-yaml ghc-random-shuffle
ghc-zlib)) ghc-regex
ghc-resourcet
ghc-safe
ghc-stm-chans
ghc-stm-conduit
ghc-strict
ghc-tar
ghc-tar-conduit
ghc-unix-compat
ghc-unliftio
ghc-unliftio-core
ghc-vector
ghc-vector-algorithms
ghc-yaml
ghc-zlib
ghc-bzlib-conduit
ghc-double-conversion
ghc-safeio))
(propagated-inputs (propagated-inputs
(list r-r6 r-hdf5r r-iterators r-itertools r-matrix)) (list r-r6 r-hdf5r r-iterators r-itertools r-matrix))
(native-inputs (native-inputs (list ghc-hunit
(list ghc-hpack ghc-quickcheck
ghc-quickcheck ghc-tasty
ghc-test-framework ghc-tasty-hunit
ghc-test-framework-hunit ghc-tasty-quickcheck
ghc-test-framework-quickcheck2 ghc-tasty-th))
ghc-test-framework-th))
(home-page "https://ngless.embl.de/") (home-page "https://ngless.embl.de/")
(synopsis "DSL for processing next-generation sequencing data") (synopsis "DSL for processing next-generation sequencing data")
(description "Ngless is a domain-specific language for (description "Ngless is a domain-specific language for

166
gnu/packages/dhall.scm
View File

@ -30,108 +30,76 @@
(define-public dhall (define-public dhall
(package (package
(name "dhall") (name "dhall")
(version "1.39.0") (version "1.41.2")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "dhall" version))
(uri (hackage-uri "dhall" version)) (sha256
(sha256 (base32
(base32 "1by2d84fbckspczddl4npfsf89q6nprmbg0i5g8yr1psp0fpl4ab")))) "14m5rrvkid76qnvg0l14xw1mnqclhip3gjrz20g1lp4fd5p056ka"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "dhall"))) (properties '((upstream-name . "dhall")))
(inputs (inputs (list ghc-aeson
(list ghc-aeson ghc-aeson-pretty
ghc-aeson-pretty ghc-ansi-terminal
ghc-ansi-terminal ghc-atomic-write
ghc-atomic-write-0.2.0.7 ghc-base16-bytestring
ghc-case-insensitive ghc-case-insensitive
ghc-cborg ghc-cborg
ghc-cborg-json ghc-cborg-json
ghc-contravariant ghc-contravariant
ghc-data-fix ghc-data-fix
ghc-diff ghc-diff
ghc-dotgen ghc-dotgen
ghc-either ghc-either
ghc-exceptions ghc-half
ghc-half ghc-hashable
ghc-hashable ghc-indexed-traversable
ghc-lens-family-core ghc-lens-family-core
ghc-megaparsec ghc-megaparsec
ghc-memory ghc-mmorph
ghc-mmorph ghc-network-uri
ghc-network-uri ghc-optparse-applicative
ghc-optparse-applicative ghc-parsers
ghc-parsers ghc-parser-combinators
ghc-parser-combinators ghc-prettyprinter
ghc-prettyprinter ghc-prettyprinter-ansi-terminal
ghc-prettyprinter-ansi-terminal ghc-pretty-simple
ghc-pretty-simple ghc-profunctors
ghc-profunctors ghc-repline
ghc-pretty-simple ghc-serialise
ghc-repline ghc-scientific
ghc-serialise ghc-text-manipulate
ghc-scientific ghc-text-short
ghc-text-manipulate ghc-th-lift-instances
ghc-th-lift-instances ghc-unordered-containers
ghc-transformers-compat ghc-uri-encode
ghc-unordered-containers ghc-vector
ghc-uri-encode ghc-cryptohash-sha256
ghc-vector ghc-http-types
ghc-cryptonite ghc-http-client
ghc-http-types ghc-http-client-tls))
ghc-http-client (native-inputs (list ghc-foldl
ghc-http-client-tls)) ghc-generic-random
(native-inputs ghc-quickcheck
(list ghc-foldl ghc-quickcheck-instances
ghc-generic-random-1.3.0.1 ghc-special-values
ghc-quickcheck ghc-spoon
ghc-quickcheck-instances ghc-system-filepath
ghc-semigroups ghc-tasty
ghc-special-values ghc-tasty-expected-failure
ghc-spoon ghc-tasty-hunit
ghc-tasty ghc-tasty-quickcheck
ghc-tasty-expected-failure ghc-tasty-silver
ghc-tasty-hunit ghc-temporary
ghc-tasty-quickcheck ghc-turtle
ghc-tasty-silver ghc-mockery
ghc-turtle ghc-doctest))
ghc-mockery
ghc-doctest))
(arguments (arguments
`(#:phases `(#:tests? #f ; Tries to access httpbin.org
(modify-phases %standard-phases #:cabal-revision ("4"
(add-after 'unpack 'remove-network-tests "0innb3cn98ynb8bd83jdyrm64ij7wcvajg5qcwzdwbyzpr62anfx")))
(lambda _ (home-page "http://hackage.haskell.org/package/dhall")
(with-directory-excursion "dhall-lang/tests"
(for-each
delete-file
'("import/success/customHeadersA.dhall"
"import/success/noHeaderForwardingA.dhall"
"import/success/unit/RemoteAsTextA.dhall"
"import/success/unit/SimpleRemoteA.dhall"
"import/success/unit/asLocation/RemoteChain1A.dhall"
"import/success/unit/asLocation/RemoteChain2A.dhall"
"import/success/unit/asLocation/RemoteChain3A.dhall"
"import/success/unit/asLocation/RemoteChainEnvA.dhall"
"import/success/unit/asLocation/RemoteChainMissingA.dhall"
"type-inference/success/CacheImportsA.dhall"
"type-inference/success/CacheImportsCanonicalizeA.dhall")))
(substitute* "src/Dhall/Tutorial.hs"
(((string-append
"-- >>> input auto "
"\"https://raw.githubusercontent.com/dhall-lang"
"/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/"
"examples/True\" :: IO Bool"))
"")
(((string-append
"-- >>> input auto "
"\"False == "
"https://raw.githubusercontent.com/dhall-lang"
"/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/"
"examples/True\" :: IO Bool"))
""))
#t)))))
(home-page "https://dhall-lang.org/")
(synopsis "Configuration language guaranteed to terminate") (synopsis "Configuration language guaranteed to terminate")
(description (description
"Dhall is an explicitly typed configuration language that is not Turing "Dhall is an explicitly typed configuration language that is not Turing

2
gnu/packages/elm.scm
View File

@ -70,7 +70,7 @@
(add-before 'configure 'update-constraints (add-before 'configure 'update-constraints
(lambda _ (lambda _
(substitute* "elm.cabal" (substitute* "elm.cabal"
(("(ansi-terminal|containers|network|http-client|language-glsl)\\s+[^,]+" all dep) (("(ansi-terminal|bytestring|containers|network|HTTP|http-client|language-glsl)\\s+[^,]+" all dep)
dep))))))) dep)))))))
(inputs (inputs
(list ghc-ansi-terminal (list ghc-ansi-terminal

173
gnu/packages/finance.scm
View File

@ -217,14 +217,13 @@ line client and a client based on Qt.")
(define-public hledger (define-public hledger
(package (package
(name "hledger") (name "hledger")
(version "1.21") (version "1.27.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hledger" version))
(uri (hackage-uri "hledger" version)) (sha256
(sha256 (base32
(base32 "0qdg87m7ys2ykqqq32p7h7aw827w4f5bcqx4dspxxq6zqlvzddqb"))))
"07fcfkmv4cy92njnf2qc7jh0naz96q962hxldcd7hk4k7ddv0mss"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(arguments (arguments
(list (list
@ -235,34 +234,34 @@ line client and a client based on Qt.")
(install-file "hledger.info" (string-append #$output "/share/info")) (install-file "hledger.info" (string-append #$output "/share/info"))
(install-file "hledger.1" (string-append #$output "/man/man1"))))))) (install-file "hledger.1" (string-append #$output "/man/man1")))))))
(properties '((upstream-name . "hledger"))) (properties '((upstream-name . "hledger")))
(inputs (inputs (list ghc-decimal
(list ghc-ansi-terminal ghc-diff
ghc-base-compat-batteries ghc-aeson
ghc-cmdargs ghc-ansi-terminal
ghc-data-default ghc-breakpoint
ghc-decimal ghc-cmdargs
ghc-diff ghc-data-default
ghc-hashable ghc-extra
ghc-hledger-lib ghc-githash
ghc-lucid ghc-hashable
ghc-math-functions ghc-hledger-lib
ghc-megaparsec ghc-lucid
ghc-old-time ghc-math-functions
ghc-regex-tdfa ghc-megaparsec
ghc-safe ghc-microlens
ghc-aeson ghc-regex-tdfa
ghc-extra ghc-safe
ghc-tasty ghc-shakespeare
ghc-timeit ghc-split
ghc-shakespeare ghc-tabular
ghc-split ghc-tasty
ghc-tabular ghc-temporary
ghc-temporary ghc-timeit
ghc-unordered-containers ghc-unordered-containers
ghc-utf8-string ghc-utf8-string
ghc-utility-ht ghc-utility-ht
ghc-wizards)) ghc-wizards))
(home-page "https://hledger.org") (home-page "http://hledger.org")
(synopsis "Command-line interface for the hledger accounting system") (synopsis "Command-line interface for the hledger accounting system")
(description (description
"The command-line interface for the hledger accounting system. Its basic "The command-line interface for the hledger accounting system. Its basic
@ -1969,59 +1968,63 @@ generate a variety of reports from them, and provides a web interface.")
(define-public hledger-web (define-public hledger-web
(package (package
(name "hledger-web") (name "hledger-web")
(version "1.21") (version "1.27.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hledger-web" version))
(uri (hackage-uri "hledger-web" version)) (sha256
(sha256 (base32
(base32 "151dxci7dld8626dzw823sr3d9iaac92wfzbfcbdz4jh9f7n07wa"))))
"0ivszqcypw0j2wn4r7fv7dqm1pvr0b1y6rqpxagzyk8cxn3ic9g2"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hledger-web"))) (properties '((upstream-name . "hledger-web")))
(inputs (list ghc-decimal
ghc-aeson
ghc-base64
ghc-blaze-html
ghc-blaze-markup
ghc-breakpoint
ghc-case-insensitive
ghc-clientsession
ghc-cmdargs
ghc-conduit
ghc-conduit-extra
ghc-data-default
ghc-extra
ghc-hjsmin
hledger
ghc-hledger-lib
ghc-hspec
ghc-http-client
ghc-http-conduit
ghc-http-types
ghc-megaparsec
ghc-network
ghc-shakespeare
ghc-unix-compat
ghc-unordered-containers
ghc-utf8-string
ghc-wai
ghc-wai-cors
ghc-wai-extra
ghc-wai-handler-launch
ghc-warp
ghc-yaml
ghc-yesod
ghc-yesod-core
ghc-yesod-form
ghc-yesod-static
ghc-yesod-test))
(arguments (arguments
`(#:tests? #f ; TODO: fail. (list #:phases
#:cabal-revision #~(modify-phases %standard-phases
("1" "1hnw10ibhbafbsfj5lzlxwjg4cjnqr5bb51n6mqbi30qqabgq78x"))) ;; Tests write to $HOME.
(inputs (add-before 'check 'set-home
(list ghc-aeson (lambda _
ghc-blaze-html (setenv "HOME" "/tmp"))))))
ghc-blaze-markup (home-page "http://hledger.org")
ghc-case-insensitive
ghc-clientsession
ghc-cmdargs
ghc-conduit-extra
ghc-conduit
ghc-data-default
ghc-decimal
ghc-extra
ghc-hjsmin
ghc-hledger-lib
ghc-hspec
ghc-http-client
ghc-http-conduit
ghc-http-types
ghc-megaparsec
ghc-network
ghc-shakespeare
ghc-unix-compat
ghc-unordered-containers
ghc-utf8-string
ghc-wai-cors
ghc-wai-extra
ghc-wai
ghc-wai-handler-launch
ghc-warp
ghc-yaml
ghc-yesod-core
ghc-yesod-form
ghc-yesod
ghc-yesod-static
ghc-yesod-test
hledger))
(home-page "https://hledger.org")
(synopsis "Web-based user interface for the hledger accounting system") (synopsis "Web-based user interface for the hledger accounting system")
(description "This package provides a simple Web-based User (description
"This package provides a simple Web-based User
Interface (UI) for the hledger accounting system. It can be used as a Interface (UI) for the hledger accounting system. It can be used as a
local, single-user UI, or as a multi-user UI for viewing, adding, and local, single-user UI, or as a multi-user UI for viewing, adding, and
editing on the Web.") editing on the Web.")

525
gnu/packages/haskell-apps.scm
View File

@ -61,29 +61,27 @@
(define-public apply-refact (define-public apply-refact
(package (package
(name "apply-refact") (name "apply-refact")
(version "0.9.3.0") (version "0.10.0.0")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "apply-refact" version))
(uri (hackage-uri "apply-refact" version)) (sha256
(sha256 (base32
(base32 "129bf8n66kpwh5420rxprngg43bqr2agyd8q8d7l49k2rxsjl1fb"))))
"1sn5g71sx8xa4ggyk49m661iip6zrzl65vb87l16l31kf79bbm7w"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "apply-refact"))) (properties '((upstream-name . "apply-refact")))
(inputs (inputs (list ghc-refact
(list ghc-refact ghc-exactprint
ghc-exactprint ghc-paths
ghc-syb ghc-extra
ghc-extra ghc-syb
ghc-uniplate ghc-filemanip
ghc-filemanip ghc-uniplate
ghc-unix-compat ghc-unix-compat
ghc-optparse-applicative)) ghc-optparse-applicative))
(native-inputs (native-inputs (list ghc-tasty ghc-tasty-golden ghc-tasty-expected-failure
(list ghc-tasty ghc-tasty-golden ghc-tasty-expected-failure ghc-silently))
ghc-silently)) (home-page "https://github.com/mpickering/apply-refact")
(home-page "https://hackage.haskell.org/package/apply-refact")
(synopsis "Perform refactorings specified by the refact library") (synopsis "Perform refactorings specified by the refact library")
(description (description
"This package lets you perform refactorings specified by the refact "This package lets you perform refactorings specified by the refact
@ -94,43 +92,36 @@ library. It is primarily used with HLint's @code{--refactor} flag.")
;; update this packages after updating GHC. ;; update this packages after updating GHC.
(define-public cabal-install (define-public cabal-install
(package (package
(name "cabal-install") (name "cabal-install")
(version "3.2.0.0") (version "3.6.2.0")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "cabal-install" version))
(uri (hackage-uri "cabal-install" version)) (sha256
(patches (search-patches "cabal-install-base16-bytestring1.0.patch" (base32
"cabal-install-ghc8.10.patch")) "0dihpm4h3xh13vnpvwflnb7v614qdvljycc6ffg5cvhwbwfrxyfw"))))
(sha256
(base32 "1c0cc256bha97aj7l0lf76l5swlnmwcqppiz8l4cl5xgba4mwmd0"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "cabal-install"))) (properties '((upstream-name . "cabal-install")))
(arguments (inputs (list ghc-async
`(#:phases ghc-base16-bytestring
(modify-phases %standard-phases ghc-cryptohash-sha256
(add-before 'configure 'update-constraints ghc-echo
(lambda _ ghc-edit-distance
(substitute* "cabal-install.cabal" ghc-hashable
(("(base|base16-bytestring|random)\\s+[^,]+" all dep) ghc-http
dep))))))) ghc-network-uri
(inputs ghc-random
(list ghc-async ghc-tar
ghc-base16-bytestring ghc-zlib
ghc-cryptohash-sha256 ghc-hackage-security
ghc-echo ghc-regex-base
ghc-edit-distance ghc-regex-posix
ghc-hackage-security ghc-resolv
ghc-hashable ghc-lukko))
ghc-http (arguments
ghc-network-uri `(#:cabal-revision ("2"
ghc-network "1kpgyfl5njxp4c8ax5ziag1bhqvph3h0pn660v3vpxalz8d1j6xv")))
ghc-random (home-page "http://www.haskell.org/cabal/")
ghc-resolv
ghc-tar
ghc-zip-archive
ghc-zlib))
(home-page "https://www.haskell.org/cabal/")
(synopsis "Command-line interface for Cabal and Hackage") (synopsis "Command-line interface for Cabal and Hackage")
(description (description
"The cabal command-line program simplifies the process of managing "The cabal command-line program simplifies the process of managing
@ -153,6 +144,9 @@ installation of Haskell libraries and programs.")
(properties '((upstream-name . "cpphs"))) (properties '((upstream-name . "cpphs")))
(inputs (inputs
(list ghc-polyparse ghc-old-locale ghc-old-time)) (list ghc-polyparse ghc-old-locale ghc-old-time))
(arguments
`(#:cabal-revision ("1"
"1f8jzs8zdh4wwbcq8fy6qqxkv75ypnvsm4yzw49wpr3b9vpnzlha")))
(home-page "https://projects.haskell.org/cpphs/") (home-page "https://projects.haskell.org/cpphs/")
(synopsis "Liberalised re-implementation of cpp, the C pre-processor") (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
(description "Cpphs is a re-implementation of the C pre-processor that is (description "Cpphs is a re-implementation of the C pre-processor that is
@ -170,14 +164,14 @@ unlit literate code files; and an option to turn off macro-expansion.")
(define-public darcs (define-public darcs
(package (package
(name "darcs") (name "darcs")
(version "2.16.4") (version "2.16.5")
(source (source
(origin (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "darcs" version)) (uri (hackage-uri "darcs" version))
(sha256 (sha256
(base32 (base32
"07dygwh6p4fsrlgxmq6r7yvxmf4n2y04izzd30jzqgs0pi9645p4")) "0ar4markr71l9hzrbgcz4q37cf2rf3936i6qi8p827p36v96qg6n"))
(modules '((guix build utils))) (modules '((guix build utils)))
;; Remove time-dependent code for reproducibility. ;; Remove time-dependent code for reproducibility.
(snippet (snippet
@ -203,57 +197,50 @@ unlit literate code files; and an option to turn off macro-expansion.")
(add-before 'configure 'update-constraints (add-before 'configure 'update-constraints
(lambda _ (lambda _
(substitute* "darcs.cabal" (substitute* "darcs.cabal"
(("(constraints)\\s+[^,]+" all dep) (("(attoparsec|base|bytestring|constraints|cryptonite|hashable|memory|regex-tdfa|time)\\s+[^,]+" all dep)
dep)
(("(cryptonite)\\s+[^,]+" all dep)
dep))))))) dep)))))))
(inputs (inputs (list ghc-regex-base
(list ghc-cmdargs ghc-regex-tdfa
ghc-split ghc-regex-applicative
ghc-test-framework-quickcheck2 ghc-fgl
ghc-test-framework-hunit ghc-html
ghc-test-framework ghc-memory
ghc-quickcheck ghc-cryptonite
ghc-constraints ghc-base16-bytestring
ghc-findbin ghc-utf8-string
ghc-hunit ghc-vector
ghc-cryptonite ghc-tar
ghc-http-conduit ghc-data-ordlist
ghc-http-types ghc-attoparsec
ghc-async ghc-zip-archive
ghc-attoparsec ghc-async
ghc-base16-bytestring ghc-constraints
ghc-bytestring-builder ghc-unix-compat
ghc-cryptohash ghc-old-time
ghc-data-ordlist ghc-temporary
ghc-fgl ghc-hashable
ghc-system-filepath ghc-mmap
ghc-graphviz ghc-zlib
ghc-hashable ghc-network-uri
ghc-html ghc-network
ghc-mmap ghc-conduit
ghc-old-time ghc-http-conduit
ghc-random ghc-http-types
ghc-regex-applicative curl))
ghc-regex-compat-tdfa (native-inputs (list ghc-cmdargs
ghc-sandi ghc-findbin
ghc-shelly ghc-quickcheck
ghc-tar ghc-leancheck
ghc-transformers-compat ghc-hunit
ghc-unix-compat ghc-test-framework
ghc-utf8-string ghc-test-framework-hunit
ghc-vector ghc-test-framework-quickcheck2
ghc-zip-archive ghc-test-framework-leancheck
ghc-zlib ghc-monad-control
ghc-http ghc-system-filepath
curl ghc-system-fileio
ghc ghc-transformers-base
ncurses pkg-config))
perl
ghc-network
ghc-network-uri))
(native-inputs
(list pkg-config))
(home-page "http://darcs.net") (home-page "http://darcs.net")
(synopsis "Distributed Revision Control System") (synopsis "Distributed Revision Control System")
(description (description
@ -509,36 +496,39 @@ used to keep a folder in sync between computers.")
(define-public hlint (define-public hlint
(package (package
(name "hlint") (name "hlint")
(version "3.2.7") (version "3.4.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hlint" version))
(uri (hackage-uri "hlint" version)) (sha256
(sha256 (base32
(base32 "0bkk03c9hacvfd73dk89g4r81b50g7pjgw5pavldali4qwss34cz"))))
"0z6gxndrh7blzapkdn6fq1pkbkjlmbgjbq9ydnvy2wm00fb3v73g"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hlint"))) (properties '((upstream-name . "hlint")))
(inputs (inputs (list ghc-unordered-containers
(list ghc-unordered-containers ghc-vector
ghc-yaml ghc-file-embed
ghc-vector ghc-utf8-string
ghc-data-default ghc-data-default
ghc-file-embed cpphs
ghc-utf8-string ghc-cmdargs
cpphs ghc-uniplate
ghc-filepattern ghc-ansi-terminal
ghc-lib-parser-ex ghc-extra
hscolour ghc-refact
ghc-cmdargs ghc-aeson
ghc-uniplate ghc-deriving-aeson
ghc-ansi-terminal ghc-filepattern
ghc-extra ghc-lib-parser-ex
ghc-refact hscolour
ghc-aeson)) ghc-yaml))
(home-page "https://github.com/ndmitchell/hlint") (arguments
`(#:cabal-revision ("1"
"1rdaffg5n179yfcn5zjwjb0bki09qy13gz2ijky455y9pbaz8yz9")))
(home-page "https://github.com/ndmitchell/hlint#readme")
(synopsis "Suggest improvements for Haskell source code") (synopsis "Suggest improvements for Haskell source code")
(description "HLint reads Haskell programs and suggests changes that (description
"HLint reads Haskell programs and suggests changes that
hopefully make them easier to read. HLint also makes it easy to disable hopefully make them easier to read. HLint also makes it easy to disable
unwanted suggestions, and to add your own custom suggestions.") unwanted suggestions, and to add your own custom suggestions.")
(license license:bsd-3))) (license license:bsd-3)))
@ -546,50 +536,50 @@ unwanted suggestions, and to add your own custom suggestions.")
(define-public hoogle (define-public hoogle
(package (package
(name "hoogle") (name "hoogle")
(version "5.0.18.2") (version "5.0.18.3")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hoogle" version))
(uri (sha256
(hackage-uri "hoogle" version)) (base32
(sha256 "0v6k75w0an9pqgb7a6cicnpf9rz77xd2lmxfbafc5l4f99jg83bn"))))
(base32
"1xacx2f33x1a4qlv25f8rlmb4wi0cjfzrj22nlnkrd0knghik3m7"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hoogle"))) (properties '((upstream-name . "hoogle")))
(inputs (inputs (list ghc-quickcheck
(list ghc-quickcheck ghc-aeson
ghc-aeson ghc-blaze-html
ghc-blaze-html ghc-blaze-markup
ghc-blaze-markup ghc-cmdargs
ghc-cmdargs ghc-conduit
ghc-conduit ghc-conduit-extra
ghc-conduit-extra ghc-connection
ghc-connection ghc-extra
ghc-extra ghc-foundation
ghc-foundation ghc-old-locale
ghc-old-locale ghc-hashable
ghc-haskell-src-exts ghc-haskell-src-exts
ghc-http-conduit ghc-http-conduit
ghc-http-types ghc-http-types
ghc-js-flot ghc-js-flot
ghc-js-jquery ghc-js-jquery
ghc-mmap ghc-mmap
ghc-process-extras ghc-process-extras
ghc-resourcet ghc-resourcet
ghc-storable-tuple ghc-storable-tuple
ghc-tar ghc-tar
ghc-uniplate ghc-uniplate
ghc-utf8-string ghc-utf8-string
ghc-vector ghc-vector
ghc-wai ghc-wai
ghc-wai-logger ghc-wai-logger
ghc-warp ghc-warp
ghc-warp-tls ghc-warp-tls
ghc-zlib)) ghc-zlib
ghc-semigroups))
(home-page "https://hoogle.haskell.org/") (home-page "https://hoogle.haskell.org/")
(synopsis "Haskell API Search") (synopsis "Haskell API Search")
(description "Hoogle is a Haskell API search engine, which allows (description
"Hoogle is a Haskell API search engine, which allows
you to search many standard Haskell libraries by either function name, you to search many standard Haskell libraries by either function name,
or by approximate type signature.") or by approximate type signature.")
(license license:bsd-3))) (license license:bsd-3)))
@ -617,90 +607,89 @@ and mIRC chat codes.")
(license license:bsd-3))) (license license:bsd-3)))
(define-public kmonad (define-public kmonad
(package ;; Project is active, but no new releases exist. Pick current master
(name "kmonad") ;; HEAD as of 2023-01-08.
(version "0.4.1") (let ((commit "a0af5b8b3f085adb2c09ca52374a53566c25194c")
(source (revision "1"))
(origin (package
(method git-fetch) (name "kmonad")
(uri (git-reference (version (git-version "0.4.1" revision commit))
(url "https://github.com/david-janssen/kmonad") (source
(commit version))) (origin
(file-name (git-file-name name version)) (method git-fetch)
(sha256 (uri (git-reference
(base32 "1rp880zxvrznx0y1k464wjrds441dpsz94syhrkaw5dnmxf74yjd")))) (url "https://github.com/david-janssen/kmonad")
(build-system haskell-build-system) (commit commit)))
(arguments (file-name (git-file-name name version))
`(#:phases (sha256
(modify-phases %standard-phases (base32 "00qmmk1lgadhh32dqi530xm18v79ndcm7rrxvdsf827vicv2nhw1"))))
(delete 'haddock) ; Haddock fails to generate docs (build-system haskell-build-system)
(add-after 'install 'install-udev-rules (arguments
(lambda* (#:key outputs #:allow-other-keys) `(#:haddock? #f ; Haddock fails to generate docs
(let* ((out (assoc-ref outputs "out")) #:phases
(rules (string-append out "/lib/udev/rules.d"))) (modify-phases %standard-phases
(mkdir-p rules) (add-after 'unpack 'patch-git-path
(call-with-output-file (string-append rules "/70-kmonad.rules") (lambda* (#:key inputs #:allow-other-keys)
(lambda (port) (substitute* "src/KMonad/Args/TH.hs"
(display (("\"git\"")
(string-append (string-append "\"" (search-input-file inputs "/bin/git") "\"")))))
"KERNEL==\"uinput\", MODE=\"0660\", " (add-after 'install 'install-udev-rules
"GROUP=\"input\", OPTIONS+=\"static_node=uinput\"\n") (lambda* (#:key outputs #:allow-other-keys)
port))) (let* ((out (assoc-ref outputs "out"))
#t))) (rules (string-append out "/lib/udev/rules.d")))
(add-after 'install-udev-rules 'install-documentation (mkdir-p rules)
(lambda* (#:key outputs #:allow-other-keys) (call-with-output-file (string-append rules "/70-kmonad.rules")
(let* ((out (assoc-ref outputs "out")) (lambda (port)
(doc (string-append out "/share/doc/kmonad-" ,version))) (display
(install-file "README.md" doc) (string-append
(copy-recursively "doc" doc) "KERNEL==\"uinput\", MODE=\"0660\", "
(copy-recursively "keymap" (string-append doc "/keymap")) "GROUP=\"input\", OPTIONS+=\"static_node=uinput\"\n")
#t)))))) port)))
(inputs #t)))
(list ghc-cereal (add-after 'install-udev-rules 'install-documentation
ghc-exceptions (lambda* (#:key outputs #:allow-other-keys)
ghc-hashable (let* ((out (assoc-ref outputs "out"))
ghc-lens (doc (string-append out "/share/doc/kmonad-" ,version)))
ghc-megaparsec (install-file "README.md" doc)
ghc-optparse-applicative (copy-recursively "doc" doc)
ghc-resourcet (copy-recursively "keymap" (string-append doc "/keymap"))
ghc-rio #t))))))
ghc-unagi-chan (inputs
ghc-unliftio (list ghc-cereal
ghc-unordered-containers)) ghc-exceptions
(home-page "https://github.com/david-janssen/kmonad") ghc-lens
(synopsis "Advanced keyboard manager") ghc-megaparsec
(description "KMonad is a keyboard remapping utility that supports ghc-optparse-applicative
ghc-resourcet
ghc-rio
ghc-unliftio
ghc-unordered-containers
ghc-template-haskell))
(native-inputs (list ghc-hspec hspec-discover git))
(home-page "https://github.com/david-janssen/kmonad")
(synopsis "Advanced keyboard manager")
(description "KMonad is a keyboard remapping utility that supports
advanced functionality, such as custom keymap layers and modifiers, macros, advanced functionality, such as custom keymap layers and modifiers, macros,
and conditional mappings that send a different keycode when tapped or held. and conditional mappings that send a different keycode when tapped or held.
By operating at a lower level than most similar tools, it supports X11, By operating at a lower level than most similar tools, it supports X11,
Wayland, and Linux console environments alike.") Wayland, and Linux console environments alike.")
(license license:expat))) (license license:expat))))
(define-public nixfmt (define-public nixfmt
(package (package
(name "nixfmt") (name "nixfmt")
(version "0.4.0") (version "0.5.0")
(source (source
(origin (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "nixfmt" version)) (uri (hackage-uri "nixfmt" version))
(sha256 (sha256
(base32 "1ispgl8rc2scr6v8bb6sks7px856jf61x74zj2iyddrn5qamkb3n")))) (base32 "0rxi8zrd2xr72w673nvgnhb0g3r7rssc1ahlhz8rmdpc6c1a82wl"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "nixfmt"))) (properties '((upstream-name . "nixfmt")))
(inputs (inputs
(list ghc-megaparsec ghc-parser-combinators ghc-cmdargs (list ghc-megaparsec ghc-parser-combinators ghc-cmdargs
ghc-safe-exceptions)) ghc-safe-exceptions))
(arguments
`(#:cabal-revision
("1" "1hsj0jh6siph3afd9c2wii09sffl48rzqv653n4clpd8qy0rn48d")
#:phases
(modify-phases %standard-phases
(add-before 'configure 'update-constraints
(lambda _
(substitute* "nixfmt.cabal"
(("(base|megaparsec)\\s+[^,]+" all dep)
dep)))))))
(home-page "https://github.com/serokell/nixfmt") (home-page "https://github.com/serokell/nixfmt")
(synopsis "Opinionated formatter for Nix") (synopsis "Opinionated formatter for Nix")
(description (description
@ -711,16 +700,16 @@ formatting by forgetting all existing formatting during parsing.")
(define-public greenclip (define-public greenclip
(package (package
(name "greenclip") (name "greenclip")
(version "3.4") (version "4.2")
(source (source
(origin (origin
(method git-fetch) (method git-fetch)
(uri (git-reference (uri (git-reference
(url "https://github.com/erebe/greenclip") (url "https://github.com/erebe/greenclip")
(commit version))) (commit (string-append "v" version))))
(file-name (git-file-name name version)) (file-name (git-file-name name version))
(sha256 (sha256
(base32 "1baw360dcnyavacf7a8v6wq4m5g6bcmyybkckv4cz7r4xl5p3qws")))) (base32 "10r485q055ci29fmpsjy55n1yqfil53cvdxldlzw2n6mpynmckyv"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(native-inputs (native-inputs
(list pkg-config)) (list pkg-config))
@ -734,6 +723,7 @@ formatting by forgetting all existing formatting during parsing.")
ghc-microlens ghc-microlens
ghc-microlens-mtl ghc-microlens-mtl
ghc-protolude ghc-protolude
ghc-tomland
ghc-vector ghc-vector
ghc-wordexp)) ghc-wordexp))
(home-page "https://github.com/erebe/greenclip") (home-page "https://github.com/erebe/greenclip")
@ -929,34 +919,31 @@ output, stderr, and exit status.")
(define-public stylish-haskell (define-public stylish-haskell
(package (package
(name "stylish-haskell") (name "stylish-haskell")
(version "0.13.0.0") (version "0.14.3.0")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "stylish-haskell" version))
(uri (sha256
(hackage-uri "stylish-haskell" version)) (base32
(sha256 "17w92v0qnwj7m6yqdq5cxbr04xiz0yfnnyx5q54218wdl7n5lf6d"))))
(base32
"0x9w3zh1lzp6l5xj3mynnlr0fzb5mbv0wwpfxp8fr6bk0jcrzjwf"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "stylish-haskell"))) (properties '((upstream-name . "stylish-haskell")))
(inputs (inputs (list ghc-aeson
(list ghc-aeson ghc-file-embed
ghc-file-embed ghc-regex-tdfa
ghc-haskell-src-exts ghc-syb
ghc-semigroups ghc-hsyaml-aeson
ghc-syb ghc-hsyaml
ghc-hsyaml ghc-semigroups
ghc-hsyaml-aeson ghc-lib-parser-ex
ghc-lib-parser ghc-strict
ghc-strict ghc-optparse-applicative))
ghc-optparse-applicative (native-inputs (list ghc-hunit ghc-random ghc-test-framework
ghc-hunit ghc-test-framework-hunit))
ghc-test-framework (home-page "https://github.com/haskell/stylish-haskell")
ghc-test-framework-hunit))
(home-page "https://github.com/jaspervdj/stylish-haskell")
(synopsis "Haskell code prettifier") (synopsis "Haskell code prettifier")
(description "Stylish-haskell is a Haskell code prettifier. The goal is (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\". 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 However, this tool can e.g. clean up import statements and help doing various
tasks that get tedious very quickly. It can tasks that get tedious very quickly. It can

594
gnu/packages/haskell-check.scm
View File

@ -90,25 +90,19 @@ Haskell test framework.")
(define-public ghc-tasty-quickcheck (define-public ghc-tasty-quickcheck
(package (package
(name "ghc-tasty-quickcheck") (name "ghc-tasty-quickcheck")
(version "0.10.1.2") (version "0.10.2")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty-quickcheck" version))
(uri (hackage-uri "tasty-quickcheck" version)) (sha256
(sha256 (base32
(base32 "1qnc6rdvjvlw08q6sln2n98rvj0s0pp689h6w4z58smjbn0lr25l"))))
"0i1i78587znqzwps49milyr5n2k388ld2kr9ysz1vw8gcw51qq49"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty-quickcheck"))) (properties '((upstream-name . "tasty-quickcheck")))
(inputs (inputs (list ghc-tagged ghc-tasty ghc-random ghc-quickcheck
(list ghc-quickcheck ghc-optparse-applicative))
ghc-tagged (native-inputs (list ghc-tasty-hunit ghc-pcre-light))
ghc-tasty (home-page "https://github.com/UnkindPartition/tasty")
ghc-random
ghc-ansi-terminal
ghc-tasty-hunit
ghc-pcre-light))
(home-page "http://documentup.com/feuerbach/tasty")
(synopsis "QuickCheck support for the Tasty test framework") (synopsis "QuickCheck support for the Tasty test framework")
(description "This package provides QuickCheck support for the Tasty (description "This package provides QuickCheck support for the Tasty
Haskell test framework.") Haskell test framework.")
@ -117,26 +111,23 @@ Haskell test framework.")
(define-public ghc-tasty-golden (define-public ghc-tasty-golden
(package (package
(name "ghc-tasty-golden") (name "ghc-tasty-golden")
(version "2.3.4") (version "2.3.5")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty-golden" version))
(uri (hackage-uri "tasty-golden" version)) (sha256
(sha256 (base32
(base32 "03klnxn9rcv0l7fl4w8q6s59fzl1328j1wzwi1za4gb0l90vadwb"))))
"1nskavqgfxx1cw7q6c0cmizlwj54rnlv93yhgssaa77gv1nbvwpn"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty-golden"))) (properties '((upstream-name . "tasty-golden")))
(inputs (inputs (list ghc-tasty
(list ghc-async ghc-typed-process
ghc-optparse-applicative ghc-optparse-applicative
ghc-tagged ghc-temporary
ghc-tasty ghc-tagged
ghc-temporary ghc-async))
ghc-unix-compat))
(native-inputs (list ghc-tasty-hunit)) (native-inputs (list ghc-tasty-hunit))
(home-page (home-page "https://github.com/UnkindPartition/tasty-golden")
"https://github.com/feuerbach/tasty-golden")
(synopsis "Golden tests support for tasty") (synopsis "Golden tests support for tasty")
(description (description
"This package provides support for @code{golden testing}. A @dfn{golden "This package provides support for @code{golden testing}. A @dfn{golden
@ -148,28 +139,20 @@ contains the correct result for the test.")
(define-public ghc-tasty (define-public ghc-tasty
(package (package
(name "ghc-tasty") (name "ghc-tasty")
(version "1.4.2") (version "1.4.3")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty" version))
(uri (hackage-uri "tasty" version)) (sha256
(sha256 (base32
(base32 "006bf4gyc30i2gvb17hj1mzrh1kwnwf7l050x3f72wi6c2axl87l"))))
"0574hbqzxzyv6vsk5kzbf04kz58y0iy8x9ydcj4b8fpncgmgy63g"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty"))) (properties '((upstream-name . "tasty")))
(inputs (inputs (list ghc-tagged ghc-optparse-applicative ghc-ansi-terminal))
(list ghc-tagged (home-page "https://github.com/UnkindPartition/tasty")
ghc-regex-tdfa
ghc-optparse-applicative
ghc-unbounded-delays
ghc-async
ghc-ansi-terminal
ghc-clock-bootstrap
ghc-wcwidth-bootstrap))
(home-page "http://documentup.com/feuerbach/tasty")
(synopsis "Modern and extensible testing framework") (synopsis "Modern and extensible testing framework")
(description "Tasty is a modern testing framework for Haskell. It lets (description
"Tasty is a modern testing framework for Haskell. It lets
you combine your unit tests, golden tests, QuickCheck/SmallCheck properties, you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
and any other types of tests into a single test suite.") and any other types of tests into a single test suite.")
(license license:expat))) (license license:expat)))
@ -177,23 +160,21 @@ and any other types of tests into a single test suite.")
(define-public ghc-tasty-hedgehog (define-public ghc-tasty-hedgehog
(package (package
(name "ghc-tasty-hedgehog") (name "ghc-tasty-hedgehog")
(version "1.1.0.0") (version "1.3.1.0")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty-hedgehog" version))
(uri (hackage-uri "tasty-hedgehog" version)) (sha256
(sha256 (base32
(base32 "1iq452mvd9wc9pfmjsmm848jwp3cvsk1faf2mlr21vcs0yaxvq3m"))))
"0cy49z8n124xh2ra2482vfy5if1n6d9lbdjma2zg1mxfj0k0zyfb"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty-hedgehog"))) (properties '((upstream-name . "tasty-hedgehog")))
(inputs (inputs (list ghc-tagged ghc-tasty ghc-hedgehog))
(list ghc-tagged ghc-tasty ghc-hedgehog)) (native-inputs (list ghc-tasty-expected-failure))
(native-inputs
(list ghc-tasty-expected-failure))
(home-page "https://github.com/qfpl/tasty-hedgehog") (home-page "https://github.com/qfpl/tasty-hedgehog")
(synopsis "Integration for tasty and hedgehog") (synopsis "Integration for tasty and hedgehog")
(description "This package provides the means for integrating the (description
"This package provides the means for integrating the
@url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library} @url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library}
with the @url{https://hackage.haskell.org/package/tasty, tasty testing with the @url{https://hackage.haskell.org/package/tasty, tasty testing
framework}.") framework}.")
@ -202,31 +183,27 @@ framework}.")
(define-public ghc-tasty-hspec (define-public ghc-tasty-hspec
(package (package
(name "ghc-tasty-hspec") (name "ghc-tasty-hspec")
(version "1.1.6") (version "1.2.0.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty-hspec" version))
(uri (hackage-uri "tasty-hspec" version)) (sha256
(sha256 (base32
(base32 "0ibl2xi6mmqad2mriz67nb7pjwwvjik385amp24j9kc7a7zkx091"))))
"02s82ijs2ringqxsqbm7m3vcy5brmwxa617azxv0v2phi3rdkjvl"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty-hspec"))) (properties '((upstream-name . "tasty-hspec")))
(inputs (inputs (list ghc-hspec
(list ghc-hspec ghc-hspec-core
ghc-hspec-core ghc-quickcheck
ghc-quickcheck ghc-tasty
ghc-tagged ghc-tasty-smallcheck
ghc-tasty ghc-tasty-quickcheck
ghc-tasty-smallcheck ghc-tagged))
ghc-tasty-quickcheck))
(arguments (arguments
`(#:cabal-revision `(#:cabal-revision ("1"
("1" "0za15rg0szacxq9yfxxjzddr77ai7ng5827a20pj9dr5anjlnajj"))) "0a6r4gzxzp6n90z0nif7ha7p7am57hs48i54i2y4z9kgjv6lnvll")))
(home-page (home-page "https://github.com/mitchellwrosen/tasty-hspec")
"https://github.com/mitchellwrosen/tasty-hspec") (synopsis "Hspec support for the Tasty test framework")
(synopsis
"Hspec support for the Tasty test framework")
(description (description
"This package provides a Tasty provider for Hspec test suites.") "This package provides a Tasty provider for Hspec test suites.")
(license license:bsd-3))) (license license:bsd-3)))
@ -276,21 +253,23 @@ tasty.")
(define-public ghc-tasty-lua (define-public ghc-tasty-lua
(package (package
(name "ghc-tasty-lua") (name "ghc-tasty-lua")
(version "0.2.3.2") (version "1.0.2")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty-lua" version))
(uri (hackage-uri "tasty-lua" version)) (sha256
(sha256 (base32
(base32 "1vnyvgcjsvqhwwyqkbgqksr9ppj5whiihpwcqkg33sl7jj3ysdwv"))))
"0wa73ihkjcxi50lgpdzwwdx7s903lqi79hw7hxlvhbcvdly1cq53"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty-lua"))) (properties '((upstream-name . "tasty-lua")))
(inputs (inputs (list ghc-hslua-core
(list ghc-file-embed ghc-hslua ghc-tasty)) ghc-hslua-marshalling
(native-inputs ghc-lua-arbitrary
(list ghc-tasty-hunit)) ghc-tasty
(home-page "https://github.com/hslua/tasty-lua") ghc-quickcheck
ghc-file-embed))
(native-inputs (list ghc-tasty-hunit))
(home-page "https://github.com/hslua/hslua")
(synopsis "Write tests in Lua, integrate into tasty") (synopsis "Write tests in Lua, integrate into tasty")
(description "This package gives users the ability to define tasty tests (description "This package gives users the ability to define tasty tests
from Lua.") from Lua.")
@ -335,6 +314,9 @@ test-framework.")
(inputs (inputs
(list ghc-optparse-applicative ghc-reducers ghc-split ghc-tagged (list ghc-optparse-applicative ghc-reducers ghc-split ghc-tagged
ghc-tasty)) ghc-tasty))
(arguments
`(#:cabal-revision ("3"
"0091arn90cx5rzn5n2bpb9alzybwraf9yj7hb0bwdfyamzpf3pkb")))
(home-page "https://github.com/ocharles/tasty-rerun") (home-page "https://github.com/ocharles/tasty-rerun")
(synopsis "Run tests by filtering the test tree") (synopsis "Run tests by filtering the test tree")
(description "This package adds the ability to run tests by filtering the (description "This package adds the ability to run tests by filtering the
@ -376,37 +358,35 @@ development.")
(define-public ghc-quickcheck-instances (define-public ghc-quickcheck-instances
(package (package
(name "ghc-quickcheck-instances") (name "ghc-quickcheck-instances")
(version "0.3.25.2") (version "0.3.28")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "quickcheck-instances" version))
(uri (hackage-uri "quickcheck-instances" version)) (sha256
(sha256 (base32
(base32 "1jycijv7gaj6qrkp219nllrdv9zd0ifp0mb0rch430fm95xin4f4"))))
"0ihqbarl2ddrfgq3mq09lswwn8213qpw13g49qxs5mjkcm6gbk3h"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "quickcheck-instances"))) (properties '((upstream-name . "quickcheck-instances")))
(arguments (inputs (list ghc-quickcheck
`(#:cabal-revision ghc-splitmix
("2" "1lsa3pbg4ljlk29fhm3mdklnx3hwffyga1nr5krbpcyc3ywq8fq8"))) ghc-case-insensitive
(inputs ghc-data-fix
(list ghc-case-insensitive ghc-hashable
ghc-data-fix ghc-integer-logarithms
ghc-hashable ghc-old-time
ghc-integer-logarithms ghc-onetuple
ghc-old-time ghc-primitive
ghc-quickcheck ghc-scientific
ghc-scientific ghc-strict
ghc-splitmix ghc-tagged
ghc-strict ghc-these
ghc-tagged ghc-time-compat
ghc-these ghc-transformers-compat
ghc-time-compat ghc-unordered-containers
ghc-transformers-compat ghc-uuid-types
ghc-unordered-containers ghc-vector
ghc-uuid-types ghc-text-short))
ghc-vector)) (home-page "https://github.com/haskellari/qc-instances")
(home-page "https://github.com/aslatter/qc-instances")
(synopsis "Common quickcheck instances") (synopsis "Common quickcheck instances")
(description "This package provides QuickCheck instances for types (description "This package provides QuickCheck instances for types
provided by the Haskell Platform.") provided by the Haskell Platform.")
@ -521,8 +501,8 @@ HUnit.")
`(#:tests? #f ; FIXME: Tests do not build. `(#:tests? #f ; FIXME: Tests do not build.
#:cabal-revision #:cabal-revision
("6" "0wbq9wiaag69nsqxwijzhs5y1hb9kbpkp1x65dvx158cxp8i9w9r"))) ("6" "0wbq9wiaag69nsqxwijzhs5y1hb9kbpkp1x65dvx158cxp8i9w9r")))
(native-inputs ;(native-inputs
(list ghc-hunit ghc-quickcheck)) ; (list ghc-hunit ghc-quickcheck))
(inputs (inputs
`(("ghc-ansi-terminal" ,ghc-ansi-terminal) `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
@ -673,19 +653,17 @@ JUnit tool for Java.")
(define-public hspec-discover (define-public hspec-discover
(package (package
(name "hspec-discover") (name "hspec-discover")
(version "2.7.10") (version "2.9.7")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hspec-discover" version))
(uri (hackage-uri "hspec-discover" version)) (sha256
(sha256 (base32
(base32 "0536kdxjw6p8b6gcwvmr22jbmb6cgzbddi0fkd01b2m847z37sb5"))))
"13yzvd3b679skvs1insk4s0wc4zvmz6hs38kc8q0j6vzqq06smqa"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hspec-discover"))) (properties '((upstream-name . "hspec-discover")))
(native-inputs (native-inputs (list ghc-quickcheck ghc-hspec-meta ghc-mockery-bootstrap))
(list ghc-quickcheck ghc-hspec-meta)) (home-page "http://hspec.github.io/")
(home-page "https://hspec.github.io/")
(synopsis "Automatically discover and run Hspec tests") (synopsis "Automatically discover and run Hspec tests")
(description "hspec-discover is a tool which automatically discovers and (description "hspec-discover is a tool which automatically discovers and
runs Hspec tests.") runs Hspec tests.")
@ -694,28 +672,28 @@ runs Hspec tests.")
(define-public ghc-hspec-core (define-public ghc-hspec-core
(package (package
(name "ghc-hspec-core") (name "ghc-hspec-core")
(version "2.7.10") (version "2.9.7")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hspec-core" version))
(uri (hackage-uri "hspec-core" version)) (sha256
(sha256 (base32
(base32 "040rzqiqwkp373jjpij8lkmv08pp2ya92zzcf95bw8px215rp08n"))))
"12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hspec-core"))) (properties '((upstream-name . "hspec-core")))
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. (inputs (list ghc-hunit
(inputs ghc-quickcheck
(list ghc-setenv ghc-ansi-terminal
ghc-ansi-terminal ghc-call-stack
ghc-clock ghc-clock
ghc-quickcheck-io ghc-hspec-expectations
ghc-hunit ghc-quickcheck-io
ghc-quickcheck ghc-random
ghc-hspec-expectations ghc-setenv
ghc-silently ghc-tf-random))
ghc-tf-random)) (native-inputs (list ghc-base-orphans-bootstrap ghc-hspec-meta
(home-page "https://hspec.github.io/") ghc-silently-bootstrap ghc-temporary))
(home-page "http://hspec.github.io/")
(synopsis "Testing framework for Haskell") (synopsis "Testing framework for Haskell")
(description "This library exposes internal types and functions that can (description "This library exposes internal types and functions that can
be used to extend Hspec's functionality.") be used to extend Hspec's functionality.")
@ -724,26 +702,23 @@ be used to extend Hspec's functionality.")
(define-public ghc-hspec-meta (define-public ghc-hspec-meta
(package (package
(name "ghc-hspec-meta") (name "ghc-hspec-meta")
(version "2.7.8") (version "2.9.3")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hspec-meta" version))
(uri (hackage-uri "hspec-meta" version)) (sha256
(sha256 (base32
(base32 "1raxwpsmcijl3x2h5naw6aydhbiknxvhj3x7v384bi1rqi51ainm"))))
"0sfj0n2hy1r8ifysgbcmfdygcd7vyzr13ldkcp0l2ml337f8j0si"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hspec-meta"))) (properties '((upstream-name . "hspec-meta")))
(inputs (inputs (list ghc-quickcheck
(list ghc-quickcheck ghc-ansi-terminal
ghc-hunit ghc-call-stack-boot
ghc-ansi-terminal ghc-clock
ghc-clock ghc-quickcheck-io
ghc-hspec-expectations ghc-random
ghc-setenv ghc-setenv))
ghc-random (home-page "http://hspec.github.io/")
ghc-quickcheck-io))
(home-page "https://hspec.github.io/")
(synopsis "Version of Hspec to test Hspec itself") (synopsis "Version of Hspec to test Hspec itself")
(description "This library provides a stable version of Hspec which is (description "This library provides a stable version of Hspec which is
used to test the in-development version of Hspec.") used to test the in-development version of Hspec.")
@ -752,26 +727,18 @@ used to test the in-development version of Hspec.")
(define-public ghc-hspec (define-public ghc-hspec
(package (package
(name "ghc-hspec") (name "ghc-hspec")
(version "2.7.10") (version "2.9.7")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hspec" version))
(uri (hackage-uri "hspec" version)) (sha256
(sha256 (base32
(base32 "092sfqjkargxxszp9jjqa8ldjz0xv34jwn6k21q59ys5ckvsrpc1"))))
"0z0lwrmrqkglr78n6k2c36n4h68142bh785ys0x4jaibjshvs6rw"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hspec"))) (properties '((upstream-name . "hspec")))
(outputs '("out" "static" "doc")) (inputs (list ghc-quickcheck ghc-hspec-core hspec-discover
(inputs ghc-hspec-expectations))
(list ghc-hspec-core (home-page "http://hspec.github.io/")
hspec-discover
ghc-hspec-expectations
ghc-quickcheck
ghc-hunit
ghc-stringbuilder
ghc-hspec-meta))
(home-page "https://hspec.github.io/")
(synopsis "Testing Framework for Haskell") (synopsis "Testing Framework for Haskell")
(description "This library provides the Hspec testing framework for (description "This library provides the Hspec testing framework for
Haskell, inspired by the Ruby library RSpec.") Haskell, inspired by the Ruby library RSpec.")
@ -780,23 +747,21 @@ Haskell, inspired by the Ruby library RSpec.")
(define-public ghc-hspec-contrib (define-public ghc-hspec-contrib
(package (package
(name "ghc-hspec-contrib") (name "ghc-hspec-contrib")
(version "0.5.1") (version "0.5.1.1")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "hspec-contrib" version)) (uri (hackage-uri "hspec-contrib" version))
(sha256 (sha256
(base32 (base32
"0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc")))) "1nyb5n2jiq920yyf3flzyxrs5xpfyppl3jn18zhviyysjjk5drpx"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hspec-contrib"))) (properties '((upstream-name . "hspec-contrib")))
(inputs (inputs (list ghc-hunit ghc-hspec-core))
(list ghc-hspec-core ghc-hunit ghc-hspec ghc-quickcheck)) (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover))
(native-inputs (arguments (list #:tests? #f)) ; Tests fail to compile.
(list hspec-discover)) (home-page "http://hspec.github.io/")
(home-page "https://hspec.github.io/")
(synopsis "Contributed functionality for Hspec") (synopsis "Contributed functionality for Hspec")
(description (description "This package provides contributed Hspec extensions.")
"This package provides contributed Hspec extensions.")
(license license:expat))) (license license:expat)))
(define-public ghc-hspec-expectations (define-public ghc-hspec-expectations
@ -834,8 +799,8 @@ Haskell, inspired by the Ruby library RSpec.")
"1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g")))) "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "nanospec"))) (properties '((upstream-name . "nanospec")))
(inputs (inputs (list ghc-silently-bootstrap))
(list ghc-hspec ghc-silently)) (native-inputs (list ghc-hspec))
(home-page "https://github.com/hspec/nanospec#readme") (home-page "https://github.com/hspec/nanospec#readme")
(synopsis "Lightweight implementation of a subset of Hspec's API") (synopsis "Lightweight implementation of a subset of Hspec's API")
(description (description
@ -843,6 +808,14 @@ Haskell, inspired by the Ruby library RSpec.")
minimal dependencies.") minimal dependencies.")
(license license:expat))) (license license:expat)))
(define-public ghc-nanospec-bootstrap
(package
(inherit ghc-nanospec)
(name "ghc-nanospec-bootstrap")
(arguments '(#:tests? #f))
(native-inputs '())
(properties '((hidden? #t)))))
(define-public ghc-crypto-cipher-tests (define-public ghc-crypto-cipher-tests
(package (package
(name "ghc-crypto-cipher-tests") (name "ghc-crypto-cipher-tests")
@ -874,31 +847,29 @@ implementations of cryptographic ciphers.")
(define-public ghc-hedgehog (define-public ghc-hedgehog
(package (package
(name "ghc-hedgehog") (name "ghc-hedgehog")
(version "1.0.5") (version "1.1.2")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "hedgehog" version))
(uri (hackage-uri "hedgehog" version)) (sha256
(sha256 (base32
(base32 "0dbk75hk6hqpzkjdlpw3s63qhm42kqigij33p321by6xndb59jg1"))))
"1qsqs8lmxa3wmw228cwi98vvvh9hqbc9d43i1sy2c9igw9xlhfi6"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "hedgehog"))) (properties '((upstream-name . "hedgehog")))
(inputs (inputs (list ghc-ansi-terminal
(list ghc-ansi-terminal ghc-async
ghc-async ghc-barbies
ghc-concurrent-output ghc-concurrent-output
ghc-erf ghc-erf
;("ghc-exceptions" ,ghc-exceptions) ghc-lifted-async
ghc-lifted-async ghc-mmorph
ghc-mmorph ghc-monad-control
ghc-monad-control ghc-pretty-show
ghc-pretty-show ghc-primitive
ghc-primitive ghc-random
ghc-random ghc-resourcet
ghc-resourcet ghc-transformers-base
ghc-transformers-base ghc-wl-pprint-annotated))
ghc-wl-pprint-annotated))
(home-page "https://hedgehog.qa") (home-page "https://hedgehog.qa")
(synopsis "Property-based testing in the spirt of QuickCheck") (synopsis "Property-based testing in the spirt of QuickCheck")
(description (description
@ -910,23 +881,30 @@ To get started quickly, see the examples:
@uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}") @uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}")
(license license:bsd-3))) (license license:bsd-3)))
;; Deprecated. Don’t use.
(define-public cabal-doctest (define-public cabal-doctest
(package (package
(name "cabal-doctest") (name "cabal-doctest")
(version "1.0.8") (version "1.0.9")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "cabal-doctest" version))
(uri (hackage-uri "cabal-doctest" version)) (sha256
(sha256 (base32
(base32 "0wxs0xkspc80h0g8ks792lrzldxvcnhc9rja1j0k678ijs20hmjm"))))
"03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "cabal-doctest"))) (properties '((upstream-name . "cabal-doctest")))
(arguments (arguments
`(#:cabal-revision `(#:cabal-revision ("2"
("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb"))) "0868js0qgfhvmyw4hjzrvmlzyqsm8dfsbmqhybxb90x44xi3r0i1")
(home-page "https://github.com/phadej/cabal-doctest") #:phases
(modify-phases %standard-phases
(add-before 'configure 'update-constraints
(lambda _
(substitute* "cabal-doctest.cabal"
(("\\b(Cabal|base)\\s+[^,]+" all dep)
dep)))))))
(home-page "https://github.com/haskellari/cabal-doctest")
(synopsis "Setup.hs helper for running doctests") (synopsis "Setup.hs helper for running doctests")
(description (description
"To properly work, the @code{doctest} package needs plenty of "To properly work, the @code{doctest} package needs plenty of
@ -934,6 +912,10 @@ configuration. This library provides the common bits for writing custom
@file{Setup.hs} files.") @file{Setup.hs} files.")
(license license:bsd-3))) (license license:bsd-3)))
;; Deprecated. Don’t use.
(define-public ghc-cabal-doctest
(deprecated-package "ghc-cabal-doctest" cabal-doctest))
(define-public ghc-testing-type-modifiers (define-public ghc-testing-type-modifiers
(package (package
(name "ghc-testing-type-modifiers") (name "ghc-testing-type-modifiers")
@ -959,22 +941,20 @@ testing frameworks.")
(define-public ghc-testing-feat (define-public ghc-testing-feat
(package (package
(name "ghc-testing-feat") (name "ghc-testing-feat")
(version "1.1.0.0") (version "1.1.1.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "testing-feat" version))
(uri (hackage-uri "testing-feat" version)) (sha256
(sha256 (base32
(base32 "14d6licgrkiw36xj1cshnqxcbx5iwzxwq731xlb1wb5n2sw8ijf2"))))
"1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "testing-feat"))) (properties '((upstream-name . "testing-feat")))
(inputs (inputs (list ghc-quickcheck ghc-size-based ghc-testing-type-modifiers))
(list ghc-quickcheck ghc-size-based ghc-testing-type-modifiers (home-page "https://github.com/size-based/testing-feat")
ghc-semigroups))
(home-page "https://github.com/JonasDuregard/testing-feat")
(synopsis "Functional Enumeration of Algebraic Types") (synopsis "Functional Enumeration of Algebraic Types")
(description "Feat (Functional Enumeration of Algebraic Types) (description
"Feat (Functional Enumeration of Algebraic Types)
provides enumerations as functions from natural numbers to provides enumerations as functions from natural numbers to
values (similar to @code{toEnum} but for any algebraic data type). This values (similar to @code{toEnum} but for any algebraic data type). This
can be used for SmallCheck-style systematic testing, QuickCheck-style can be used for SmallCheck-style systematic testing, QuickCheck-style
@ -984,18 +964,16 @@ random testing, and hybrids of the two.")
(define-public ghc-inspection-testing (define-public ghc-inspection-testing
(package (package
(name "ghc-inspection-testing") (name "ghc-inspection-testing")
(version "0.4.6.0") (version "0.4.6.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "inspection-testing" version))
(uri (hackage-uri "inspection-testing" version)) (sha256
(sha256 (base32
(base32 "0mxff0v3ciccbk4b8kxnh4752fzbwn7213qd8xji0csv6gi2w83y"))))
"0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "inspection-testing"))) (properties '((upstream-name . "inspection-testing")))
(home-page (home-page "https://github.com/nomeata/inspection-testing")
"https://github.com/nomeata/inspection-testing")
(synopsis "GHC plugin to do inspection testing") (synopsis "GHC plugin to do inspection testing")
(description (description
"Some carefully crafted libraries make promises to their users beyond "Some carefully crafted libraries make promises to their users beyond
@ -1133,6 +1111,9 @@ these constraints more cleanly.")
(properties '((upstream-name . "doctest-exitcode-stdio"))) (properties '((upstream-name . "doctest-exitcode-stdio")))
(inputs (inputs
(list ghc-doctest-lib ghc-quickcheck ghc-semigroups)) (list ghc-doctest-lib ghc-quickcheck ghc-semigroups))
(arguments
`(#:cabal-revision ("1"
"1065s8bch6zhl6mc8nhvfpwd1irmjd04z7xgycbpihc14x4ijim3")))
(home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/") (home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/")
(synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environment") (synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environment")
(description (description
@ -1140,55 +1121,33 @@ these constraints more cleanly.")
environment.") environment.")
(license license:bsd-3))) (license license:bsd-3)))
(define-public ghc-cabal-doctest
(package
(name "ghc-cabal-doctest")
(version "1.0.8")
(source
(origin
(method url-fetch)
(uri (hackage-uri "cabal-doctest" version))
(sha256
(base32 "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
(build-system haskell-build-system)
(properties '((upstream-name . "cabal-doctest")))
(arguments
`(#:cabal-revision
("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
(home-page "https://github.com/phadej/cabal-doctest")
(synopsis "@file{Setup.hs} helper for Doctests running")
(description
"This package provides helpers for running Doctests in @file{Setup.hs}.")
(license license:bsd-3)))
(define-public ghc-tasty-silver (define-public ghc-tasty-silver
(package (package
(name "ghc-tasty-silver") (name "ghc-tasty-silver")
(version "3.2.3") (version "3.3.1.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "tasty-silver" version))
(uri (hackage-uri "tasty-silver" version)) (sha256
(sha256 (base32
(base32 "0nvh2k8iqqkanmp7lpwd3asimyarzisly8wavbdahcxryn0j4xb7")))) "13j0zs0ciijv9q2nncna1gbgsgw2g7xc228hzmqic1750n3ybz9m"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tasty-silver"))) (properties '((upstream-name . "tasty-silver")))
(inputs (inputs (list ghc-ansi-terminal
(list ghc-ansi-terminal ghc-async
ghc-async ghc-optparse-applicative
ghc-optparse-applicative ghc-process-extras
ghc-process-extras ghc-regex-tdfa
ghc-regex-tdfa ghc-silently
ghc-semigroups ghc-tagged
ghc-tagged ghc-tasty
ghc-tasty ghc-temporary
ghc-temporary)) ghc-semigroups))
(native-inputs (native-inputs (list ghc-tasty-hunit))
(list ghc-tasty-hunit ghc-silently))
(home-page "https://github.com/phile314/tasty-silver") (home-page "https://github.com/phile314/tasty-silver")
(synopsis "Fancy test runner, including support for golden tests") (synopsis "Fancy test runner, including support for golden tests")
(description (description
"This package provides a fancy test runner and support for @dfn{golden "This package provides a fancy test runner and support for @dfn{golden
testing}. A golden test is an IO action that writes its result to a file. To testing}. A golden test is an IO action that writes its result to a file. To
pass the test, this output file should be identical to the corresponding pass the test, this output file should be identical to the corresponding
``golden'' file, which contains the correct result for the test. The test ``golden'' file, which contains the correct result for the test. The test
@ -1196,3 +1155,22 @@ runner allows filtering tests using regexes, and to interactively inspect the
result of golden tests.") result of golden tests.")
(license license:expat))) (license license:expat)))
(define-public ghc-tasty-inspection-testing
(package
(name "ghc-tasty-inspection-testing")
(version "0.1.0.1")
(source (origin
(method url-fetch)
(uri (hackage-uri "tasty-inspection-testing" version))
(sha256
(base32
"0p46w44f19w7lvdzyg3vq6qzix0rjp8p23ilxz82dviq38lgmifp"))))
(build-system haskell-build-system)
(properties '((upstream-name . "tasty-inspection-testing")))
(inputs (list ghc-inspection-testing ghc-tasty))
(home-page "https://github.com/Bodigrim/tasty-inspection-testing")
(synopsis "Inspection testing support for tasty")
(description
"Integrate @@inspection-testing@@ into @@tasty@@ test suites.")
(license license:expat)))

223
gnu/packages/haskell-crypto.scm
View File

@ -27,6 +27,7 @@
#:use-module (gnu packages haskell) #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check) #:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-xyz) #:use-module (gnu packages haskell-xyz)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages tls) #:use-module (gnu packages tls)
#:use-module (guix build-system haskell) #:use-module (guix build-system haskell)
#:use-module (guix download) #:use-module (guix download)
@ -209,25 +210,24 @@ that hides the C implementation.")
(define-public ghc-cryptohash-sha1 (define-public ghc-cryptohash-sha1
(package (package
(name "ghc-cryptohash-sha1") (name "ghc-cryptohash-sha1")
(version "0.11.100.1") (version "0.11.101.0")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "cryptohash-sha1" version))
(uri (hackage-uri "cryptohash-sha1" version)) (sha256
(sha256 (base32
(base32 "0h9jl9v38gj0vnscqx7xdklk634p05fa6z2pcvknisq2mnbjq154"))))
"1aqdxdhxhl9jldh951djpwxx8z7gzaqspxl7iwpl84i5ahrsyy9w"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "cryptohash-sha1"))) (properties '((upstream-name . "cryptohash-sha1")))
(arguments
`(#:cabal-revision
("6" "10rpxrmqgwihmplczglwxf5q3l13z9j3kvi065z884y4dymmnkgc")
#:tests? #f)) ; tests require old version of ghc-hunit (0.9)
(native-inputs (list ghc-base16-bytestring ghc-sha ghc-tasty (native-inputs (list ghc-base16-bytestring ghc-sha ghc-tasty
ghc-tasty-quickcheck ghc-hunit)) ghc-tasty-quickcheck ghc-tasty-hunit))
(arguments
`(#:cabal-revision ("1"
"0bz9rfl7b2iwn45m0lxcmsyi5rrv3xdgzx2lzr79bds91dw6i25b")))
(home-page "https://github.com/hvr/cryptohash-sha1") (home-page "https://github.com/hvr/cryptohash-sha1")
(synopsis "SHA-1 implementation for Haskell") (synopsis "SHA-1 implementation for Haskell")
(description "This Haskell package provides an incremental and one-pass, (description
"This Haskell package provides an incremental and one-pass,
pure API to the @uref{https://en.wikipedia.org/wiki/SHA-1, SHA-1 hash algorithm}, pure API to the @uref{https://en.wikipedia.org/wiki/SHA-1, SHA-1 hash algorithm},
including @uref{https://en.wikipedia.org/wiki/HMAC, HMAC support}, with including @uref{https://en.wikipedia.org/wiki/HMAC, HMAC support}, with
performance close to the fastest implementations available in other languages. performance close to the fastest implementations available in other languages.
@ -270,23 +270,18 @@ the C implementation.")
(define-public ghc-cryptonite (define-public ghc-cryptonite
(package (package
(name "ghc-cryptonite") (name "ghc-cryptonite")
(version "0.29") (version "0.30")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "cryptonite" version)) (uri (hackage-uri "cryptonite" version))
(sha256 (sha256
(base32 (base32
"13xhp3hshb8x06bw37kp16c9jpjmgfn06nkj9drz745fv8f04fnq")))) "07bb97iszhnrfddh5ql6p3dqd0c13xycjw5n2kljw7d0ia59q2an"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "cryptonite"))) (properties '((upstream-name . "cryptonite")))
;; FIXME: tests are broken. (inputs (list ghc-memory ghc-basement))
;; See https://github.com/haskell-crypto/cryptonite/issues/260 (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
(arguments '(#:tests? #f)) ghc-tasty-kat))
(outputs '("out" "static" "doc"))
(inputs
(list ghc-basement ghc-memory ghc-byteable))
(native-inputs
(list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit ghc-tasty-kat))
(home-page "https://github.com/haskell-crypto/cryptonite") (home-page "https://github.com/haskell-crypto/cryptonite")
(synopsis "Cryptography primitives") (synopsis "Cryptography primitives")
(description (description
@ -299,24 +294,21 @@ generators, and more.")
(define-public ghc-digest (define-public ghc-digest
(package (package
(name "ghc-digest") (name "ghc-digest")
(version "0.0.1.3") (version "0.0.1.4")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "digest" version))
(uri (hackage-uri "digest" version)) (sha256
(sha256 (base32
(base32 "05pc5l4bwddszc6vy1hazwi1dnrxg323521gdkis9cvh7zs2a4gr"))))
"1l5383l5pvp018rj3vabrppnzcqrr2g0dvgvmsrbjdn02wzab5jm"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "digest"))) (properties '((upstream-name . "digest")))
(arguments (arguments
`(#:extra-directories ("zlib"))) `(#:extra-directories ("zlib")))
(inputs (inputs (list zlib))
(list zlib)) (native-inputs (list pkg-config))
(home-page (home-page "http://hackage.haskell.org/package/digest")
"https://hackage.haskell.org/package/digest") (synopsis "Various cryptographic hashes for bytestrings")
(synopsis
"Various cryptographic hashes for bytestrings")
(description (description
"This package provides efficient cryptographic hash implementations for "This package provides efficient cryptographic hash implementations for
strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they
@ -326,13 +318,13 @@ are implemented as FFI bindings to efficient code from zlib.")
(define-public ghc-entropy (define-public ghc-entropy
(package (package
(name "ghc-entropy") (name "ghc-entropy")
(version "0.4.1.6") (version "0.4.1.10")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "entropy" version))
(uri (hackage-uri "entropy" version)) (sha256
(sha256 (base32
(base32 "0qmzz0zgad13zl0kjrxz6cxg8ckn2w8saas2a2j72vbafpzmkixd")))) "1rbx4ydabrjs8kkdg9laznkh9nisiq6b5z93vnp9bh6iy59ivb45"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "entropy"))) (properties '((upstream-name . "entropy")))
(home-page "https://github.com/TomMD/entropy") (home-page "https://github.com/TomMD/entropy")
@ -418,26 +410,24 @@ libraries, like OpenSSL.")
(define-public ghc-x509 (define-public ghc-x509
(package (package
(name "ghc-x509") (name "ghc-x509")
(version "1.7.5") (version "1.7.7")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "x509" version)) (uri (hackage-uri "x509" version))
(sha256 (sha256
(base32 (base32
"1j67c35g8334jx7x32hh6awhr43dplp0qwal5gnlkmx09axzrc5i")))) "1zk8lll1hmzl5xvrd16dhyz25151y59xhsqp2mm1wgymwl7r5ijr"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "x509"))) (properties '((upstream-name . "x509")))
(inputs (inputs (list ghc-memory
(list ghc-memory ghc-hourglass
ghc-hourglass ghc-pem
ghc-pem ghc-asn1-types
ghc-asn1-types ghc-asn1-encoding
ghc-asn1-encoding ghc-asn1-parse
ghc-asn1-parse ghc-cryptonite))
ghc-cryptonite)) (native-inputs (list ghc-tasty ghc-tasty-quickcheck))
(native-inputs (home-page "http://github.com/vincenthz/hs-certificate")
(list ghc-tasty ghc-tasty-quickcheck))
(home-page "https://github.com/vincenthz/hs-certificate")
(synopsis "X509 reader and writer") (synopsis "X509 reader and writer")
(description (description
"This library provides functions to read and write X509 certificates.") "This library provides functions to read and write X509 certificates.")
@ -446,21 +436,19 @@ libraries, like OpenSSL.")
(define-public ghc-x509-store (define-public ghc-x509-store
(package (package
(name "ghc-x509-store") (name "ghc-x509-store")
(version "1.6.7") (version "1.6.9")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "x509-store" version)) (uri (hackage-uri "x509-store" version))
(sha256 (sha256
(base32 (base32
"1y8yyr1i95jkllg8k0z54k5v4vachp848clc07m33xpxidn3b1lp")))) "1nn8ql7vkp4qgf2msm600sr6ranpsajbhq0sc4c0l6pk1i9174n5"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "x509-store"))) (properties '((upstream-name . "x509-store")))
(inputs (inputs (list ghc-pem ghc-asn1-types ghc-asn1-encoding ghc-cryptonite
(list ghc-pem ghc-asn1-types ghc-asn1-encoding ghc-cryptonite ghc-x509))
ghc-x509)) (native-inputs (list ghc-tasty ghc-tasty-hunit))
(native-inputs (home-page "http://github.com/vincenthz/hs-certificate")
(list ghc-tasty ghc-tasty-hunit))
(home-page "https://github.com/vincenthz/hs-certificate")
(synopsis "X.509 collection accessing and storing methods") (synopsis "X.509 collection accessing and storing methods")
(description (description
"This package provides functions for accessing and storing X.509 "This package provides functions for accessing and storing X.509
@ -470,29 +458,26 @@ collections, certificates, revocation lists, and exception lists.")
(define-public ghc-x509-validation (define-public ghc-x509-validation
(package (package
(name "ghc-x509-validation") (name "ghc-x509-validation")
(version "1.6.11") (version "1.6.12")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "x509-validation" version)) (uri (hackage-uri "x509-validation" version))
(sha256 (sha256
(base32 (base32
"16yihzljql3z8w5rgdl95fv3hgk7yd86kbl9b3glllsark5j2hzr")))) "1j7is28ljz4yxwxz5ax3x7ykgwkr38dx46bw7vgj4arkk7hl93hd"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "x509-validation"))) (properties '((upstream-name . "x509-validation")))
(inputs (inputs (list ghc-memory
(list ghc-memory ghc-hourglass
ghc-byteable ghc-data-default-class
ghc-hourglass ghc-pem
ghc-data-default-class ghc-asn1-types
ghc-pem ghc-asn1-encoding
ghc-asn1-types ghc-x509
ghc-asn1-encoding ghc-x509-store
ghc-x509 ghc-cryptonite))
ghc-x509-store (native-inputs (list ghc-tasty ghc-tasty-hunit))
ghc-cryptonite)) (home-page "http://github.com/vincenthz/hs-certificate")
(native-inputs
(list ghc-tasty ghc-tasty-hunit))
(home-page "https://github.com/vincenthz/hs-certificate")
(synopsis "X.509 certificate and revocation list validation") (synopsis "X.509 certificate and revocation list validation")
(description (description
"This package provides functions for X.509 certificate and revocation "This package provides functions for X.509 certificate and revocation
@ -502,18 +487,17 @@ list validation.")
(define-public ghc-x509-system (define-public ghc-x509-system
(package (package
(name "ghc-x509-system") (name "ghc-x509-system")
(version "1.6.6") (version "1.6.7")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "x509-system" version)) (uri (hackage-uri "x509-system" version))
(sha256 (sha256
(base32 (base32
"06a4m9c7vlr9nhp9gmqbb46arf0yj1dkdm4nip03hzy67spdmp20")))) "049bdaxrih49nkhkyl2342qnbx2f0q99z8rld648bz1kkgyizz38"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "x509-system"))) (properties '((upstream-name . "x509-system")))
(inputs (inputs (list ghc-pem ghc-x509 ghc-x509-store))
(list ghc-pem ghc-x509 ghc-x509-store)) (home-page "http://github.com/vincenthz/hs-certificate")
(home-page "https://github.com/vincenthz/hs-certificate")
(synopsis "Handle system X.509 accessors and storage") (synopsis "Handle system X.509 accessors and storage")
(description (description
"This package provides a library to handle system accessors and storage "This package provides a library to handle system accessors and storage
@ -654,7 +638,7 @@ percent.
(properties '((upstream-name . "ed25519"))) (properties '((upstream-name . "ed25519")))
(arguments (arguments
`(#:cabal-revision `(#:cabal-revision
("3" "1yidh86ymzwmp2b449pwim6vvfcs1qgkkncbixw1zmb7wj6v167v") ("6" "0qyx6cl52fnll8lp6v9133wfvv3zhvq7v2crn441mng520j9wp48")
;; We omit these test suites because they require old versions of ;; We omit these test suites because they require old versions of
;; packages and packages we do not have. ;; packages and packages we do not have.
#:configure-flags #:configure-flags
@ -671,33 +655,30 @@ guidelines.")
(define-public ghc-tls (define-public ghc-tls
(package (package
(name "ghc-tls") (name "ghc-tls")
(version "1.5.5") (version "1.5.8")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "tls" version)) (uri (hackage-uri "tls" version))
(sha256 (sha256
(base32 (base32
"0j1rxxq5lzs584nk19610mk7mmsqqkgfxw2qj74ibb1zsk7baj4a")))) "0rxdv8ab98kd4nqql7djmmi51k4vayq21s38s43sx3rzn0iyla3b"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "tls"))) (properties '((upstream-name . "tls")))
(inputs (inputs (list ghc-cereal
(list ghc-cereal ghc-data-default-class
ghc-data-default-class ghc-memory
ghc-memory ghc-cryptonite
ghc-cryptonite ghc-asn1-types
ghc-asn1-types ghc-asn1-encoding
ghc-asn1-encoding ghc-x509
ghc-x509 ghc-x509-store
ghc-x509-store ghc-x509-validation
ghc-x509-validation ghc-async
ghc-async ghc-hourglass
ghc-network ghc-network))
ghc-hourglass)) (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck))
(native-inputs (home-page "http://github.com/vincenthz/hs-tls")
(list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck)) (synopsis "TLS/SSL protocol native implementation (Server and Client)")
(home-page "https://github.com/vincenthz/hs-tls")
(synopsis
"TLS/SSL protocol native implementation (Server and Client)")
(description (description
"Native Haskell TLS and SSL protocol implementation for server and client. "Native Haskell TLS and SSL protocol implementation for server and client.
This provides a high-level implementation of a sensitive security protocol, This provides a high-level implementation of a sensitive security protocol,
@ -711,23 +692,22 @@ extensions.")
(define-public ghc-hsopenssl (define-public ghc-hsopenssl
(package (package
(name "ghc-hsopenssl") (name "ghc-hsopenssl")
(version "0.11.7.2") (version "0.11.7.4")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "HsOpenSSL" version))
(uri (hackage-uri "HsOpenSSL" version)) (sha256
(sha256 (base32
(base32 "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf"))))
"0ysdfl8ck3nzhx597fa13dqf31jq5gzwajlak6r91jajks9w0dl5"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "HsOpenSSL"))) (properties '((upstream-name . "HsOpenSSL")))
(inputs (list ghc-network openssl))
(arguments (arguments
`(#:extra-directories ("openssl"))) `(#:extra-directories ("openssl")))
(inputs (home-page "https://github.com/haskell-cryptography/HsOpenSSL")
(list ghc-network openssl))
(home-page "https://github.com/vshabanov/HsOpenSSL")
(synopsis "Partial OpenSSL binding for Haskell") (synopsis "Partial OpenSSL binding for Haskell")
(description "HsOpenSSL is an OpenSSL binding for Haskell. It can (description
"HsOpenSSL is an OpenSSL binding for Haskell. It can
generate RSA and DSA keys, read and write PEM files, generate message generate RSA and DSA keys, read and write PEM files, generate message
digests, sign and verify messages, encrypt and decrypt messages. It has digests, sign and verify messages, encrypt and decrypt messages. It has
also some capabilities of creating SSL clients and servers. This also some capabilities of creating SSL clients and servers. This
@ -754,6 +734,9 @@ implementation of SSL.")
(list ghc-hsopenssl ghc-io-streams ghc-network)) (list ghc-hsopenssl ghc-io-streams ghc-network))
(native-inputs (native-inputs
(list ghc-hunit ghc-test-framework ghc-test-framework-hunit)) (list ghc-hunit ghc-test-framework ghc-test-framework-hunit))
(arguments
`(#:cabal-revision ("1"
"0vfawnfcjrw29qg1n7k6z6bk4bmnk869gjlr9mxw4mzxgl80b2vp")))
(home-page "https://hackage.haskell.org/package/openssl-streams") (home-page "https://hackage.haskell.org/package/openssl-streams")
(synopsis "OpenSSL network support for io-streams") (synopsis "OpenSSL network support for io-streams")
(description "This library contains io-streams routines for secure (description "This library contains io-streams routines for secure

1157
gnu/packages/haskell-web.scm
View File

File diff suppressed because it is too large Load Diff

9057
gnu/packages/haskell-xyz.scm
View File

File diff suppressed because it is too large Load Diff

2
gnu/packages/idris.scm
View File

@ -99,7 +99,7 @@
(add-before 'configure 'update-constraints (add-before 'configure 'update-constraints
(lambda _ (lambda _
(substitute* "idris.cabal" (substitute* "idris.cabal"
(("(aeson|ansi-terminal|haskeline|megaparsec|optparse-applicative)\\s+[^,]+" all dep) (("(aeson|ansi-terminal|bytestring|haskeline|libffi|megaparsec|network|optparse-applicative)\\s+[^,]+" all dep)
dep)))) dep))))
(add-before 'configure 'set-cc-command (add-before 'configure 'set-cc-command
(lambda _ (lambda _

127
gnu/packages/lisp.scm
View File

@ -1262,71 +1262,74 @@ assembler, PEG) is less than 1MB.")
(license license:expat))) (license license:expat)))
(define-public carp (define-public carp
(package ;; Release 0.5.5 does not support GHC 9.2.
(name "carp") (let ((commit "339722325ec607091f6035866ebedea2b69080fe")
(version "0.5.5") (revision "1"))
(source (origin (package
(method git-fetch) (name "carp")
(uri (git-reference (version (git-version "0.5.5" revision commit))
(url "https://github.com/carp-lang/Carp") (source (origin
(commit (string-append "v" version)))) (method git-fetch)
(file-name (git-file-name name version)) (uri (git-reference
(sha256 (url "https://github.com/carp-lang/Carp")
(base32 (commit commit)))
"14jdnv0ljqvpr9ych1plfw7hp5q57a8j1bv8h3v345x06z783d07")))) (file-name (git-file-name name version))
(build-system haskell-build-system) (sha256
(arguments (base32
(list #:phases "0w0j3imi4270dsmrh96spsc9xllsk5rrh817l80q1nyay9p53xwd"))))
#~(modify-phases %standard-phases (build-system haskell-build-system)
;; Carp looks inside the sources checkout to know where to (arguments
;; find its core libraries and other files. (list #:phases
;; Carp emits C code and tries to compile it with an external #~(modify-phases %standard-phases
;; C compiler. On Linux it defaults to Clang. ;; Carp looks inside the sources checkout to know where to
(add-after 'install 'wrap-programs ;; find its core libraries and other files.
(lambda* (#:key inputs #:allow-other-keys) ;; Carp emits C code and tries to compile it with an external
(define (wrap-carp-program program) ;; C compiler. On Linux it defaults to Clang.
(wrap-program (string-append (add-after 'install 'wrap-programs
#$output "/bin/" program) (lambda* (#:key inputs #:allow-other-keys)
`("CARP_DIR" prefix (define (wrap-carp-program program)
(#$(package-source this-package))) (wrap-program (string-append
`("PATH" prefix #$output "/bin/" program)
,(list (dirname `("CARP_DIR" prefix
(search-input-file inputs "bin/clang")) (#$(package-source this-package)))
(dirname `("PATH" prefix
(search-input-file inputs "bin/ld")))) ,(list (dirname
`("C_INCLUDE_PATH" prefix (search-input-file inputs "bin/clang"))
,(list (dirname (dirname
(search-input-directory (search-input-file inputs "bin/ld"))))
inputs "include/linux")) `("C_INCLUDE_PATH" prefix
(dirname ,(list (dirname
(search-input-file (search-input-directory
inputs "include/stdlib.h")))))) inputs "include/linux"))
(dirname
(for-each wrap-carp-program (search-input-file
(list "carp" inputs "include/stdlib.h"))))))
"carp-header-parse")))))))
(inputs (for-each wrap-carp-program
(list bash-minimal (list "carp"
clang "carp-header-parse")))))))
ghc-blaze-markup (inputs
ghc-blaze-html (list bash-minimal
ghc-split clang
ghc-ansi-terminal ghc-blaze-markup
ghc-cmark ghc-blaze-html
ghc-edit-distance ghc-split
ghc-hashable ghc-ansi-terminal
ghc-open-browser ghc-cmark
ghc-optparse-applicative)) ghc-edit-distance
(native-inputs ghc-hashable
(list ghc-hunit)) ghc-open-browser
(home-page "https://carp-lang.org/") ghc-optparse-applicative))
(synopsis "Statically typed Lisp without a garbage collector") (native-inputs
(description (list ghc-hunit))
"@code{carp} is a Lisp-like programming language that compiles to (home-page "https://carp-lang.org/")
(synopsis "Statically typed Lisp without a garbage collector")
(description
"@code{carp} is a Lisp-like programming language that compiles to
C. It features inferred static typing, macros, automatic memory C. It features inferred static typing, macros, automatic memory
management without a garbage collector, a REPL, and straightforward management without a garbage collector, a REPL, and straightforward
integration with code written in C.") integration with code written in C.")
(license license:asl2.0))) (license license:asl2.0))))
(define-public lisp-repl-core-dumper (define-public lisp-repl-core-dumper
(package (package
(name "lisp-repl-core-dumper") (name "lisp-repl-core-dumper")

29
gnu/packages/patches/cabal-install-base16-bytestring1.0.patch
View File

@ -1,29 +0,0 @@
Restore compatibility with newer version of base16-bytestring.
Taken from https://raw.githubusercontent.com/archlinux/svntogit-community/packages/trunk/cabal-install-base16-bytestring1.0.patch
diff --git a/Distribution/Client/HashValue.hs b/Distribution/Client/HashValue.hs
index 54b8aee9e..11e647c1c 100644
--- a/Distribution/Client/HashValue.hs
+++ b/Distribution/Client/HashValue.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
module Distribution.Client.HashValue (
@@ -72,10 +73,14 @@ hashFromTUF (Sec.Hash hashstr) =
--TODO: [code cleanup] either we should get TUF to use raw bytestrings or
-- perhaps we should also just use a base16 string as the internal rep.
case Base16.decode (BS.pack hashstr) of
+#if MIN_VERSION_base16_bytestring(1,0,0)
+ Right hash -> HashValue hash
+ Left _ -> error "hashFromTUF: cannot decode base16"
+#else
(hash, trailing) | not (BS.null hash) && BS.null trailing
-> HashValue hash
_ -> error "hashFromTUF: cannot decode base16 hash"
-
+#endif
-- | Truncate a 32 byte SHA256 hash to
--

393
gnu/packages/patches/cabal-install-ghc8.10.patch
View File

@ -1,393 +0,0 @@
From ac9b41eef3c781ce188ded2551f98fe75152e30c Mon Sep 17 00:00:00 2001
From: Oleg Grenrus <oleg.grenrus@iki.fi>
Date: Tue, 14 Apr 2020 11:31:34 +0300
Subject: [PATCH] GHC-8.10 support for 3.2
Includes cherry-picked commits:
- Test cabal-install with GHC-8.10 #6709
- Add GHC-8.10.1 job. Only tests Cabal-the-lib part atm. #6617
Also add topHandler' signature.
---
.docker/validate-8.10.1.dockerfile | 60 ++++++
.github/workflows/artifacts.yml | 6 +-
.github/workflows/bootstrap.yml | 4 +-
.github/workflows/linux.yml | 179 ++++++++++++------
.github/workflows/macos.yml | 40 ++--
.github/workflows/quick-jobs.yml | 4 +-
.github/workflows/windows.yml | 117 +++++++++++-
.../Distribution/PackageDescription/Quirks.hs | 19 +-
Makefile | 4 +
boot/ci-artifacts.template.yml | 6 +-
boot/ci-bootstrap.template.yml | 4 +-
boot/ci-linux.template.yml | 8 +-
boot/ci-macos.template.yml | 7 +-
boot/ci-quick-jobs.template.yml | 4 +-
boot/ci-windows.template.yml | 8 +-
cabal-dev-scripts/src/GenValidate.hs | 33 ++--
Distribution/Client/CmdSdist.hs | 3 +
.../Distribution/Client/FetchUtils.hs | 4 +-
.../Distribution/Client/IndexUtils.hs | 2 +-
Distribution/Client/Sandbox.hs | 5 +-
.../Distribution/Client/TargetSelector.hs | 2 +-
Distribution/Client/Update.hs | 4 +-
.../Distribution/Client/Utils/Json.hs | 13 +-
.../Distribution/Solver/Modular/Assignment.hs | 11 +-
.../Distribution/Solver/Modular/Builder.hs | 10 +-
.../Distribution/Solver/Modular/Index.hs | 6 +-
.../Solver/Modular/IndexConversion.hs | 8 +-
.../Distribution/Solver/Modular/Solver.hs | 12 +-
.../Distribution/Solver/Modular/Validate.hs | 5 +-
bootstrap.sh | 6 +-
cabal-install.cabal | 4 +-
cabal-install.cabal.pp | 4 +-
.../targets/complex/q/q.cabal | 3 +-
cabal-testsuite/cabal-testsuite.cabal | 4 +-
validate.sh | 21 +-
35 files changed, 461 insertions(+), 169 deletions(-)
create mode 100644 .docker/validate-8.10.1.dockerfile
diff --git a/Distribution/Client/CmdSdist.hs b/Distribution/Client/CmdSdist.hs
index 9ce0c80100e..a22317004c4 100644
--- a/Distribution/Client/CmdSdist.hs
+++ b/Distribution/Client/CmdSdist.hs
@@ -237,7 +237,10 @@ packageToSdist verbosity projectRootDir format outputFile pkg = do
(norm NoExec -> nonexec, norm Exec -> exec) <-
listPackageSources verbosity (flattenPackageDescription $ packageDescription pkg) knownSuffixHandlers
+ print $ map snd exec
+ print $ map snd nonexec
let files = nub . sortOn snd $ nonexec ++ exec
+ print files
case format of
SourceList nulSep -> do
diff --git a/Distribution/Client/FetchUtils.hs b/Distribution/Client/FetchUtils.hs
index e9a31a91f84..4e5e581f9ec 100644
--- a/Distribution/Client/FetchUtils.hs
+++ b/Distribution/Client/FetchUtils.hs
@@ -176,8 +176,8 @@ fetchRepoTarball verbosity' repoCtxt repo pkgid = do
verbosity = verboseUnmarkOutput verbosity'
downloadRepoPackage = case repo of
- RepoLocal{..} -> return (packageFile repo pkgid)
- RepoLocalNoIndex{..} -> return (packageFile repo pkgid)
+ RepoLocal{} -> return (packageFile repo pkgid)
+ RepoLocalNoIndex{} -> return (packageFile repo pkgid)
RepoRemote{..} -> do
transport <- repoContextGetTransport repoCtxt
diff --git a/Distribution/Client/IndexUtils.hs b/Distribution/Client/IndexUtils.hs
index a76becc05ba..bf0ff7cf5ba 100644
--- a/Distribution/Client/IndexUtils.hs
+++ b/Distribution/Client/IndexUtils.hs
@@ -634,7 +634,7 @@ withIndexEntries
-> ([IndexCacheEntry] -> IO a)
-> ([NoIndexCacheEntry] -> IO a)
-> IO a
-withIndexEntries _ (RepoIndex repoCtxt repo@RepoSecure{..}) callback _ =
+withIndexEntries _ (RepoIndex repoCtxt repo@RepoSecure{}) callback _ =
repoContextWithSecureRepo repoCtxt repo $ \repoSecure ->
Sec.withIndex repoSecure $ \Sec.IndexCallbacks{..} -> do
-- Incrementally (lazily) read all the entries in the tar file in order,
diff --git a/Distribution/Client/Sandbox.hs b/Distribution/Client/Sandbox.hs
index 66b415d7239..14bad3f2135 100644
--- a/Distribution/Client/Sandbox.hs
+++ b/Distribution/Client/Sandbox.hs
@@ -666,7 +666,7 @@ reinstallAddSourceDeps :: Verbosity
-> FilePath
-> IO WereDepsReinstalled
reinstallAddSourceDeps verbosity configFlags' configExFlags
- installFlags globalFlags sandboxDir = topHandler' $ do
+ installFlags globalFlags sandboxDir = topHandlerWith errorMsg $ do
let sandboxDistPref = sandboxBuildDir sandboxDir
configFlags = configFlags'
{ configDistPref = Flag sandboxDistPref }
@@ -710,7 +710,8 @@ reinstallAddSourceDeps verbosity configFlags' configExFlags
++ "offending packages or recreating the sandbox."
logMsg message rest = debugNoWrap verbosity message >> rest
- topHandler' = topHandlerWith $ \_ -> do
+ errorMsg :: a -> IO WereDepsReinstalled
+ errorMsg _ = do
warn verbosity "Couldn't reinstall some add-source dependencies."
-- Here we can't know whether any deps have been reinstalled, so we have
-- to be conservative.
diff --git a/Distribution/Client/TargetSelector.hs b/Distribution/Client/TargetSelector.hs
index 23d92f580fd..f8f683d9875 100644
--- a/Distribution/Client/TargetSelector.hs
+++ b/Distribution/Client/TargetSelector.hs
@@ -222,7 +222,7 @@ readTargetSelectorsWith :: (Applicative m, Monad m) => DirActions m
-> Maybe ComponentKindFilter
-> [String]
-> m (Either [TargetSelectorProblem] [TargetSelector])
-readTargetSelectorsWith dirActions@DirActions{..} pkgs mfilter targetStrs =
+readTargetSelectorsWith dirActions@DirActions{} pkgs mfilter targetStrs =
case parseTargetStrings targetStrs of
([], usertargets) -> do
usertargets' <- mapM (getTargetStringFileStatus dirActions) usertargets
diff --git a/Distribution/Client/Update.hs b/Distribution/Client/Update.hs
index 52bb1f76c96..8ded78b9d2e 100644
--- a/Distribution/Client/Update.hs
+++ b/Distribution/Client/Update.hs
@@ -73,8 +73,8 @@ updateRepo :: Verbosity -> UpdateFlags -> RepoContext -> Repo -> IO ()
updateRepo verbosity updateFlags repoCtxt repo = do
transport <- repoContextGetTransport repoCtxt
case repo of
- RepoLocal{..} -> return ()
- RepoLocalNoIndex{..} -> return ()
+ RepoLocal{} -> return ()
+ RepoLocalNoIndex{} -> return ()
RepoRemote{..} -> do
downloadResult <- downloadIndex transport verbosity repoRemote repoLocalDir
case downloadResult of
diff --git a/Distribution/Client/Utils/Json.hs b/Distribution/Client/Utils/Json.hs
index 89a13af87a4..01d5753136b 100644
--- a/Distribution/Client/Utils/Json.hs
+++ b/Distribution/Client/Utils/Json.hs
@@ -15,12 +15,9 @@ module Distribution.Client.Utils.Json
)
where
-import Data.Char
-import Data.Int
-import Data.String
-import Data.Word
-import Data.List
-import Data.Monoid
+import Distribution.Client.Compat.Prelude
+
+import Data.Char (intToDigit)
import Data.ByteString.Builder (Builder)
import qualified Data.ByteString.Builder as BB
@@ -135,13 +132,13 @@ encodeArrayBB :: [Value] -> Builder
encodeArrayBB [] = "[]"
encodeArrayBB jvs = BB.char8 '[' <> go jvs <> BB.char8 ']'
where
- go = Data.Monoid.mconcat . intersperse (BB.char8 ',') . map encodeValueBB
+ go = mconcat . intersperse (BB.char8 ',') . map encodeValueBB
encodeObjectBB :: Object -> Builder
encodeObjectBB [] = "{}"
encodeObjectBB jvs = BB.char8 '{' <> go jvs <> BB.char8 '}'
where
- go = Data.Monoid.mconcat . intersperse (BB.char8 ',') . map encPair
+ go = mconcat . intersperse (BB.char8 ',') . map encPair
encPair (l,x) = encodeStringBB l <> BB.char8 ':' <> encodeValueBB x
encodeStringBB :: String -> Builder
diff --git a/Distribution/Solver/Modular/Assignment.hs b/Distribution/Solver/Modular/Assignment.hs
index be5e63bfbc1..b05a099ec5a 100644
--- a/Distribution/Solver/Modular/Assignment.hs
+++ b/Distribution/Solver/Modular/Assignment.hs
@@ -9,10 +9,11 @@ module Distribution.Solver.Modular.Assignment
import Prelude ()
import Distribution.Solver.Compat.Prelude hiding (pi)
-import Data.Array as A
-import Data.List as L
-import Data.Map as M
-import Data.Maybe
+import qualified Data.Array as A
+import qualified Data.List as L
+import qualified Data.Map as M
+
+import Data.Maybe (fromJust)
import Distribution.PackageDescription (FlagAssignment, mkFlagAssignment) -- from Cabal
@@ -79,7 +80,7 @@ toCPs (A pa fa sa) rdm =
-- Dependencies per package.
depp :: QPN -> [(Component, PI QPN)]
depp qpn = let v :: Vertex
- v = fromJust (cvm qpn)
+ v = fromJust (cvm qpn) -- TODO: why this is safe?
dvs :: [(Component, Vertex)]
dvs = tg A.! v
in L.map (\ (comp, dv) -> case vm dv of (_, x, _) -> (comp, PI x (pa M.! x))) dvs
diff --git a/Distribution/Solver/Modular/Builder.hs b/Distribution/Solver/Modular/Builder.hs
index eb11a36aa16..5d196f4fd9f 100644
--- a/Distribution/Solver/Modular/Builder.hs
+++ b/Distribution/Solver/Modular/Builder.hs
@@ -19,10 +19,10 @@ module Distribution.Solver.Modular.Builder (
-- flag-guarded dependencies, we cannot introduce them immediately. Instead, we
-- store the entire dependency.
-import Data.List as L
-import Data.Map as M
-import Data.Set as S
-import Prelude hiding (sequence, mapM)
+import qualified Data.List as L
+import qualified Data.Map as M
+import qualified Data.Set as S
+import Prelude
import qualified Distribution.Solver.Modular.ConflictSet as CS
import Distribution.Solver.Modular.Dependency
@@ -55,7 +55,7 @@ data BuildState = BS {
}
-- | Map of available linking targets.
-type LinkingState = Map (PN, I) [PackagePath]
+type LinkingState = M.Map (PN, I) [PackagePath]
-- | Extend the set of open goals with the new goals listed.
--
diff --git a/Distribution/Solver/Modular/Index.hs b/Distribution/Solver/Modular/Index.hs
index fdddfc8237a..ac60fec7d65 100644
--- a/Distribution/Solver/Modular/Index.hs
+++ b/Distribution/Solver/Modular/Index.hs
@@ -6,10 +6,12 @@ module Distribution.Solver.Modular.Index
, mkIndex
) where
-import Data.List as L
-import Data.Map as M
import Prelude hiding (pi)
+import Data.Map (Map)
+import qualified Data.List as L
+import qualified Data.Map as M
+
import Distribution.Solver.Modular.Dependency
import Distribution.Solver.Modular.Flag
import Distribution.Solver.Modular.Package
diff --git a/Distribution/Solver/Modular/IndexConversion.hs b/Distribution/Solver/Modular/IndexConversion.hs
index c9565c80dba..8e9ef614184 100644
--- a/Distribution/Solver/Modular/IndexConversion.hs
+++ b/Distribution/Solver/Modular/IndexConversion.hs
@@ -2,12 +2,12 @@ module Distribution.Solver.Modular.IndexConversion
( convPIs
) where
-import Data.List as L
+import qualified Data.List as L
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as M
-import Data.Maybe
+import Data.Maybe (mapMaybe, fromMaybe, maybeToList)
import Data.Monoid as Mon
-import Data.Set as S
+import qualified Data.Set as S
import Distribution.Compiler
import Distribution.InstalledPackageInfo as IPI
@@ -330,7 +330,7 @@ flagInfo (StrongFlags strfl) =
-- | Internal package names, which should not be interpreted as true
-- dependencies.
-type IPNs = Set PN
+type IPNs = S.Set PN
-- | Convenience function to delete a 'Dependency' if it's
-- for a 'PN' that isn't actually real.
diff --git a/Distribution/Solver/Modular/Solver.hs b/Distribution/Solver/Modular/Solver.hs
index 32452550556..e6aa1fb4374 100644
--- a/Distribution/Solver/Modular/Solver.hs
+++ b/Distribution/Solver/Modular/Solver.hs
@@ -9,9 +9,9 @@ module Distribution.Solver.Modular.Solver
, PruneAfterFirstSuccess(..)
) where
-import Data.Map as M
-import Data.List as L
-import Data.Set as S
+import qualified Data.Map as M
+import qualified Data.List as L
+import qualified Data.Set as S
import Distribution.Verbosity
import Distribution.Compiler (CompilerInfo)
@@ -91,8 +91,8 @@ solve :: SolverConfig -- ^ solver parameters
-> Index -- ^ all available packages as an index
-> PkgConfigDb -- ^ available pkg-config pkgs
-> (PN -> PackagePreferences) -- ^ preferences
- -> Map PN [LabeledPackageConstraint] -- ^ global constraints
- -> Set PN -- ^ global goals
+ -> M.Map PN [LabeledPackageConstraint] -- ^ global constraints
+ -> S.Set PN -- ^ global goals
-> RetryLog Message SolverFailure (Assignment, RevDepMap)
solve sc cinfo idx pkgConfigDB userPrefs userConstraints userGoals =
explorePhase $
@@ -232,7 +232,7 @@ instance GSimpleTree (Tree d c) where
-- Show conflict set
goCS :: ConflictSet -> String
- goCS cs = "{" ++ (intercalate "," . L.map showVar . CS.toList $ cs) ++ "}"
+ goCS cs = "{" ++ (L.intercalate "," . L.map showVar . CS.toList $ cs) ++ "}"
#endif
-- | Replace all goal reasons with a dummy goal reason in the tree
diff --git a/Distribution/Solver/Modular/Validate.hs b/Distribution/Solver/Modular/Validate.hs
index 6195d101b02..a3dec6e1f67 100644
--- a/Distribution/Solver/Modular/Validate.hs
+++ b/Distribution/Solver/Modular/Validate.hs
@@ -15,11 +15,12 @@ module Distribution.Solver.Modular.Validate (validateTree) where
import Control.Applicative
import Control.Monad.Reader hiding (sequence)
import Data.Function (on)
-import Data.List as L
-import Data.Set as S
import Data.Traversable
import Prelude hiding (sequence)
+import qualified Data.List as L
+import qualified Data.Set as S
+
import Language.Haskell.Extension (Extension, Language)
import Data.Map.Strict as M
diff --git a/bootstrap.sh b/bootstrap.sh
index 077d7f4efd2..d5141660474 100755
--- a/bootstrap.sh
+++ b/bootstrap.sh
@@ -260,9 +260,9 @@ EDIT_DISTANCE_VER="0.2.2.1"; EDIT_DISTANCE_VER_REGEXP="0\.2\.2\.?"
# 0.2.2.*
ED25519_VER="0.0.5.0"; ED25519_VER_REGEXP="0\.0\.?"
# 0.0.*
-HACKAGE_SECURITY_VER="0.6.0.0"; HACKAGE_SECURITY_VER_REGEXP="0\.6\."
- # >= 0.7.0.0 && < 0.7
-TAR_VER="0.5.1.0"; TAR_VER_REGEXP="0\.5\.([1-9]|1[0-9]|0\.[3-9]|0\.1[0-9])\.?"
+HACKAGE_SECURITY_VER="0.6.0.1"; HACKAGE_SECURITY_VER_REGEXP="0\.6\."
+ # >= 0.6.0.0 && < 0.7
+TAR_VER="0.5.1.1"; TAR_VER_REGEXP="0\.5\.([1-9]|1[0-9]|0\.[3-9]|0\.1[0-9])\.?"
# >= 0.5.0.3 && < 0.6
DIGEST_VER="0.0.1.2"; DIGEST_REGEXP="0\.0\.(1\.[2-9]|[2-9]\.?)"
# >= 0.0.1.2 && < 0.1
diff --git a/cabal-install.cabal b/cabal-install.cabal
index 985ea9a5a69..c9d713c29fe 100644
--- a/cabal-install.cabal
+++ b/cabal-install.cabal
@@ -316,7 +316,7 @@ executable cabal
build-depends:
async >= 2.0 && < 2.3,
array >= 0.4 && < 0.6,
- base >= 4.8 && < 4.14,
+ base >= 4.8 && < 4.15,
base16-bytestring >= 0.1.1 && < 0.2,
binary >= 0.7.3 && < 0.9,
bytestring >= 0.10.6.0 && < 0.11,
@@ -341,7 +341,7 @@ executable cabal
time >= 1.5.0.1 && < 1.10,
transformers >= 0.4.2.0 && < 0.6,
zlib >= 0.5.3 && < 0.7,
- hackage-security >= 0.6.0.0 && < 0.7,
+ hackage-security >= 0.6.0.1 && < 0.7,
text >= 1.2.3 && < 1.3,
parsec >= 3.1.13.0 && < 3.2
diff --git a/tests/IntegrationTests2/targets/complex/q/q.cabal b/tests/IntegrationTests2/targets/complex/q/q.cabal
index 556fa4a4202..7ee22fcb28d 100644
--- a/tests/IntegrationTests2/targets/complex/q/q.cabal
+++ b/tests/IntegrationTests2/targets/complex/q/q.cabal
@@ -5,7 +5,8 @@ cabal-version: >= 1.2
library
exposed-modules: Q
- build-depends: base, filepath
+ -- we rely that filepath has filepath-tests component
+ build-depends: base, filepath >=1.4.0.0
executable buildable-false
main-is: Main.hs

303
gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch 100644
View File

@ -0,0 +1,303 @@
Taken from https://github.com/bos/bloomfilter/pull/20
From fb79b39c44404fd791a3bed973e9d844fb084f1e Mon Sep 17 00:00:00 2001
From: Simon Jakobi <simon.jakobi@gmail.com>
Date: Fri, 12 Nov 2021 01:37:36 +0100
Subject: [PATCH] Fix build with GHC 9.2
The `FastShift.shift{L,R}` methods are replaced with `unsafeShift{L,R}`
introduced in base-4.5.
Fixes #19.
---
Data/BloomFilter.hs | 16 +++++------
Data/BloomFilter/Hash.hs | 15 +++++-----
Data/BloomFilter/Mutable.hs | 20 +++++++-------
Data/BloomFilter/Util.hs | 55 ++++++-------------------------------
bloomfilter.cabal | 2 +-
5 files changed, 34 insertions(+), 74 deletions(-)
diff --git a/Data/BloomFilter.hs b/Data/BloomFilter.hs
index 2210cef..6b47c21 100644
--- a/Data/BloomFilter.hs
+++ b/Data/BloomFilter.hs
@@ -78,8 +78,8 @@ import Control.DeepSeq (NFData(..))
import Data.Array.Base (unsafeAt)
import qualified Data.Array.Base as ST
import Data.Array.Unboxed (UArray)
-import Data.Bits ((.&.))
-import Data.BloomFilter.Util (FastShift(..), (:*)(..))
+import Data.Bits ((.&.), unsafeShiftL, unsafeShiftR)
+import Data.BloomFilter.Util ((:*)(..))
import qualified Data.BloomFilter.Mutable as MB
import qualified Data.BloomFilter.Mutable.Internal as MB
import Data.BloomFilter.Mutable.Internal (Hash, MBloom)
@@ -98,7 +98,7 @@ data Bloom a = B {
}
instance Show (Bloom a) where
- show ub = "Bloom { " ++ show ((1::Int) `shiftL` shift ub) ++ " bits } "
+ show ub = "Bloom { " ++ show ((1::Int) `unsafeShiftL` shift ub) ++ " bits } "
instance NFData (Bloom a) where
rnf !_ = ()
@@ -172,7 +172,7 @@ singleton hash numBits elt = create hash numBits (\mb -> MB.insert mb elt)
-- | Given a filter's mask and a hash value, compute an offset into
-- a word array and a bit offset within that word.
hashIdx :: Int -> Word32 -> (Int :* Int)
-hashIdx mask x = (y `shiftR` logBitsInHash) :* (y .&. hashMask)
+hashIdx mask x = (y `unsafeShiftR` logBitsInHash) :* (y .&. hashMask)
where hashMask = 31 -- bitsInHash - 1
y = fromIntegral x .&. mask
@@ -191,7 +191,7 @@ hashesU ub elt = hashIdx (mask ub) `map` hashes ub elt
-- /still/ some possibility that @True@ will be returned.
elem :: a -> Bloom a -> Bool
elem elt ub = all test (hashesU ub elt)
- where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `shiftL` bit) /= 0
+ where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `unsafeShiftL` bit) /= 0
modify :: (forall s. (MBloom s a -> ST s z)) -- ^ mutation function (result is discarded)
-> Bloom a
@@ -255,11 +255,11 @@ insertList elts = modify $ \mb -> mapM_ (MB.insert mb) elts
-- is /still/ some possibility that @True@ will be returned.
notElem :: a -> Bloom a -> Bool
notElem elt ub = any test (hashesU ub elt)
- where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `shiftL` bit) == 0
+ where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `unsafeShiftL` bit) == 0
-- | Return the size of an immutable Bloom filter, in bits.
length :: Bloom a -> Int
-length = shiftL 1 . shift
+length = unsafeShiftL 1 . shift
-- | Build an immutable Bloom filter from a seed value. The seeding
-- function populates the filter as follows.
@@ -318,7 +318,7 @@ fromList hashes numBits = unfold hashes numBits convert
logPower2 :: Int -> Int
logPower2 k = go 0 k
where go j 1 = j
- go j n = go (j+1) (n `shiftR` 1)
+ go j n = go (j+1) (n `unsafeShiftR` 1)
-- $overview
--
diff --git a/Data/BloomFilter/Hash.hs b/Data/BloomFilter/Hash.hs
index 132a3a4..d071fd4 100644
--- a/Data/BloomFilter/Hash.hs
+++ b/Data/BloomFilter/Hash.hs
@@ -38,8 +38,7 @@ module Data.BloomFilter.Hash
) where
import Control.Monad (foldM)
-import Data.Bits ((.&.), (.|.), xor)
-import Data.BloomFilter.Util (FastShift(..))
+import Data.Bits ((.&.), (.|.), unsafeShiftL, unsafeShiftR, xor)
import Data.List (unfoldr)
import Data.Int (Int8, Int16, Int32, Int64)
import Data.Word (Word8, Word16, Word32, Word64)
@@ -91,11 +90,11 @@ class Hashable a where
-> Word64 -- ^ salt
-> IO Word64
hashIO64 v salt = do
- let s1 = fromIntegral (salt `shiftR` 32) .&. maxBound
+ let s1 = fromIntegral (salt `unsafeShiftR` 32) .&. maxBound
s2 = fromIntegral salt
h1 <- hashIO32 v s1
h2 <- hashIO32 v s2
- return $ (fromIntegral h1 `shiftL` 32) .|. fromIntegral h2
+ return $ (fromIntegral h1 `unsafeShiftL` 32) .|. fromIntegral h2
-- | Compute a 32-bit hash.
hash32 :: Hashable a => a -> Word32
@@ -149,8 +148,8 @@ cheapHashes :: Hashable a => Int -- ^ number of hashes to compute
cheapHashes k v = go 0
where go i | i == j = []
| otherwise = hash : go (i + 1)
- where !hash = h1 + (h2 `shiftR` i)
- h1 = fromIntegral (h `shiftR` 32)
+ where !hash = h1 + (h2 `unsafeShiftR` i)
+ h1 = fromIntegral (h `unsafeShiftR` 32)
h2 = fromIntegral h
h = hashSalt64 0x9150a946c4a8966e v
j = fromIntegral k
@@ -163,7 +162,7 @@ instance Hashable Integer where
(salt `xor` 0x3ece731e)
| otherwise = hashIO32 (unfoldr go k) salt
where go 0 = Nothing
- go i = Just (fromIntegral i :: Word32, i `shiftR` 32)
+ go i = Just (fromIntegral i :: Word32, i `unsafeShiftR` 32)
instance Hashable Bool where
hashIO32 = hashOne32
@@ -224,7 +223,7 @@ instance Hashable Word64 where
-- | A fast unchecked shift. Nasty, but otherwise GHC 6.8.2 does a
-- test and branch on every shift.
div4 :: CSize -> CSize
-div4 k = fromIntegral ((fromIntegral k :: HTYPE_SIZE_T) `shiftR` 2)
+div4 k = fromIntegral ((fromIntegral k :: HTYPE_SIZE_T) `unsafeShiftR` 2)
alignedHash :: Ptr a -> CSize -> Word32 -> IO Word32
alignedHash ptr bytes salt
diff --git a/Data/BloomFilter/Mutable.hs b/Data/BloomFilter/Mutable.hs
index edff1fc..0bb5cc9 100644
--- a/Data/BloomFilter/Mutable.hs
+++ b/Data/BloomFilter/Mutable.hs
@@ -65,9 +65,9 @@ module Data.BloomFilter.Mutable
import Control.Monad (liftM, forM_)
import Control.Monad.ST (ST)
import Data.Array.Base (unsafeRead, unsafeWrite)
-import Data.Bits ((.&.), (.|.))
+import Data.Bits ((.&.), (.|.), unsafeShiftL, unsafeShiftR)
import Data.BloomFilter.Array (newArray)
-import Data.BloomFilter.Util (FastShift(..), (:*)(..), nextPowerOfTwo)
+import Data.BloomFilter.Util ((:*)(..), nextPowerOfTwo)
import Data.Word (Word32)
import Data.BloomFilter.Mutable.Internal
@@ -86,9 +86,9 @@ new hash numBits = MB hash shft msk `liftM` newArray numElems numBytes
| numBits > maxHash = maxHash
| isPowerOfTwo numBits = numBits
| otherwise = nextPowerOfTwo numBits
- numElems = max 2 (twoBits `shiftR` logBitsInHash)
- numBytes = numElems `shiftL` logBytesInHash
- trueBits = numElems `shiftL` logBitsInHash
+ numElems = max 2 (twoBits `unsafeShiftR` logBitsInHash)
+ numBytes = numElems `unsafeShiftL` logBytesInHash
+ trueBits = numElems `unsafeShiftL` logBitsInHash
shft = logPower2 trueBits
msk = trueBits - 1
isPowerOfTwo n = n .&. (n - 1) == 0
@@ -109,7 +109,7 @@ logBytesInHash = 2 -- logPower2 (sizeOf (undefined :: Hash))
-- | Given a filter's mask and a hash value, compute an offset into
-- a word array and a bit offset within that word.
hashIdx :: Int -> Word32 -> (Int :* Int)
-hashIdx msk x = (y `shiftR` logBitsInHash) :* (y .&. hashMask)
+hashIdx msk x = (y `unsafeShiftR` logBitsInHash) :* (y .&. hashMask)
where hashMask = 31 -- bitsInHash - 1
y = fromIntegral x .&. msk
@@ -125,7 +125,7 @@ insert mb elt = do
let mu = bitArray mb
forM_ (hashesM mb elt) $ \(word :* bit) -> do
old <- unsafeRead mu word
- unsafeWrite mu word (old .|. (1 `shiftL` bit))
+ unsafeWrite mu word (old .|. (1 `unsafeShiftL` bit))
-- | Query a mutable Bloom filter for membership. If the value is
-- present, return @True@. If the value is not present, there is
@@ -135,7 +135,7 @@ elem elt mb = loop (hashesM mb elt)
where mu = bitArray mb
loop ((word :* bit):wbs) = do
i <- unsafeRead mu word
- if i .&. (1 `shiftL` bit) == 0
+ if i .&. (1 `unsafeShiftL` bit) == 0
then return False
else loop wbs
loop _ = return True
@@ -145,7 +145,7 @@ elem elt mb = loop (hashesM mb elt)
-- | Return the size of a mutable Bloom filter, in bits.
length :: MBloom s a -> Int
-length = shiftL 1 . shift
+length = unsafeShiftL 1 . shift
-- | Slow, crummy way of computing the integer log of an integer known
@@ -153,7 +153,7 @@ length = shiftL 1 . shift
logPower2 :: Int -> Int
logPower2 k = go 0 k
where go j 1 = j
- go j n = go (j+1) (n `shiftR` 1)
+ go j n = go (j+1) (n `unsafeShiftR` 1)
-- $overview
--
diff --git a/Data/BloomFilter/Util.hs b/Data/BloomFilter/Util.hs
index 7f695dc..6ade6e5 100644
--- a/Data/BloomFilter/Util.hs
+++ b/Data/BloomFilter/Util.hs
@@ -2,15 +2,11 @@
module Data.BloomFilter.Util
(
- FastShift(..)
- , nextPowerOfTwo
+ nextPowerOfTwo
, (:*)(..)
) where
-import Data.Bits ((.|.))
-import qualified Data.Bits as Bits
-import GHC.Base
-import GHC.Word
+import Data.Bits ((.|.), unsafeShiftR)
-- | A strict pair type.
data a :* b = !a :* !b
@@ -22,46 +18,11 @@ nextPowerOfTwo :: Int -> Int
{-# INLINE nextPowerOfTwo #-}
nextPowerOfTwo n =
let a = n - 1
- b = a .|. (a `shiftR` 1)
- c = b .|. (b `shiftR` 2)
- d = c .|. (c `shiftR` 4)
- e = d .|. (d `shiftR` 8)
- f = e .|. (e `shiftR` 16)
- g = f .|. (f `shiftR` 32) -- in case we're on a 64-bit host
+ b = a .|. (a `unsafeShiftR` 1)
+ c = b .|. (b `unsafeShiftR` 2)
+ d = c .|. (c `unsafeShiftR` 4)
+ e = d .|. (d `unsafeShiftR` 8)
+ f = e .|. (e `unsafeShiftR` 16)
+ g = f .|. (f `unsafeShiftR` 32) -- in case we're on a 64-bit host
!h = g + 1
in h
-
--- | This is a workaround for poor optimisation in GHC 6.8.2. It
--- fails to notice constant-width shifts, and adds a test and branch
--- to every shift. This imposes about a 10% performance hit.
-class FastShift a where
- shiftL :: a -> Int -> a
- shiftR :: a -> Int -> a
-
-instance FastShift Word32 where
- {-# INLINE shiftL #-}
- shiftL (W32# x#) (I# i#) = W32# (x# `uncheckedShiftL#` i#)
-
- {-# INLINE shiftR #-}
- shiftR (W32# x#) (I# i#) = W32# (x# `uncheckedShiftRL#` i#)
-
-instance FastShift Word64 where
- {-# INLINE shiftL #-}
- shiftL (W64# x#) (I# i#) = W64# (x# `uncheckedShiftL64#` i#)
-
- {-# INLINE shiftR #-}
- shiftR (W64# x#) (I# i#) = W64# (x# `uncheckedShiftRL64#` i#)
-
-instance FastShift Int where
- {-# INLINE shiftL #-}
- shiftL (I# x#) (I# i#) = I# (x# `iShiftL#` i#)
-
- {-# INLINE shiftR #-}
- shiftR (I# x#) (I# i#) = I# (x# `iShiftRA#` i#)
-
-instance FastShift Integer where
- {-# INLINE shiftL #-}
- shiftL = Bits.shiftL
-
- {-# INLINE shiftR #-}
- shiftR = Bits.shiftR
diff --git a/bloomfilter.cabal b/bloomfilter.cabal
index 821a5d7..c621f7f 100644
--- a/bloomfilter.cabal
+++ b/bloomfilter.cabal
@@ -18,7 +18,7 @@ extra-source-files: README.markdown cbits/lookup3.c cbits/lookup3.h
library
build-depends:
array,
- base >= 4.4 && < 5,
+ base >= 4.5 && < 5,
bytestring >= 0.9,
deepseq
exposed-modules: Data.BloomFilter

67
gnu/packages/patches/ghc-bytestring-handle-ghc9.patch 100644
View File

@ -0,0 +1,67 @@
Taken from https://raw.githubusercontent.com/archlinux/svntogit-community/packages/haskell-bytestring-handle/trunk/ghc9.patch
--- bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Write.hs.orig 2021-06-21 14:54:12.217134401 +0800
+++ bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Write.hs 2021-06-21 15:24:01.794796505 +0800
@@ -17,7 +17,7 @@
import GHC.IO.Buffer ( BufferState(..), emptyBuffer, Buffer(..) )
import GHC.IO.BufferedIO ( BufferedIO(..) )
-import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..) )
+import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..), RawIO(..) )
#if MIN_VERSION_base(4,5,0)
import GHC.IO.Encoding ( getLocaleEncoding )
#else
@@ -138,6 +138,7 @@
seek_base = error "seek_base needs to be updated"
})
modifyIORef (write_size ws) (`max` newSeekPos)
+ pure newSeekPos
tell ws = do
ss <- readIORef (write_seek_state ws)
@@ -152,6 +153,12 @@
devType _ = return RegularFile -- TODO: is this correct?
+instance RawIO WriteState where
+ read _ _ _ _ = return 0
+ readNonBlocking _ _ _ _ = return Nothing
+ write _ _ _ _ = return ()
+ writeNonBlocking _ _ _ _ = return 0
+
ioe_seekOutOfRange :: IO a
ioe_seekOutOfRange =
ioException $ IOError Nothing InvalidArgument ""
--- bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Read.hs.orig 2021-06-21 14:53:55.433129276 +0800
+++ bytestring-handle-0.1.0.6/src/Data/ByteString/Handle/Read.hs 2021-06-21 15:24:25.998784996 +0800
@@ -24,7 +24,7 @@
, emptyBuffer, isEmptyBuffer, newBuffer, newByteBuffer
, bufferElems, withBuffer, withRawBuffer )
import GHC.IO.BufferedIO ( BufferedIO(..) )
-import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..) )
+import GHC.IO.Device ( IODevice(..), IODeviceType(..), SeekMode(..), RawIO(..) )
#if MIN_VERSION_base(4,5,0)
import GHC.IO.Encoding ( getLocaleEncoding )
#else
@@ -155,7 +155,7 @@
(seek_before_length curSeekState)
(fromIntegral (seek_pos curSeekState) + seekPos)
SeekFromEnd -> normalisedSeekState (read_chunks_backwards rs) [] (read_length rs) seekPos
- maybe ioe_seekOutOfRange (writeIORef (read_seek_state rs)) newSeekState
+ maybe ioe_seekOutOfRange (\nss -> writeIORef (read_seek_state rs) nss >> pure (fromIntegral(seek_pos nss))) newSeekState
tell rs = do
ss <- readIORef (read_seek_state rs)
@@ -166,6 +166,12 @@
devType _ = return RegularFile -- TODO: is this correct?
+instance RawIO ReadState where
+ read _ _ _ _ = return 0
+ readNonBlocking _ _ _ _ = return Nothing
+ write _ _ _ _ = return ()
+ writeNonBlocking _ _ _ _ = return 0
+
ioe_seekOutOfRange :: IO a
ioe_seekOutOfRange =
ioException $ IOError Nothing InvalidArgument ""

66
gnu/packages/patches/ngless-unliftio.patch
View File

@ -1,66 +0,0 @@
From 919565adc1216b9d3108b3043e8d307292b37393 Mon Sep 17 00:00:00 2001
From: Luis Pedro Coelho <luis@luispedro.org>
Date: Fri, 7 May 2021 11:42:56 +0800
Subject: [PATCH] BLD Update to LTS-17.10
- Updates the GHC version
- Requires `extra-deps` for `diagrams` package
- Simplifies code for NGLessIO monad as UnliftIO can now be auto-derived
---
NGLess/NGLess/NGError.hs | 8 ++------
stack.yaml | 11 ++++++++---
2 files changed, 10 insertions(+), 9 deletions(-)
diff --git a/NGLess/NGLess/NGError.hs b/NGLess/NGLess/NGError.hs
index a22e557f..c7eddf5b 100644
--- a/NGLess/NGLess/NGError.hs
+++ b/NGLess/NGLess/NGError.hs
@@ -50,7 +50,8 @@ type NGLess = Either NGError
newtype NGLessIO a = NGLessIO { unwrapNGLessIO :: ResourceT IO a }
deriving (Functor, Applicative, Monad, MonadIO,
- MonadResource, MonadThrow, MonadCatch, MonadMask)
+ MonadResource, MonadThrow, MonadCatch, MonadMask,
+ MonadUnliftIO)
instance MonadError NGError NGLessIO where
@@ -62,11 +63,6 @@ instance PrimMonad NGLessIO where
primitive act = NGLessIO (primitive act)
{-# INLINE primitive #-}
-instance MonadUnliftIO NGLessIO where
- askUnliftIO = NGLessIO $ do
- u <- askUnliftIO
- return $ UnliftIO (\(NGLessIO act) -> unliftIO u act)
-
instance MonadFail NGLessIO where
fail err = throwShouldNotOccur err
diff --git a/stack.yaml b/stack.yaml
index 051d973d..11b65887 100644
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,14 +1,19 @@
# For more information, see: https://github.com/commercialhaskell/stack/blob/release/doc/yaml_configuration.md
-resolver: lts-14.20
+resolver: lts-17.10
compiler-check: newer-minor
# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
extra-deps:
- git: "https://github.com/ngless-toolkit/interval-to-int"
commit: "78289f6b48d41f7cc48169520ec9b77b050a0029"
-
-
+ - diagrams-core-1.4.2@sha256:47de45658e8a805b7cb7f535e7b093daf7e861604fa3c70e25bd4ef481bf1571,2997
+ - diagrams-lib-1.4.3@sha256:04f77778d4b550d3c8e54440800685f88467bef91075e82e009a8a6f45c51033,8232
+ - diagrams-svg-1.4.3@sha256:36708b0b4cf35507ccf689f1a25f6f81b8f41c2c4c2900793de820f66d4e241c,3181
+ - active-0.2.0.14@sha256:e618aba4a7881eb85dc1585e0a01230af6b4fbab6693931e4a5d0d3a5b184406,1823
+ - dual-tree-0.2.2.1@sha256:9ff31e461d873ae74ba51d93b454c0c4094726d7cb78a0c454394c965e83539d,2830
+ - monoid-extras-0.5.1@sha256:438dbfd7b4dce47d8f0ca577f56caf94bd1e21391afa545cad09fe7cf2e5793d,2333
+ - svg-builder-0.1.1@sha256:22de54d326a6b6912e461e1302edb9108b02aac0b6a6368fcdc3c4a224d487fd,1440
allow-newer: true
# Override default flag values for local packages and extra-deps

24
gnu/packages/patches/xmonad-dynamic-linking.patch
View File

@ -2,15 +2,15 @@ This patch is required for xmonad to make use of shared libraries.
Without it, xmonad will not work since we do not (by default) use Without it, xmonad will not work since we do not (by default) use
statically linked Haskell libraries. statically linked Haskell libraries.
diff -ruN xmonad-0.15-a/src/XMonad/Core.hs xmonad-0.15-b/src/XMonad/Core.hs index 46a0939..5ad4f8f 100644
--- xmonad-0.15-a/src/XMonad/Core.hs 1969-12-31 19:00:00.000000000 -0500 --- a/src/XMonad/Core.hs
+++ xmonad-0.15-b/src/XMonad/Core.hs 1969-12-31 19:00:00.000000000 -0500 +++ b/src/XMonad/Core.hs
@@ -681,6 +681,8 @@ @@ -664,6 +664,8 @@ compile dirs method =
compileGHC bin dir errHandle = where
runProcess "ghc" ["--make" ghcArgs = [ "--make"
, "xmonad.hs" , "xmonad.hs"
+ , "-dynamic" + , "-dynamic"
+ , "-fPIC" + , "-fPIC"
, "-i" , "-i" -- only look in @lib@
, "-ilib" , "-ilib"
, "-fforce-recomp" , "-fforce-recomp"

16
gnu/packages/patches/xmonad-next-dynamic-linking.patch
View File

@ -1,16 +0,0 @@
This patch is required for xmonad to make use of shared libraries.
Without it, xmonad will not work since we do not (by default) use
statically linked Haskell libraries.
index 46a0939..5ad4f8f 100644
--- a/src/XMonad/Core.hs
+++ b/src/XMonad/Core.hs
@@ -664,6 +664,8 @@ compile dirs method =
where
ghcArgs = [ "--make"
, "xmonad.hs"
+ , "-dynamic"
+ , "-fPIC"
, "-i" -- only look in @lib@
, "-ilib"
, "-fforce-recomp"

158
gnu/packages/purescript.scm
View File

@ -34,79 +34,67 @@
(define-public purescript (define-public purescript
(package (package
(name "purescript") (name "purescript")
(version "0.14.5") (version "0.15.7")
(source (source
(origin (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "purescript" version)) (uri (hackage-uri "purescript" version))
(sha256 (sha256
(base32 "06f318hdah076vkviw1ryyg2p0gpbabsp8lbm5x03f2qv92n9j1n")))) (base32 "1krjkgmxpfqf5a1jqs7qbg6r7ball1464zw6vgrdfzl9057c6l4f"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "purescript"))) (properties '((upstream-name . "purescript")))
(inputs (inputs (list ghc-aeson
(list ghc-glob ghc-aeson-better-errors
ghc-aeson ghc-ansi-terminal
ghc-aeson-better-errors ghc-blaze-html
ghc-aeson-pretty ghc-bower-json
ghc-ansi-terminal ghc-boxes
ghc-base-compat ghc-cborg
ghc-blaze-html ghc-serialise
ghc-bower-json ghc-cheapskate
ghc-boxes ghc-clock
ghc-cborg ghc-cryptonite
ghc-cheapskate ghc-data-ordlist
ghc-clock ghc-dlist
ghc-cryptonite ghc-edit-distance
ghc-data-ordlist ghc-file-embed
ghc-dlist ghc-glob
ghc-edit-distance ghc-language-javascript
ghc-file-embed ghc-lens
ghc-fsnotify ghc-lifted-async
ghc-happy ghc-lifted-base
ghc-language-javascript ghc-memory
ghc-lifted-async ghc-monad-control
ghc-lifted-base ghc-monad-logger
ghc-memory ghc-monoidal-containers
ghc-microlens-platform ghc-parallel
ghc-monad-control ghc-pattern-arrows
ghc-monad-logger ghc-protolude
ghc-network ghc-regex-tdfa
ghc-parallel ghc-safe
ghc-pattern-arrows ghc-scientific
ghc-protolude ghc-semigroups
ghc-purescript-cst ghc-semialign
ghc-regex-tdfa ghc-sourcemap
ghc-safe ghc-stringsearch
ghc-scientific ghc-these
ghc-semialign ghc-transformers-base
ghc-semigroups ghc-utf8-string
ghc-serialise ghc-vector
ghc-sourcemap ghc-witherable
ghc-split ghc-ansi-wl-pprint
ghc-stringsearch ghc-network
ghc-syb ghc-optparse-applicative
ghc-these ghc-gitrev))
ghc-transformers-base (native-inputs (list ghc-generic-random
ghc-transformers-compat ghc-hspec
ghc-unordered-containers ghc-hunit
ghc-utf8-string ghc-newtype
ghc-vector ghc-quickcheck
ghc-ansi-wl-pprint ghc-regex-base
ghc-http-types ghc-split
ghc-network ghc-typed-process
ghc-optparse-applicative-0.15.1.0 ; XXX: needs specific version ghc-happy))
ghc-wai
ghc-wai-websockets
ghc-warp
ghc-websockets))
(native-inputs
(list ghc-happy
ghc-hunit
ghc-hspec
hspec-discover
ghc-tasty
ghc-tasty-golden
ghc-tasty-hspec))
(arguments (arguments
`(;; Tests require npm `(;; Tests require npm
#:tests? #f #:tests? #f
@ -116,7 +104,7 @@
(add-before 'configure 'update-constraints (add-before 'configure 'update-constraints
(lambda _ (lambda _
(substitute* "purescript.cabal" (substitute* "purescript.cabal"
(("\\b(ansi-terminal|cryptonite|dlist|language-javascript)\\s+[^,]+" all dep) (("\\b(language-javascript|process)\\s+[^,]+" all dep)
dep))))))) dep)))))))
(home-page "https://www.purescript.org/") (home-page "https://www.purescript.org/")
(synopsis "Haskell inspired programming language compiling to JavaScript") (synopsis "Haskell inspired programming language compiling to JavaScript")
@ -125,39 +113,3 @@
expressive types, inspired by Haskell and compiling to JavaScript.") expressive types, inspired by Haskell and compiling to JavaScript.")
(license license:bsd-3))) (license license:bsd-3)))
(define-public ghc-purescript-cst
(package
(name "ghc-purescript-cst")
(version "0.4.0.0")
(source
(origin
(method url-fetch)
(uri (hackage-uri "purescript-cst" version))
(sha256
(base32 "0r3f5lr9lrv9wpgkwj6nyl42lvxryj2lvr1w7ld4gki8ylq24n8g"))))
(build-system haskell-build-system)
(properties '((upstream-name . "purescript-cst")))
(arguments
`(#:phases
(modify-phases %standard-phases
(add-before 'configure 'update-constraints
(lambda _
(substitute* "purescript-cst.cabal"
(("\\b(dlist)\\s+[^,]+" all dep)
dep)))))))
(inputs
(list ghc-aeson
ghc-base-compat
ghc-dlist
ghc-microlens
ghc-protolude
ghc-scientific
ghc-semigroups
ghc-serialise
ghc-vector))
(native-inputs (list ghc-happy))
(home-page "https://www.purescript.org/")
(synopsis "PureScript Programming Language Concrete Syntax Tree")
(description
"This package implements parser for the PureScript programming language.")
(license license:bsd-3)))

117
gnu/packages/wm.scm
View File

@ -801,40 +801,26 @@ background wallpaper manager with transparency support, a simple session
manager and a system tray.") manager and a system tray.")
(license license:lgpl2.0))) (license license:lgpl2.0)))
(define-public xmonad
(define-public xmonad-next
(package (package
(name "xmonad-next") (name "xmonad")
(version "0.17.0") (version "0.17.1")
(synopsis "Tiling window manager")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "xmonad" version)) (uri (hackage-uri "xmonad" version))
(sha256 (sha256
(base32 (base32
"04qspdz9w6xpw1npcmx2zx0595wc68q985pv4i0hvp32zillvdqy")) "1apqwyqmc51gamfgsvlanzqqig9qvjss89ibcamhnha1gs1k4jl8"))
(patches (search-patches "xmonad-next-dynamic-linking.patch")))) (patches (search-patches "xmonad-dynamic-linking.patch"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "xmonad"))) (properties '((upstream-name . "xmonad")))
(inputs (list ghc-data-default-class ghc-setlocale ghc-x11)) (inputs (list ghc-x11 ghc-data-default-class ghc-setlocale))
(native-inputs (list ghc-quickcheck ghc-quickcheck-classes)) (native-inputs (list ghc-quickcheck ghc-quickcheck-classes))
(arguments (arguments
(list #:phases `(#:cabal-revision ("2"
#~(modify-phases %standard-phases "1rgwrnyb7kijzl2mqm8ks2nydh37q5vkbg4400rg9n6x13w2r9b3")))
(add-after 'install 'install-xsession (home-page "http://xmonad.org")
(lambda _ (synopsis "Tiling window manager")
(let ((xsessions (string-append #$output "/share/xsessions")))
(mkdir-p xsessions)
(call-with-output-file (string-append xsessions
"/xmonad.desktop")
(lambda (port)
(format port "~
[Desktop Entry]~@
Name=~a~@
Comment=~a~@
Exec=~a/bin/xmonad~@
Type=Application~%" #$name #$synopsis #$output)))))))))
(home-page "https://xmonad.org")
(description (description
"Xmonad is a tiling window manager for X. Windows are arranged "Xmonad is a tiling window manager for X. Windows are arranged
automatically to tile the screen without gaps or overlap, maximising screen automatically to tile the screen without gaps or overlap, maximising screen
@ -846,42 +832,16 @@ used on each workspace. Xinerama is fully supported, allowing windows to be
tiled on several screens.") tiled on several screens.")
(license license:bsd-3))) (license license:bsd-3)))
(define-public xmonad
(package
(inherit xmonad-next)
(name "xmonad")
(version "0.15")
(source (origin
(method url-fetch)
(uri (hackage-uri "xmonad" version))
(sha256
(base32
"0a7rh21k9y6g8fwkggxdxjns2grvvsd5hi2ls4klmqz5xvk4hyaa"))
(patches (search-patches "xmonad-dynamic-linking.patch"))))
(inputs
(list ghc-extensible-exceptions
ghc-data-default
ghc-quickcheck
ghc-semigroups
ghc-setlocale
ghc-utf8-string
ghc-x11))
(native-inputs '())
(arguments
`(#:cabal-revision
("1" "0yqh96qqphllr0zyz5j93cij5w2qvf39xxnrb52pz0qz3pywz9wd")
,@(package-arguments xmonad-next)))))
(define-public xmobar (define-public xmobar
(package (package
(name "xmobar") (name "xmobar")
(version "0.44.2") (version "0.46")
(source (origin (source (origin
(method url-fetch) (method url-fetch)
(uri (hackage-uri "xmobar" version)) (uri (hackage-uri "xmobar" version))
(sha256 (sha256
(base32 (base32
"0gdphjn5ll5lkb2psdsb34563wsz6g0y2gg3z8cj4jy8lvbbv808")))) "0glpiq7c0qwfcxnc2flgzj7afm5m1a9ghzwwcq7f8q27m21kddrd"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "xmobar"))) (properties '((upstream-name . "xmobar")))
(native-inputs (native-inputs
@ -904,6 +864,8 @@ tiled on several screens.")
ghc-timezone-olson ghc-timezone-olson
ghc-x11 ghc-x11
ghc-x11-xft ghc-x11-xft
ghc-cairo
ghc-pango
libxpm)) libxpm))
(arguments (arguments
`(#:configure-flags (list "--flags=all_extensions") `(#:configure-flags (list "--flags=all_extensions")
@ -945,53 +907,30 @@ Unlike dmenu, it mangles the input before it presents its choices. In
particular, it displays commonly-chosen options before uncommon ones.") particular, it displays commonly-chosen options before uncommon ones.")
(license license:bsd-3))) (license license:bsd-3)))
(define-public ghc-xmonad-contrib-next (define-public ghc-xmonad-contrib
(package (package
(name "ghc-xmonad-contrib-next") (name "ghc-xmonad-contrib")
(version "0.17.0") (version "0.17.1")
(source (source (origin
(origin (method url-fetch)
(method url-fetch) (uri (hackage-uri "xmonad-contrib" version))
(uri (hackage-uri "xmonad-contrib" version)) (sha256
(sha256 (base32
(base32 "11g1cyfgfvcmz35qhgi9wzxrk3br8m8b7qy3jvph4nnf6aj13wvy")))) "0lwj8xkyaw6h0rv3lz2jdqrwzz7yghfmnhpndygkb3wgyhvq6dxb"))))
(build-system haskell-build-system) (build-system haskell-build-system)
(properties '((upstream-name . "xmonad-contrib"))) (properties '((upstream-name . "xmonad-contrib")))
(propagated-inputs (list ghc-random ghc-x11 ghc-utf8-string ghc-x11-xft xmonad-next)) (inputs (list ghc-random ghc-x11 xmonad ghc-utf8-string ghc-x11-xft))
(native-inputs (list ghc-quickcheck ghc-hspec)) (native-inputs (list ghc-quickcheck ghc-hspec))
(home-page "https://xmonad.org") (arguments
`(#:cabal-revision ("1"
"0dc9nbn0kaw98rgpi1rq8np601zjhdr1y0ydg6yb82wwaqawql6z")))
(home-page "https://xmonad.org/")
(synopsis "Third party extensions for xmonad") (synopsis "Third party extensions for xmonad")
(description (description
"Third party tiling algorithms, configurations, and scripts to Xmonad, a "Third party tiling algorithms, configurations, and scripts to Xmonad, a
tiling window manager for X.") tiling window manager for X.")
(license license:bsd-3))) (license license:bsd-3)))
(define-public ghc-xmonad-contrib
(package
(inherit ghc-xmonad-contrib-next)
(name "ghc-xmonad-contrib")
(version "0.16")
(source
(origin
(method url-fetch)
(uri (hackage-uri "xmonad-contrib" version))
(sha256
(base32 "1pddgkvnbww28wykncc7j0yb0lv15bk7xnnhdcbrwkxzw66w6wmd"))))
(arguments
`(#:cabal-revision
("1" "0vimkby2gq6sgzxzbvz67caba609xqlv2ii2gi8a1cjrnn6ib011")
,@(package-arguments ghc-xmonad-contrib-next)))
(native-inputs '())
(propagated-inputs
(list ghc-old-time
ghc-random
ghc-utf8-string
ghc-extensible-exceptions
ghc-semigroups
ghc-x11
ghc-x11-xft
xmonad))))
(define-public evilwm (define-public evilwm
(package (package
(name "evilwm") (name "evilwm")