diff options
Diffstat (limited to 'gnu/packages/haskell-xyz.scm')
| -rw-r--r-- | gnu/packages/haskell-xyz.scm | 621 |
1 files changed, 612 insertions, 9 deletions
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm index 5b9da15630..1655b88cb0 100644 --- a/gnu/packages/haskell-xyz.scm +++ b/gnu/packages/haskell-xyz.scm @@ -26,6 +26,8 @@ ;;; Copyright © 2020 JoJo <jo@jo.zone> ;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr> ;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org> +;;; Copyright © 2020 Carlo Holl <carloholl@gmail.com> +;;; Copyright © 2020 Christopher Lemmer Webber <cwebber@dustycloud.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -995,6 +997,32 @@ Users wishing to have an improved Prelude can use BasicPrelude. Developers wishing to create a new prelude should use CorePrelude.") (license license:expat))) +(define-public ghc-bencode + (package + (name "ghc-bencode") + (version "0.6.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/bencode/bencode-" + version ".tar.gz")) + (sha256 + (base32 "0znv0y3b3zm5jvhlvj5f5s7y93db67j9yd59w1bnrw2pqv30gqaq")))) + (build-system haskell-build-system) + (inputs + `(("ghc-transformers-compat" ,ghc-transformers-compat))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://hackage.haskell.org/package/bencode") + (synopsis "Parsers and printers for bencoded data") + (description + "This library provides parsers and printers for bencoded data. Bencode +is the encoding used by the peer-to-peer file sharing system BitTorrent for +storing and transmitting loosely structured data.") + (license license:bsd-3))) + (define-public ghc-bifunctors (package (name "ghc-bifunctors") @@ -1551,6 +1579,118 @@ constructor which can be parameterised by a string-like type like: the resulting type will be insensitive to cases.") (license license:bsd-3))) +(define-public ghc-cassava + (package + (name "ghc-cassava") + (version "0.5.2.0") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/cassava/cassava-" + version + ".tar.gz")) + (sha256 + (base32 + "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk")))) + (build-system haskell-build-system) + (inputs + `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-hashable" ,ghc-hashable) + ("ghc-scientific" ,ghc-scientific) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector) + ("ghc-only" ,ghc-only) + ("ghc-text-short" ,ghc-text-short) + ("ghc-bytestring-builder" ,ghc-bytestring-builder))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) + ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2))) + (arguments + `(#:cabal-revision + ("1" + "1ph8rf91z4nf1ryrh9s4gd1kq98jlgk2manwddkpch8k0n9xvfk4") + #:configure-flags '("--flags=-bytestring--lt-0_10_4"))) + (home-page "https://github.com/haskell-hvr/cassava") + (synopsis "CSV parsing and encoding library") + (description + "@code{cassava} is a library for parsing and encoding +@url{https://tools.ietf.org/html/rfc4180, RFC 4180} compliant @url{https:// +en.wikipedia.org/wiki/Comma-separated_values, comma-separated values (CSV)} +data, which is a textual line-oriented format commonly used for exchanging +tabular data. + +@code{cassava}'s API includes support for: + +@itemize @bullet + +@item +Index-based record-conversion +@item +Name-based record-conversion +@item +Typeclass directed conversion of fields and records +@item +Built-in field-conversion instances for standard types +@item +Customizable record-conversion instance derivation via GHC generics +@item +Low-level @url{https://hackage.haskell.org/package/bytestring), bytestring} +builders (see @url{https://hackage.haskell.org/package/cassava-0.5.2.0/docs/ +Data-Csv-Builder.html, Data.Csv.Builder}) +@item +Incremental decoding and encoding API (see @url{https://hackage.haskell.org/ +package/cassava-0.5.2.0/docs/Data-Csv-Incremental.html, Data.Csv.Incremental}) +@item +Streaming API for constant-space decoding (see @url{https://hackage.haskell.org/ +package/cassava-0.5.2.0/docs/Data-Csv-Streaming.html, Data.Csv.Streaming}) +@end itemize + +Moreover, this library is designed to be easy to use; for instance, here's a +very simple example of encoding CSV data: + +@verbatim +>>> Data.Csv.encode [(\"John\",27),(\"Jane\",28)] +\"John,27\r\nJane,28\r\n\" +@end verbatim +") + (license license:bsd-3))) + +(define-public ghc-cassava-megaparsec + (package + (name "ghc-cassava-megaparsec") + (version "2.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/cassava-megaparsec/" + "cassava-megaparsec-" + version + ".tar.gz")) + (sha256 + (base32 + "0q4skw98nzy6icmgpwqvgw0c5pqcgi25rf7nmwh2pksvv94pi3p3")))) + (build-system haskell-build-system) + (inputs + `(("ghc-cassava" ,ghc-cassava) + ("ghc-megaparsec" ,ghc-megaparsec) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-hspec-megaparsec" ,ghc-hspec-megaparsec))) + (home-page "https://github.com/stackbuilders/cassava-megaparsec") + (synopsis "Megaparsec parser for CSV files that plays nicely with Cassava") + (description + "Alternative parser for the Cassava package written with Megaparsec that +provides for better error messages at the expense of some speed.") + (license license:expat))) + (define-public ghc-cborg (package (name "ghc-cborg") @@ -2608,6 +2748,36 @@ a vocabulary for working with them.") @code{ghc-contravariant} package.") (license license:expat))) +(define-public ghc-control-monad-free + (package + (name "ghc-control-monad-free") + (version "0.6.2") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/" + "package/control-monad-free/control-monad-free-" + version + ".tar.gz")) + (sha256 + (base32 + "1habgf7byffqf1rqjkzpihvdhclaafgqsqpfpwp3fgpj5ayk1j33")))) + (build-system haskell-build-system) + (home-page "https://github.com/pepeiborra/control-monad-free") + (synopsis "Free monads and monad transformers") + (description + "This package provides datatypes to construct Free monads, Free monad +transformers, and useful instances. In addition it provides the constructs to +avoid quadratic complexity of left associative bind, as explained in: + +@itemize @bullet +@item +Janis Voigtlander, @cite{Asymptotic Improvement of Computations over +Free Monads, MPC'08} +@end itemize") + (license license:public-domain))) + (define-public ghc-convertible (package (name "ghc-convertible") @@ -2634,6 +2804,30 @@ pure @code{Either} value. This means that you need not remember which specific function performs the conversion you desire.") (license license:bsd-3))) +(define-public ghc-csv + (package + (name "ghc-csv") + (version "0.1.2") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/csv/csv-" + version + ".tar.gz")) + (sha256 + (base32 + "00767ai09wm7f0yzmpqck3cpgxncpr9djnmmz5l17ajz69139x4c")))) + (build-system haskell-build-system) + (home-page "http://hackage.haskell.org/package/csv") + (synopsis "CSV loader and dumper") + (description + "This library parses and dumps documents that are formatted according to +RFC 4180, @cite{The common Format and MIME Type for Comma-Separated +Values (CSV) Files}. This format is used, among many other things, as a +lingua franca for spreadsheets, and for certain web services.") + (license license:expat))) + (define-public ghc-data-accessor (package (name "ghc-data-accessor") @@ -2932,6 +3126,35 @@ to add D-Bus support to Haskell applications, without the awkward interfaces common to foreign bindings.") (license license:asl2.0))) +(define-public ghc-decimal + (package + (name "ghc-decimal") + (version "0.5.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/Decimal/Decimal-" + version + ".tar.gz")) + (sha256 + (base32 + "0k7kh05mr2f54w1lpgq1nln0h8k6s6h99dyp5jzsb9cfbb3aap2p")))) + (build-system haskell-build-system) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2) + ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) + (home-page "https://github.com/PaulJohnson/Haskell-Decimal") + (synopsis "Decimal numbers with variable precision") + (description + "A decimal number has an integer mantissa and a negative exponent. +The exponent can be interpreted as the number of decimal places in the +value.") + (license license:bsd-3))) + (define-public ghc-deepseq-generics (package (name "ghc-deepseq-generics") @@ -3342,16 +3565,18 @@ Writer monad), where list append quickly becomes too expensive.") (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: missing test framework (inputs - `(("ghc-syb" ,ghc-syb) - ("ghc-paths" ,ghc-paths) - ("ghc-base-compat" ,ghc-base-compat) + `(("ghc-base-compat" ,ghc-base-compat) ("ghc-code-page" ,ghc-code-page) - ("ghc-hunit" ,ghc-hunit) - ("ghc-hspec" ,ghc-hspec) + ("ghc-paths" ,ghc-paths) + ("ghc-syb" ,ghc-syb))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) ("ghc-quickcheck" ,ghc-quickcheck) - ("ghc-stringbuilder" ,ghc-stringbuilder) + ("ghc-hspec" ,ghc-hspec) + ("ghc-mockery" ,ghc-mockery) + ("ghc-setenv" ,ghc-setenv) ("ghc-silently" ,ghc-silently) - ("ghc-setenv" ,ghc-setenv))) + ("ghc-stringbuilder" ,ghc-stringbuilder))) (home-page "https://github.com/sol/doctest#readme") (synopsis "Test interactive Haskell examples") @@ -4214,7 +4439,7 @@ file contents, and more.") (define-public ghc-filepath-bytestring (package (name "ghc-filepath-bytestring") - (version "1.4.2.1.1") + (version "1.4.2.1.6") (source (origin (method url-fetch) @@ -4223,7 +4448,7 @@ file contents, and more.") "filepath-bytestring-" version ".tar.gz")) (sha256 (base32 - "06shdskjj391hb9295slm9gg2rbn5fdq5v6fg0mgn3yl5dv8q5dx")))) + "11xrrzdkm5i96dazbz0gi1qp8nnj2lwbnxzwy7f4cnahskz4f4g7")))) (build-system haskell-build-system) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck))) @@ -5638,6 +5863,62 @@ feature, allowing applications to subscribe to notifications when a file is accessed or modified.") (license license:bsd-3))) +(define-public ghc-hledger-lib + (package + (name "ghc-hledger-lib") + (version "1.14.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/hledger-lib/hledger-lib-" + version + ".tar.gz")) + (sha256 + (base32 + "1w6qp01cak6spnpldm01czlm6i5a2alw47w76875l2nagrc4rfp2")))) + (build-system haskell-build-system) + (inputs + `(("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-base-compat-batteries" ,ghc-base-compat-batteries) + ("ghc-blaze-markup" ,ghc-blaze-markup) + ("ghc-call-stack" ,ghc-call-stack) + ("ghc-cassava" ,ghc-cassava) + ("ghc-cassava-megaparsec" ,ghc-cassava-megaparsec) + ("ghc-cmdargs" ,ghc-cmdargs) + ("ghc-data-default" ,ghc-data-default) + ("ghc-decimal" ,ghc-decimal) + ("ghc-easytest" ,ghc-easytest) + ("ghc-extra" ,ghc-extra) + ("ghc-file-embed" ,ghc-file-embed) + ("ghc-glob" ,ghc-glob) + ("ghc-hashtables" ,ghc-hashtables) + ("ghc-megaparsec" ,ghc-megaparsec) + ("ghc-mtl-compat" ,ghc-mtl-compat) + ("ghc-old-time" ,ghc-old-time) + ("ghc-parser-combinators" ,ghc-parser-combinators) + ("ghc-pretty-show" ,ghc-pretty-show) + ("ghc-regex-tdfa" ,ghc-regex-tdfa) + ("ghc-safe" ,ghc-safe) + ("ghc-split" ,ghc-split) + ("ghc-tabular" ,ghc-tabular) + ("ghc-uglymemo" ,ghc-uglymemo) + ("ghc-utf8-string" ,ghc-utf8-string))) + (native-inputs `(("ghc-doctest" ,ghc-doctest))) + (home-page "https://hledger.org") + (synopsis "Reusable library providing the core functionality of hledger") + (description + "A reusable library containing hledger's core functionality. +This is used by most hledger* packages so that they support the same common +file formats, command line options, reports etc. + +hledger is a robust, cross-platform set of tools for tracking money, time, or +any other commodity, using double-entry accounting and a simple, editable file +format, with command-line, terminal and web interfaces. It is a Haskell +rewrite of Ledger, and one of the leading implementations of Plain Text +Accounting.") + (license license:gpl3))) + (define-public ghc-hmatrix (package (name "ghc-hmatrix") @@ -5841,6 +6122,34 @@ are described in a file named @code{package.yaml}. Both @code{cabal2nix} and @code{package.yaml}.") (license license:expat))) +(define-public ghc-hspec-megaparsec + (package + (name "ghc-hspec-megaparsec") + (version "2.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/" + "package/hspec-megaparsec/hspec-megaparsec-" + version + ".tar.gz")) + (sha256 + (base32 + "0w8nn2rh01lkiwsiyqh3gviklhfmy0245rakj94dmliyljw8skfg")))) + (build-system haskell-build-system) + (inputs + `(("ghc-hspec-expectations" ,ghc-hspec-expectations) + ("ghc-megaparsec" ,ghc-megaparsec))) + (native-inputs + `(("ghc-hspec" ,ghc-hspec))) + (home-page "https://github.com/mrkkrp/hspec-megaparsec") + (synopsis "Utility functions for testing Megaparsec parsers with Hspec") + (description + "Provides a small set of helper functions for testing Megaparsec parsers +with Hspec.") + (license license:bsd-3))) + (define-public ghc-hs-bibutils (package (name "ghc-hs-bibutils") @@ -7169,6 +7478,48 @@ Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf, online}.") (license license:bsd-3))) +(define-public ghc-lucid + (package + (name "ghc-lucid") + (version "2.9.12") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/lucid/lucid-" + version + ".tar.gz")) + (sha256 + (base32 + "156wniydd1hlb7rygbm95zln8ky8lai8rn2apkkv0rax9cdw6jrh")))) + (build-system haskell-build-system) + (inputs + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-hashable" ,ghc-hashable) + ("ghc-mmorph" ,ghc-mmorph) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (native-inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-hspec" ,ghc-hspec) + ("ghc-bifunctors" ,ghc-bifunctors))) + (arguments + `(#:cabal-revision + ("1" + "1f0whk5ncanxfjjanrf6rqyncig2xgc5mh2j0sqy3nrlyjr9aqq9"))) + (home-page "https://github.com/chrisdone/lucid") + (synopsis "Haskell DSL for rendering HTML") + (description "Clear to write, read and edit Haskell DSL for HTML. + +@itemize @bullet +@item +Names are consistent, and do not conflict with base or are keywords +(all have suffix @code{-}). +@item +Same combinator can be used for attributes and elements +(e.g. @code{style_}). +@end itemize") + (license license:bsd-3))) + (define-public ghc-lzma (package (name "ghc-lzma") @@ -7975,6 +8326,28 @@ semi-direct products, \"deletable\" monoids, \"split\" monoids, and \"cut\" monoids.") (license license:bsd-3))) +(define-public ghc-mountpoints + (package + (name "ghc-mountpoints") + (version "1.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/mountpoints/mountpoints-" + version + ".tar.gz")) + (sha256 + (base32 + "1hnm31pqcffphyc463wf0vbik9fzm5lb2r4wjdc1y4dqzmjdzz37")))) + (build-system haskell-build-system) + (home-page + "http://hackage.haskell.org/package/mountpoints") + (synopsis "Haskell library for listing mount points") + (description "This library provides Haskell bindings for checking +currently mounted filesystems.") + (license license:lgpl2.1+))) + (define-public ghc-mtl-compat (package (name "ghc-mtl-compat") @@ -8234,6 +8607,36 @@ getting a list of all the network interfaces and their respective IPv4, IPv6 and MAC addresses.") (license license:bsd-3))) +(define-public ghc-network-multicast + (package + (name "ghc-network-multicast") + (version "0.3.2") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/network-multicast/network-multicast-" + version + ".tar.gz")) + (sha256 + (base32 + "0whvi0pbwjy6dbwfdf9rv1j3yr3lcmfp3q7a8pwq63g537l4l2l3")))) + (build-system haskell-build-system) + (inputs + `(("ghc-network" ,ghc-network) + ("ghc-network-bsd" ,ghc-network-bsd))) + (home-page + "http://hackage.haskell.org/package/network-multicast") + (synopsis "Simple multicast library for Haskell") + (description + "This package provides the Network.Multicast Haskell module for +sending UDP datagrams over multicast (class D) addresses.") + ;; Note that this is technically under CC0 1.0 and Expat, though it's not + ;; totally clear what the breakdown is. Since CC0 1.0 is effectively + ;; "public domain with a minimal fallback license", figuring marking it + ;; as effectively Expat is probably correct. + (license license:expat))) + (define-public ghc-network-uri (package (name "ghc-network-uri") @@ -8441,6 +8844,38 @@ old @code{time} library. For new projects, the newer @uref{https://hackage.haskell.org/package/time, time library} is recommended.") (license license:bsd-3))) +(define-public ghc-only + (package + (name "ghc-only") + (version "0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/Only/Only-" + version + ".tar.gz")) + (sha256 + (base32 + "0rdj3a629fk2vp121jq8mf2smkblrz5w3cxhlsyx6my2x29s2ymb")))) + (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("1" + "1ahk7p34kmh041mz7lyc10nhcxgv2i4z8nvzxvqm2x34gslmsbzr"))) + (home-page "https://hackage.haskell.org/package/Only") + (synopsis "The 1-tuple type or single-value collection") + (description + "This package provides a canonical anonymous 1-tuple type missing from +Haskell for attaching typeclass instances. + +There is also the @url{https://hackage.haskell.org/package/OneTuple, OneTuple +package} which by using a boxed @code{data}-type provides a 1-tuple type which +has laziness properties which are more faithful to the ones of Haskell's +native tuples; whereas the primary purpose of @code{Only} is to provide the +traditionally so named type-wrapper for attaching typeclass instances.") + (license license:bsd-3))) + (define-public ghc-opengl (package (name "ghc-opengl") @@ -8722,6 +9157,45 @@ require aeson (description "Safe conversions between textual types") (license license:isc))) +(define-public ghc-text-short + (package + (name "ghc-text-short") + (version "0.1.3") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/text-short/text-short-" + version + ".tar.gz")) + (sha256 + (base32 + "0xyrxlb602z8bc9sr2y1fag0x56a20yj5qrkvy7iwc6hnznrynxz")))) + (build-system haskell-build-system) + (inputs `(("ghc-hashable" ,ghc-hashable))) + (native-inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-quickcheck-instances" + ,ghc-quickcheck-instances))) + (arguments + `(#:cabal-revision + ("2" + "17cb7p0qywf2dsrq3g8qb3ssknd9wl5k0nc2pxz9gc3l8rxpkw51"))) + (home-page "https://hackage.haskell.org/package/text-short") + (synopsis "Memory-efficient representation of Unicode text strings") + (description "This package provides the @code{ShortText} type which +is suitable for keeping many short strings in memory. This is similar +to how @code{ShortByteString} relates to @code{ByteString}. + +The main difference between @code{Text} and @code{ShortText} is that +@code{ShortText} uses UTF-8 instead of UTF-16 internally and also doesn't +support zero-copy slicing (thereby saving 2 words). Consequently, the memory +footprint of a (boxed) @{ShortText} value is 4 words (2 words when unboxed) +plus the length of the UTF-8 encoded payload.") + (license license:bsd-3))) + (define-public ghc-doclayout (package (name "ghc-doclayout") @@ -12570,6 +13044,49 @@ Unlike the filepath package, this package does not simply reuse String, increasing type safety.") (license license:expat))) +(define-public ghc-tabular + (package + (name "ghc-tabular") + (version "0.2.2.7") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/tabular/tabular-" + version + ".tar.gz")) + (sha256 + (base32 + "1ysgq7rrks7f98nnvxil8xz1q27hxdgz4szbjhqwzbwd209dmy0k")))) + (build-system haskell-build-system) + (inputs + `(("ghc-csv" ,ghc-csv) + ("ghc-html" ,ghc-html))) + (home-page "https://github.com/bgamari/tabular") + (synopsis "Two-dimensional data tables with rendering functions") + (description + "Tabular provides a Haskell representation of two-dimensional data +tables, the kind that you might find in a spreadsheet or or a research report. +It also comes with some default rendering functions for turning those tables +into ASCII art, simple text with an arbitrary delimiter, CSV, HTML or LaTeX. + +Below is an example of the kind of output this library produces. The tabular +package can group rows and columns, each group having one of three +separators (no line, single line, double line) between its members. + +@example + + || memtest 1 | memtest 2 || time test | time test 2 +====++===========+===========++=============+============ +A 1 || hog | terrible || slow | slower +A 2 || pig | not bad || fast | slowest +----++-----------+-----------++-------------+------------ +B 1 || good | awful || intolerable | bearable +B 2 || better | no chance || crawling | amazing +B 3 || meh | well... || worst ever | ok + +@end example") + (license license:bsd-3))) (define-public ghc-tagged (package @@ -13299,6 +13816,28 @@ from a shell. The @code{tldr} pages are a community effort to simplify the man pages with practical examples.") (license license:bsd-3))) +(define-public ghc-torrent + (package + (name "ghc-torrent") + (version "10000.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/torrent/torrent-" + version ".tar.gz")) + (sha256 + (base32 "0m7s0q7f8c7glxzqhf2j86ch5xhk6jnzwwsa4mkywag22119c290")))) + (build-system haskell-build-system) + (inputs + `(("ghc-bencode" ,ghc-bencode) + ("ghc-syb" ,ghc-syb))) + (home-page "https://hackage.haskell.org/package/torrent") + (synopsis "BitTorrent file parser and generator") + (description "This library provides support for parsing and generating +BitTorrent files.") + (license license:bsd-3))) + (define-public ghc-transformers (package (name "ghc-transformers") @@ -13592,6 +14131,28 @@ processes. It wraps around the @code{process} library, and intends to improve upon it.") (license license:expat))) +(define-public ghc-uglymemo + (package + (name "ghc-uglymemo") + (version "0.1.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/uglymemo/uglymemo-" + version + ".tar.gz")) + (sha256 + (base32 + "0ixqg5d0ly1r18jbgaa89i6kjzgi6c5hanw1b1y8c5fbq14yz2gy")))) + (build-system haskell-build-system) + (home-page "https://hackage.haskell.org/package/uglymemo") + (synopsis "Simple memoization function for Haskell") + (description + "This package provides a simple (but internally ugly) memoization +function.") + (license license:public-domain))) + (define-public ghc-unagi-chan (package (name "ghc-unagi-chan") @@ -14468,6 +15029,48 @@ widths to the Char type.") Haskell value or function.") (license license:bsd-3))) +(define-public ghc-wizards + (package + (name "ghc-wizards") + (version "1.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/wizards/wizards-" + version + ".tar.gz")) + (sha256 + (base32 + "1clvbd1ckhvy29qrbmpkn7bya7300fq6znnps23nn3nxyrxhsr85")))) + (build-system haskell-build-system) + (inputs + `(("ghc-control-monad-free" ,ghc-control-monad-free))) + (arguments + `(#:cabal-revision + ("1" + "095qd17zrdhqmcvmslbyzfa5sh9glvvsnsvnlz31gzsmi8nnsgim"))) + (home-page "http://hackage.haskell.org/package/wizards") + (synopsis "High level, generic library for interrogative user interfaces") + (description + "@code{wizards} is a package designed for the quick and painless +development of @emph{interrogative} programs, which revolve around a dialogue +with the user, who is asked a series of questions in a sequence much like an +installation wizard. + +Everything from interactive system scripts, to installation wizards, to +full-blown shells can be implemented with the support of @code{wizards}. + +It is developed transparently on top of a free monad, which separates out the +semantics of the program from any particular interface. A variety of backends +exist, including console-based @code{System.Console.Wizard.Haskeline} and +@code{System.Console.Wizard.BasicIO}, and the pure +@code{System.Console.Wizard.Pure}. It is also possible to write your own +backends, or extend existing back-ends with new features. While both built-in +IO backends operate on a console, there is no reason why @code{wizards} cannot +also be used for making GUI wizard interfaces.") + (license license:bsd-3))) + (define-public ghc-wl-pprint (package (name "ghc-wl-pprint") |