;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
;;; Copyright © 2015, 2019 Eric Bavier <bavier@member.fsf.org>
-;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2016, 2018, 2019, 2021 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
;;; Copyright © 2016, 2019 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2015, 2016, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2017 Peter Mikkelsen <petermikkelsen10@gmail.com>
;;; Copyright © 2017, 2018 Alex Vong <alexvong1995@gmail.com>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
-;;; Copyright © 2017, 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2017–2019, 2021 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Tonton <tonton@riseup.net>
;;; Copyright © 2018, 2019 Timothy Sample <samplet@ngyro.com>
;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
;;; Copyright © 2019 Alex Griffin <a@ajgrf.com>
;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
;;; Copyright © 2020 JoJo <jo@jo.zone>
-;;; Copyright © 2020 Nicolas Goaziou <mail@nicolasgoaziou.fr>
+;;; Copyright © 2020, 2021 Nicolas Goaziou <mail@nicolasgoaziou.fr>
;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
;;; Copyright © 2020 Carlo Holl <carloholl@gmail.com>
+;;; Copyright © 2020 Christine Lemmer-Webber <cwebber@dustycloud.org>
+;;; Copyright © 2021 Alice BRENON <alice.brenon@ens-lyon.fr>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages pcre)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages sdl)
- #:use-module (gnu packages web)
+ #:use-module (gnu packages serialization)
#:use-module (gnu packages xml)
#:use-module (gnu packages xorg)
#:use-module (guix build-system haskell)
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")
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")
interface}.")
(license license:expat)))
+(define-public ghc-config-ini
+ (package
+ (name "ghc-config-ini")
+ (version "0.2.4.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "config-ini/config-ini-" version ".tar.gz"))
+ (sha256
+ (base32 "0dfm4xb1sd713rcqzplzdgw68fyhj24i6lj8j3q8kldpmkl98lbf"))))
+ (build-system haskell-build-system)
+ (arguments
+ ;; XXX The tests fail to compile: “The constructor ‘I1.Ini’ should have 2
+ ;; arguments, but has been given 1”.
+ `(#:tests? #f
+ #:cabal-revision
+ ("2" "0iwraaa0y1b3xdsg760j1wpylkqshky0k2djcg0k4s97lrwqpbcz")))
+ (native-inputs
+ `(("ghc-doctest" ,ghc-doctest)
+ ("ghc-hedgehog" ,ghc-hedgehog)
+ ("ghc-ini" ,ghc-ini)
+ ("ghc-microlens" ,ghc-microlens)))
+ (inputs
+ `(("ghc-megaparsec" ,ghc-megaparsec)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (home-page "https://github.com/aisamanra/config-ini")
+ (synopsis "Monadic Haskell DSL for parsing simple INI configuration files")
+ (description
+ "The @code{config-ini} Haskell library exports some simple monadic
+functions to ease the parsing of @file{.ini}-style configuration files, and
+to write and update them in an efficient @i{diff-minimal} way. This means that
+if you parse a file, update a single field, and reserialize, that file should
+differ only in the field we changed and @emph{that's it}: field order, comments,
+and incidental whitespace will remain unchanged. The library aims to produce
+human-readable error messages when things go wrong.")
+ (license license:bsd-3)))
+
(define-public ghc-configurator
(package
(name "ghc-configurator")
Accessor to access state in transformers State monad.")
(license license:bsd-3)))
+(define-public ghc-data-clist
+ (package
+ (name "ghc-data-clist")
+ (version "0.1.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/data-clist/"
+ "data-clist-" version ".tar.gz"))
+ (sha256
+ (base32 "1mwfhnmvi3vicyjzl33m6pcipi2v887zazyqxygq258ndd010s9m"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "13hg7a3d4ky8b765dl03ryxg28lq8iaqj5ky3j51r0i1i4f2a9hy")))
+ (home-page "https://github.com/sw17ch/data-clist")
+ (synopsis "Simple, functional, bidirectional circular list type")
+ (description
+ "This Haskell library provides a simple purely functional circular list,
+or ring, data type: a circular data structure such that if you continue rotating
+the ring in either direction, you'll eventually return to the element you first
+observed.")
+ (license license:bsd-3)))
+
(define-public ghc-data-default
(package
(name "ghc-data-default")
(define-public ghc-doctest
(package
(name "ghc-doctest")
- (version "0.16.3")
+ (version "0.16.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1y1l7aa80qkib1z8lsizgg7fpfdmdwhxvi5m255a42jdkjgn5sfg"))))
+ "0lk4cjfzi5bx2snfzw1zi06li0gvgz3ckfh2kwa98l7nxfdl39ag"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: missing test framework
(inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
- ("ghc-hspec-core" ,ghc-hspec-core)
("ghc-mockery" ,ghc-mockery)
("ghc-setenv" ,ghc-setenv)
("ghc-silently" ,ghc-silently)
(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)
"filepath-bytestring-" version ".tar.gz"))
(sha256
(base32
- "06shdskjj391hb9295slm9gg2rbn5fdq5v6fg0mgn3yl5dv8q5dx"))))
+ "11xrrzdkm5i96dazbz0gi1qp8nnj2lwbnxzwy7f4cnahskz4f4g7"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
simple general-purpose data structure\".")
(license license:bsd-3)))
+(define-public ghc-finite-typelits
+ (package
+ (name "ghc-finite-typelits")
+ (version "0.1.4.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "finite-typelits/"
+ "finite-typelits-" version ".tar.gz"))
+ (sha256
+ (base32 "0iyp9fyd2ki9qcmk9infz9p6rjhsx9jrs3f5yz0yqs8vj5na81yj"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/mniip/finite-typelits")
+ (synopsis "Finitely many values, indexed by type-level naturals")
+ (description
+ "This package provides a Haskell type inhabited by finitely many values
+and indexed by type-level naturals.")
+ (license license:bsd-3)))
+
(define-public ghc-fixed
(package
(name "ghc-fixed")
(let* ((out (assoc-ref outputs "out"))
(elisp-file "elisp/hindent.el")
(dest (string-append out "/share/emacs/site-lisp"))
- (emacs (string-append (assoc-ref inputs "emacs")
- "/bin/emacs")))
+ (emacs (search-input-file inputs "/bin/emacs")))
(make-file-writable elisp-file)
(emacs-substitute-variables elisp-file
("hindent-process-path"
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")
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
- (home-page "http://patch-tag.com/r/salazar/indents")
+ (home-page "https://github.com/jaspervdj/indents")
(synopsis "Indentation sensitive parser-combinators for parsec")
(description
"This library provides functions for use in parsing indentation sensitive
license from a given license file.")
(license license:expat)))
+(define-public ghc-ini
+ (package
+ (name "ghc-ini")
+ (version "0.4.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "ini/ini-" version ".tar.gz"))
+ (sha256
+ (base32 "0mvwii8jbh2ll54qb9dij5m66c6324s2y4vrwz1qr4wz40m3qa8l"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (home-page "https://github.com/chrisdone/ini")
+ (synopsis
+ "Haskell library to easily handle configuration files in the INI format")
+ (description
+ "The @code{ghc-ini} Haskell library lets programmers quickly and easily
+read and write configuration files in the simple INI format.")
+ (license license:bsd-3)))
+
(define-public ghc-inline-c
(package
(name "ghc-inline-c")
(build-system haskell-build-system)
(arguments
`(#:configure-flags `("--flags=system-libyaml")
- #:extra-directories ("libyaml")))
+ #:extra-directories ("libyaml+static")))
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-resourcet" ,ghc-resourcet)
- ("libyaml" ,libyaml)))
+ ("libyaml+static" ,libyaml+static)))
(home-page "https://github.com/snoyberg/yaml#readme")
(synopsis "Low-level, streaming YAML interface.")
(description "This package provides a Haskell wrapper over the
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")
\"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")
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")
@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")
(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-text-zipper
+ (package
+ (name "ghc-text-zipper")
+ (version "0.10.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/text-zipper/"
+ "text-zipper-" version ".tar.gz"))
+ (sha256
+ (base32 "0jxicjp0ak1fyl1n3yspxq6hv9l90zzy75glsv8bc2svsn9ypyls"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("hspec-discover" ,hspec-discover)))
+ (inputs
+ `(("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/jtdaugherty/text-zipper/")
+ (synopsis "Text editor zipper library")
+ (description
+ "This Haskell library provides a two-dimensional zipper data structure for
+editing text. The structure represents the body of text and an editing cursor
+which can be moved through it, along with a set of editing transformations.
+
+Text zippers are generalized over the set of data types that might be used to
+store lists of characters (e.g., @code{String}, @code{T.Text}, etc.).
+Implementations using both of these examples are provided.")
+ (license license:bsd-3)))
+
(define-public ghc-doclayout
(package
(name "ghc-doclayout")
("pandoc" ,pandoc "lib")
,@all-static-inputs
,@direct-inputs)))
+ (outputs '("out" "lib" "static" "doc"))
(synopsis "Pandoc filter for bibliographic references")))
(define-public ghc-pandoc-types
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-hunit" ,ghc-hunit)))
- (home-page "https://johnmacfarlane.net/pandoc")
+ (home-page "https://pandoc.org")
(synopsis "Types for representing a structured document")
(description
"This module defines the @code{Pandoc} data structure, which is used by
replace the standard one provided by GHC.")
(license license:expat)))
+(define-public ghc-protolude-0.3
+ (package
+ (inherit ghc-protolude)
+ (name "ghc-protolude")
+ (version "0.3.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/protolude/protolude-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1b6wprbwfdjyvds2bm6na0fbqgzdkj5ikkk33whbkyh3krd3i0s0"))))))
+
(define-public ghc-psqueue
(package
(name "ghc-psqueue")
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
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")
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")
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")
"A clone of wl-pprint for use with the text library.")
(license license:bsd-3)))
+(define-public ghc-word-wrap
+ (package
+ (name "ghc-word-wrap")
+ (version "0.4.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "word-wrap/word-wrap-" version ".tar.gz"))
+ (sha256
+ (base32 "15rcqhg9vb7qisk9ryjnyhhfgigxksnkrczycaw2rin08wczjwpb"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1k4w4g053vhmpp08542hrqaw81p3p35i567xgdarqmpghfrk68pp")))
+ (home-page "https://github.com/jtdaugherty/word-wrap/")
+ (synopsis "Haskell library for word-wrapping text")
+ (description
+ "The @code{word-wrap} Haskell library wraps long lines of text.")
+ (license license:bsd-3)))
+
(define-public ghc-word8
(package
(name "ghc-word8")
(description "Word8 library to be used with @code{Data.ByteString}.")
(license license:bsd-3)))
+(define-public ghc-wordexp
+ (package
+ (name "ghc-wordexp")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/wordexp/wordexp-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1mbcrq89jz0dcibw66w0jdy4f4bfpx4zwjfs98rm3jjgdikwdzb4"))))
+ (build-system haskell-build-system)
+ (native-inputs `(("ghc-c2hs" ,ghc-c2hs)))
+ (inputs
+ `(("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://hackage.haskell.org/package/wordexp")
+ (synopsis "Library wrapping @code{wordexp} for Haskell")
+ (description "@code{wordexp(3)} wrapper library for Haskell to perform
+word expansion like a posix-shell.")
+ (license license:bsd-3)))
+
(define-public ghc-x11
(package
(name "ghc-x11")
HCoop / jackhill / guix / guix.git / blobdiff