#:use-module (gnu packages base)
#:use-module (gnu packages compression)
#:use-module (gnu packages emacs)
- #:use-module (gnu packages gcc)
#:use-module (gnu packages gl)
#:use-module (gnu packages graphviz)
#:use-module (gnu packages gtk)
("alsa-lib" ,alsa-lib)))
(native-inputs
`(("pkg-config" ,pkg-config)))
- (home-page "http://www.haskell.org/haskellwiki/ALSA")
+ (home-page "https://wiki.haskell.org/ALSA")
(synopsis "Binding to the ALSA Library API (Exceptions)")
(description "This package provides access to ALSA infrastructure, that is
needed by both alsa-seq and alsa-pcm.")
permissions while atomically writing to a file.")
(license license:expat)))
+(define-public ghc-atomic-write-0.2.0.7
+ (package
+ (inherit ghc-atomic-write)
+ (version "0.2.0.7")
+ (source
+ (origin
+ (inherit (package-source ghc-atomic-write))
+ (uri (string-append
+ "https://hackage.haskell.org/package/atomic-write/atomic-write-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "03cn3ii74h0w3g4h78xsx9v2sn58r3qsr2dbdwq340xwhiwcgxdm"))))))
+
(define-public ghc-attoparsec
(package
(name "ghc-attoparsec")
(base32
"1ia6li7qjg1zkak4gf6mnbshw45mq9bfjr0jch58ds0lscmvwyzf"))))
(build-system haskell-build-system)
- (home-page "http://www.haskell.org/haskellwiki/Unicode-symbols")
+ (home-page "https://wiki.haskell.org/Unicode-symbols")
(synopsis "Unicode alternatives for common functions and operators")
(description "This package defines new symbols for a number of functions,
operators and types in the base package. All symbols are documented with
`(("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-hunit" ,ghc-hunit)
- ("ghc-shelly" ,ghc-shelly)
- ("gcc" ,gcc)))
+ ("ghc-shelly" ,ghc-shelly)))
(arguments
- `(;; XXX: Test failures are induced by a parse error in <bits/floatn.h>
- ;; of glibc 2.28.
- #:tests? #f
-
- #:phases
+ `(#:phases
(modify-phases %standard-phases
(add-before 'check 'set-cc
;; add a cc executable in the path, needed for some tests to pass
;; ghc-test-framework -> ghc-ansi-terminal -> ghc-colour.
`(#:tests? #f))
(build-system haskell-build-system)
- (home-page "https://www.haskell.org/haskellwiki/Colour")
+ (home-page "https://wiki.haskell.org/Colour")
(synopsis "Model for human colour perception")
(description
"This package provides a data type for colours and transparency.
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
- (home-page "http://github.com/bos/configurator")
+ (home-page "https://github.com/bos/configurator")
(synopsis "Configuration management")
(description
"This package provides a configuration management library for programs
(sha256
(base32 "1fq4gygxbz0bd0mzgvc1sl3m4gjnsv8nbgpnmdpa29zj5lb9agxc"))))
(build-system haskell-build-system)
- (home-page "https://www.haskell.org/haskellwiki/Record_access")
+ (home-page "https://wiki.haskell.org/Record_access")
(synopsis
"Haskell utilities for accessing and manipulating fields of records")
(description "This package provides Haskell modules for accessing and
(base32 "0yp030vafbpddl27m606aibbbr5ar5j5bsv4bksscz3cq4yq5j10"))))
(build-system haskell-build-system)
(inputs `(("ghc-data-accessor" ,ghc-data-accessor)))
- (home-page "https://www.haskell.org/haskellwiki/Record_access")
+ (home-page "https://wiki.haskell.org/Record_access")
(synopsis "Use Accessor to access state in transformers State monad")
(description "This package provides Haskell modules to allow use of
Accessor to access state in transformers State monad.")
and @code{withBaseCase}) or implicitly (@code{genericArbitrary'}).")
(license license:expat)))
+(define-public ghc-generic-random-1.3.0.1
+ (package
+ (inherit ghc-generic-random)
+ (version "1.3.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/generic-random/"
+ "generic-random-" version ".tar.gz"))
+ (sha256
+ (base32 "0d9w7xcmsb31b95fr9d5jwbsajcl1yi4347dlbw4bybil2vjwd7k"))))
+ (arguments '())))
+
(define-public ghc-generics-sop
(package
(name "ghc-generics-sop")
(build-system haskell-build-system)
(inputs
`(("ghc-openglraw" ,ghc-openglraw)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/Opengl")
(synopsis "Raw Haskell bindings GLU")
(description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
("ghc-opengl" ,ghc-opengl)
("ghc-openglraw" ,ghc-openglraw)
("freeglut" ,freeglut)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/Opengl")
(synopsis "Haskell bindings for the OpenGL Utility Toolkit")
(description "This library provides Haskell bindings for the OpenGL
Utility Toolkit, a window system-independent toolkit for writing OpenGL
(substitute* "os/generic/Graphics/Gnuplot/Private/OS.hs"
(("(gnuplotName = ).*$" all cmd)
(string-append cmd "\"" gnuplot "/bin/gnuplot\"")))))))))
- (home-page "https://www.haskell.org/haskellwiki/Gnuplot")
+ (home-page "https://wiki.haskell.org/Gnuplot")
(synopsis "2D and 3D plots using gnuplot")
(description "This package provides a Haskell module for creating 2D and
3D plots using gnuplot.")
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/haskell/haddock.git")
+ (url "https://github.com/haskell/haddock")
(commit (string-append "haddock-" version "-release"))))
(file-name (git-file-name name version))
(sha256
(inputs
`(("ghc-syb" ,ghc-syb)
("ghc-xml" ,ghc-xml)))
- (home-page "http://www.haskell.org/haddock/")
+ (home-page "https://www.haskell.org/haddock/")
(synopsis "Test utilities for Haddock")
(description "This package provides test utilities for Haddock.")
(license license:bsd-3)
a set of wrappers to use the hash tables in the IO monad.")
(license license:bsd-3)))
+(define-public ghc-haskeline-0.8
+ (package
+ (name "ghc-haskeline")
+ (version "0.8.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/haskeline/haskeline-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0gqsa5s0drim9m42hv4wrq61mnvcdylxysfxfw3acncwilfrn9pb"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-exceptions" ,ghc-exceptions)))
+ (native-inputs `(("ghc-hunit" ,ghc-hunit)))
+ ;; FIXME: Tests failing
+ (arguments `(#:tests? #f))
+ (home-page "https://github.com/judah/haskeline")
+ (synopsis
+ "Command-line interface for user input, written in Haskell")
+ (description
+ "Haskeline provides a user interface for line input in command-line
+programs. This library is similar in purpose to readline, but since it is
+written in Haskell it is (hopefully) more easily used in other Haskell
+programs.
+
+Haskeline runs both on POSIX-compatible systems and on Windows.")
+ (license license:bsd-3)))
+
(define-public ghc-haskell-lexer
(package
(name "ghc-haskell-lexer")
("ghc-utf8-string" ,ghc-utf8-string)
("ghc-microlens-platform" ,ghc-microlens-platform)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://github.com/MarcWeber/hasktags")
+ (home-page "https://github.com/MarcWeber/hasktags")
(synopsis "Make @code{Ctags} and @code{Etags} files for Haskell programs")
(description
"This package provides a means of generating tag files for Emacs and
indexed variants.")
(license license:bsd-3)))
+(define-public ghc-lens-family-core
+ (package
+ (name "ghc-lens-family-core")
+ (version "1.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/lens-family-core/lens-family-core-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "009rf10pj1cb50v44cc1pq7qvfrmkkk9dikahs9qmvbvgl3mykwi"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/lens-family-core")
+ (synopsis "Haskell 98 Lens Families")
+ (description
+ "This package provides first class functional references. In addition to
+the usual operations of getting, setting and composition, plus integration
+with the state monad, lens families provide some unique features:
+
+@itemize
+@item Polymorphic updating
+@item Traversals
+@item Cast projection functions to read-only lenses
+@item Cast @code{toList} functions to read-only traversals
+@item Cast semantic editor combinators to modify-only traversals
+@end itemize
+
+For optimal first-class support use the lens-family package with rank 2/rank N
+polymorphism. @code{Lens.Family.Clone} allows for first-class support of
+lenses and traversals for those who require Haskell 98.")
+ (license license:bsd-3)))
+
(define-public ghc-libffi
(package
(name "ghc-libffi")
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://github.com/ekmett/linear/")
+ (home-page "https://github.com/ekmett/linear/")
(synopsis "Linear algebra library for Haskell")
(description
"This package provides types and combinators for linear algebra on free
than its name.")
(license license:bsd-3)))
+(define-public ghc-managed
+ (package
+ (name "ghc-managed")
+ (version "1.0.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/managed/managed-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1kbrw99yh5x5blykmx2n88mplbbi4ss1ij5j17b7asw6q0ihm9zi"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/managed")
+ (synopsis "Monad for managed values")
+ (description
+ "In Haskell you very often acquire values using the with... idiom using
+functions of type (a -> IO r) -> IO r. This idiom forms a Monad, which is a
+special case of the ContT monad (from transformers) or the Codensity
+monad (from kan-extensions). The main purpose behind this package is to
+provide a restricted form of these monads specialized to this unusually common
+case.
+
+The reason this package defines a specialized version of these types
+is to:
+
+@itemize
+@item be more beginner-friendly,
+@item simplify inferred types and error messages, and:
+@item provide some additional type class instances that would otherwise be
+orphan instances
+@end itemize")
+ (license license:bsd-3)))
+
(define-public ghc-markdown-unlit
(package
(name "ghc-markdown-unlit")
`(("ghc-errorcall-eq-instance" ,ghc-errorcall-eq-instance)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)))
- (home-page "https://software.complete.org/missingh")
+ ;; ‘Official’ <http://software.complete.org/missingh> redirects to a 404.
+ (home-page "https://github.com/haskell-hvr/missingh")
(synopsis "Large utility library")
(description
"MissingH is a library of all sorts of utility functions for Haskell
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
- (home-page "http://github.com/sjakobi/newtype-generics")
+ (home-page "https://github.com/sjakobi/newtype-generics")
(synopsis "Typeclass and set of functions for working with newtypes")
(description "The @code{Newtype} typeclass represents the packing and
unpacking of a newtype, and allows you to operate under that newtype with
("ghc-gluraw" ,ghc-gluraw)
("ghc-statevar" ,ghc-statevar)
("ghc-openglraw" ,ghc-openglraw)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/Opengl")
(synopsis "Haskell bindings for the OpenGL graphics system")
(description "This package provides Haskell bindings for the OpenGL
graphics system (GL, version 4.5) and its accompanying utility library (GLU,
`(("ghc-half" ,ghc-half)
("ghc-fixed" ,ghc-fixed)
("glu" ,glu)))
- (home-page "https://www.haskell.org/haskellwiki/Opengl")
+ (home-page "https://wiki.haskell.org/Opengl")
(synopsis "Raw Haskell bindings for the OpenGL graphics system")
(description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
DSLs, etc.")
(license license:bsd-3)))
+(define-public ghc-optional-args
+ (package
+ (name "ghc-optional-args")
+ (version "1.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/optional-args/optional-args-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1r5hhn6xvc01grggxdyy48daibwzi0aikgidq0ahpa6bfynm8d1f"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/optional-args")
+ (synopsis "Optional function arguments")
+ (description
+ "This library provides a type for specifying @code{Optional} function
+arguments.")
+ (license license:bsd-3)))
+
(define-public ghc-options
(package
(name "ghc-options")
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-hunit" ,ghc-hunit)))
- (home-page "http://johnmacfarlane.net/pandoc")
+ (home-page "https://johnmacfarlane.net/pandoc")
(synopsis "Types for representing a structured document")
(description
"This module defines the @code{Pandoc} data structure, which is used by
libraries.")
(license license:expat)))
+(define-public ghc-pgp-wordlist
+ (package
+ (name "ghc-pgp-wordlist")
+ (version "0.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/pgp-wordlist/pgp-wordlist-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "15g6qh0fb7kjj3l0w8cama7cxgnhnhybw760md9yy7cqfq15cfzg"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-doctest" ,ghc-doctest)))
+ (home-page
+ "https://github.com/quchen/pgp-wordlist")
+ (synopsis
+ "Translate between binary data and a human-readable collection of words")
+ (description
+ "The PGP Word List consists of two phonetic alphabets, each with one word
+per possible byte value. A string of bytes is translated with these
+alphabets, alternating between them at each byte.
+
+The PGP words corresponding to the bytes 5B 1D CA 6E are \"erase breakaway
+spellbind headwaters\", for example.
+
+For further information, see
+@url{http://en.wikipedia.org/wiki/PGP_word_list}.")
+ (license license:bsd-3)))
+
(define-public ghc-pipes
(package
(name "ghc-pipes")
types.")
(license license:bsd-3)))
+(define-public ghc-prettyprinter
+ (package
+ (name "ghc-prettyprinter")
+ (version "1.2.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/prettyprinter/prettyprinter-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "1p9c3q55hba4c0zyxc624g5df7wgsclpsmd8wqpdnmib882q9d1v"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-pgp-wordlist" ,ghc-pgp-wordlist)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/quchen/prettyprinter")
+ (synopsis
+ "Modern, easy to use, well-documented, extensible pretty-printer")
+ (description
+ "A prettyprinter/text rendering engine. Easy to use, well-documented,
+ANSI terminal backend exists, HTML backend is trivial to implement, no name
+clashes, @code{Text}-based, extensible.")
+ (license license:bsd-2)))
+
+(define-public ghc-prettyprinter-1.6
+ (package
+ (inherit ghc-prettyprinter)
+ (version "1.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/prettyprinter/prettyprinter-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "10fphxh8lvdaw7i8jyllwmj87w02db92mf99zfw5vddp9mv6b5rz"))))
+ (inputs
+ `(("ghc-quickckeck-instances" , ghc-quickcheck-instances)
+ ,@(package-inputs ghc-prettyprinter)))))
+
+(define-public ghc-prettyprinter-ansi-terminal
+ (package
+ (name "ghc-prettyprinter-ansi-terminal")
+ (version "1.1.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/prettyprinter-ansi-terminal/"
+ "prettyprinter-ansi-terminal-" version ".tar.gz"))
+ (sha256
+ (base32 "0ha6vz707qzb5ky7kdsnw2zgphg2dnxrpbrxy8gaw119vwhb9q6k"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-prettyprinter" ,ghc-prettyprinter-1.6)))
+ (native-inputs `(("ghc-doctest" ,ghc-doctest)))
+ (home-page
+ "https://github.com/quchen/prettyprinter")
+ (synopsis
+ "ANSI terminal backend for the prettyprinter package")
+ (description "ANSI terminal backend for the prettyprinter package.")
+ (license license:bsd-2)))
+
(define-public ghc-pretty-hex
(package
(name "ghc-pretty-hex")
(inputs
`(("ghc-haskell-lexer" ,ghc-haskell-lexer)
("ghc-happy" ,ghc-happy)))
- (home-page "http://wiki.github.com/yav/pretty-show")
+ (home-page "https://wiki.github.com/yav/pretty-show")
(synopsis "Tools for working with derived `Show` instances")
(description
"This package provides a library and an executable for working with
examination.")
(license license:expat)))
+(define-public ghc-pretty-simple
+ (package
+ (name "ghc-pretty-simple")
+ (version "2.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/pretty-simple/"
+ "pretty-simple-" version ".tar.gz"))
+ (sha256
+ (base32 "0wsi9235ihm15s145lxi7325vv2k4bhighc5m88kn1lk0pl81aqq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-glob" ,ghc-glob)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-aeson" ,ghc-aeson)))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)))
+ (home-page "https://github.com/cdepillabout/pretty-simple")
+ (synopsis "Pretty printer for data types with a 'Show' instance")
+ (description
+ "Pretty-simple is a pretty printer for Haskell data types that have a
+Show instance.")
+ (license license:bsd-3)))
+
(define-public ghc-primitive
(package
(name "ghc-primitive")
replace the standard one provided by GHC.")
(license license:expat)))
+(define-public ghc-psqueue
+ (package
+ (name "ghc-psqueue")
+ (version "1.1.0.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "mirror://hackage/package/PSQueue-"
+ version "/PSQueue-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1cik7sw10sacsijmfhghzy54gm1qcyxw14shlp86lx8z89kcnkza"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/PSQueue")
+ (synopsis "Priority search queue")
+ (description
+ "A @dfn{priority search queue} efficiently supports the operations of
+both a search tree and a priority queue. A @code{Binding} is a product of
+a key and a priority. Bindings can be inserted, deleted, modified and queried
+in logarithmic time, and the binding with the least priority can be retrieved
+in constant time. A queue can be built from a list of bindings, sorted by
+keys, in linear time.")
+ (license license:bsd-3)))
+
(define-public ghc-psqueues
(package
(name "ghc-psqueues")
this problem.")
(license license:bsd-3)))
+(define-public ghc-regex-pcre
+ (package
+ (name "ghc-regex-pcre")
+ (version "0.94.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "regex-pcre/regex-pcre-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1h16w994g9s62iwkdqa7bar2n9cfixmkzz2rm8svm960qr57valf"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("pcre" ,pcre)))
+ (home-page "https://hackage.haskell.org/package/regex-pcre")
+ (synopsis "Enhancement of the builtin Text.Regex library")
+ (description
+ "This package is an enhancement of the @code{Text.Regex} library.
+It wraps the @code{PCRE} C library providing Perl-compatible regular
+expressions.")
+ (license license:bsd-3)))
+
(define-public ghc-regex-pcre-builtin
(package
(name "ghc-regex-pcre-builtin")
(build-system haskell-build-system)
(inputs
`(("ghc-regex-base" ,ghc-regex-base)))
- (home-page "https://hackage.haskell.org/package/regex-pcre")
+ (home-page "https://hackage.haskell.org/package/regex-pcre-builtin")
(synopsis "Enhancement of the builtin Text.Regex library")
(description
"This package is an enhancement of the @code{Text.Regex} library,
"This provides an extra text interface for regex-tdfa.")
(license license:bsd-3)))
+(define-public ghc-repline
+ (package
+ (name "ghc-repline")
+ (version "0.2.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/repline/repline-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1ph21kbbanlcs8n5lwk16g9vqkb98mkbz5mzwrp8j2rls2921izc"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/sdiehl/repline")
+ (synopsis "Haskeline wrapper for GHCi-like REPL interfaces")
+ (description
+ "Haskeline wrapper for GHCi-like REPL interfaces. Composable with
+normal mtl transformers.")
+ (license license:expat)))
+
+(define-public ghc-repline-0.3
+ (package
+ (inherit ghc-repline)
+ (version "0.3.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/repline/repline-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0niihfyggg2qisadg7w49cr5k5qyyynia93iip0ng2bbmzwi88g8"))))
+ (inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-haskeline" ,ghc-haskeline-0.8)))))
+
(define-public ghc-rerebase
(package
(name "ghc-rerebase")
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-hedgehog" ,ghc-tasty-hedgehog)
("ghc-hedgehog" ,ghc-hedgehog)))
- (home-page "http://github.com/Soostone/retry")
+ (home-page "https://github.com/Soostone/retry")
(synopsis "Retry combinators for monadic actions that may fail")
(description "This package exposes combinators that can wrap
arbitrary monadic actions. They run the action and potentially retry
("ghc-hashable" ,ghc-hashable-bootstrap)))
(properties '((hidden? #t)))))
+(define-public ghc-serialise
+ (package
+ (name "ghc-serialise")
+ (version "0.2.1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/serialise/serialise-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "19ary6ivzk8z7wcxhm860qmh7pwqj0qjqzav1h42y85l608zqgh4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-cborg" ,ghc-cborg)
+ ("ghc-half" ,ghc-half)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1rknhad1i8bpknsnphmcmb6dnb48c2p2c13ia2qqch3hkhsvfpr6")))
+ (home-page "https://github.com/well-typed/cborg")
+ (synopsis "Binary serialisation library for Haskell values")
+ (description
+ "This package (formerly binary-serialise-cbor) provides pure,
+efficient serialization of Haskell values directly into ByteStrings for
+storage or transmission purposes. By providing a set of type class instances,
+you can also serialise any custom data type you have as well.
+
+The underlying binary format used is the 'Concise Binary Object
+Representation', or CBOR, specified in RFC 7049. As a result, serialised
+Haskell values have implicit structure outside of the Haskell program itself,
+meaning they can be inspected or analyzed without custom tools.
+
+An implementation of the standard bijection between CBOR and JSON is
+provided by the https://hackage.haskell.org/package/cborg-json
+package. Also see https://hackage.haskell.org/package/cbor-tool for a
+convenient command-line utility for working with CBOR data.")
+ (license license:bsd-3)))
+
(define-public ghc-setenv
(package
(name "ghc-setenv")
generics-sop}.")
(license license:bsd-3)))
+(define-public ghc-special-values
+ (package
+ (name "ghc-special-values")
+ (version "0.1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/special-values/"
+ "special-values-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1kkdw2c4d2hha99v9f89ahmifjxp7fxmxyfwq9a8xk6s0h9xs51w"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-scientific" ,ghc-scientific)
+ ("ghc-ieee754" ,ghc-ieee754)
+ ("ghc-nats" ,ghc-nats)))
+ (home-page
+ "https://github.com/minad/special-values#readme")
+ (synopsis "Typeclass providing special values")
+ (description
+ "Special values are provided by a SpecialValues typeclass. Those can be
+used for example by QuickCheck, see quickcheck-special." )
+ (license license:expat)))
+
(define-public ghc-split
(package
(name "ghc-split")
(native-inputs '())
(properties '((hidden? #t)))))
+(define-public ghc-spoon
+ (package
+ (name "ghc-spoon")
+ (version "0.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/spoon/spoon-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1m41k0mfy6fpfrv2ym4m5jsjaj9xdfl2iqpppd3c4d0fffv51cxr"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1"
+ "09s5jjcsg4g4qxchq9g2l4i9d5zh3rixpkbiysqcgl69kj8mwv74")))
+ (home-page
+ "http://hackage.haskell.org/package/spoon")
+ (synopsis
+ "Catch errors thrown from pure computations")
+ (description
+ "Takes an error-throwing expression and puts it back in the Maybe it
+belongs in.
+
+Note that this suffers from the
+@url{https://ghc.haskell.org/trac/ghc/ticket/5902}. Buyer beware.")
+ (license license:bsd-3)))
+
(define-public ghc-statevar
(package
(name "ghc-statevar")
("ghc-unsafe" ,ghc-unsafe)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-syb" ,ghc-syb)))
- (home-page "https://www.haskell.org/haskellwiki/Storable_Vector")
+ (home-page "https://wiki.haskell.org/Storable_Vector")
(synopsis "Fast, packed, strict storable arrays with a list interface")
(description "This library provides fast, packed, strict storable
arrays with a list interface, a chunky lazy list interface with variable
text package.")
(license license:bsd-2)))
+(define-public ghc-text-manipulate
+ (package
+ (name "ghc-text-manipulate")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/text-manipulate"
+ "/text-manipulate-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0bwxyjj3ll45srxhsp2ihikgqglvjc6m02ixr8xpvyqwkcfwgsg0"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page
+ "https://github.com/brendanhay/text-manipulate")
+ (synopsis
+ "Case conversion, word boundary manipulation, and textual subjugation")
+ (description
+ "Manipulate identifiers and structurally non-complex pieces of text by
+delimiting word boundaries via a combination of whitespace,
+control-characters, and case-sensitivity.
+
+Has support for common idioms like casing of programmatic variable names,
+taking, dropping, and splitting by word, and modifying the first character of
+a piece of text.
+
+Caution: this library makes heavy use of the text library's internal loop
+optimisation framework. Since internal modules are not guaranteed to have a
+stable API there is potential for build breakage when the text dependency is
+upgraded. Consider yourself warned!")
+ (license license:mpl2.0)))
+
(define-public ghc-text-metrics
(package
(name "ghc-text-metrics")
statically known size.")
(license license:bsd-3)))
+(define-public ghc-turtle
+ (package
+ (name "ghc-turtle")
+ (version "1.5.15")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/turtle/turtle-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0yckgsc2a4g5x867gni80ldp226bsnhncfbil4ql6v2zwm4r8p7f"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-async" ,ghc-async)
+ ("ghc-clock" ,ghc-clock)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-foldl" ,ghc-foldl)
+ ("ghc-hostname" ,ghc-hostname)
+ ("ghc-managed" ,ghc-managed)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-system-filepath" ,ghc-system-filepath)
+ ("ghc-system-fileio" ,ghc-system-fileio)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ ("ghc-optional-args" ,ghc-optional-args)
+ ("ghc-unix-compat" ,ghc-unix-compat)))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-fail" ,ghc-fail)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "02q1rv7zx31xz9wnmcqwd4w3iw7623p07iyi21zr0cqlignic5pg")))
+ (home-page
+ "http://hackage.haskell.org/package/turtle")
+ (synopsis "Shell programming, Haskell-style")
+ (description
+ "Turtle is a reimplementation of the Unix command line environment in
+Haskell so that you can use Haskell as both a shell and a scripting
+language. Features include:
+
+@itemize
+@item Batteries included: Command an extended suite of predefined utilities.
+@item Interoperability: You can still run external shell commands.
+@item Portability: Works on Windows, OS X, and Linux.
+@item Exception safety: Safely acquire and release resources.
+@item Streaming: Transform or fold command output in constant space.
+@item Patterns: Use typed regular expressions that can parse structured values.
+@item Formatting: Type-safe printf-style text formatting.
+@item Modern: Supports text and system-filepath.
+@end itemize
+
+Read \"Turtle.Tutorial\" for a detailed tutorial or \"Turtle.Prelude\" for a
+quick-start guide. Turtle is designed to be beginner-friendly, but as a
+result lacks certain features, like tracing commands. If you feel comfortable
+using turtle then you should also check out the Shelly library which provides
+similar functionality.")
+ (license license:bsd-3)))
+
(define-public ghc-typed-process
(package
(name "ghc-typed-process")
`(("ghc-syb" ,ghc-syb)
("ghc-hashable" ,ghc-hashable)
("ghc-unordered-containers" ,ghc-unordered-containers)))
- (home-page "http://community.haskell.org/~ndm/uniplate/")
+ (home-page "https://github.com/ndmitchell/uniplate")
(synopsis "Simple, concise and fast generic operations")
(description "Uniplate is a library for writing simple and concise generic
operations. Uniplate has similar goals to the original Scrap Your Boilerplate
(base32
"0azlzaxp2dn4l1nr7shsxah2magk1szf6fx0mv75az00qsjw6qg4"))))
(build-system haskell-build-system)
- (home-page "http://github.com/willdonnelly/xdg-basedir")
+ (home-page "https://github.com/willdonnelly/xdg-basedir")
(synopsis "XDG Base Directory library for Haskell")
(description "This package provides a library implementing the XDG Base Directory spec.")
(license license:bsd-3)))
HCoop / jackhill / guix / guix.git / blobdiff