From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mp2 ([2001:41d0:2:bcc0::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by ms0.migadu.com with LMTPS id 0NZnMgZNV2FufAAAgWs5BA (envelope-from ) for ; Fri, 01 Oct 2021 20:01:42 +0200 Received: from aspmx1.migadu.com ([2001:41d0:2:bcc0::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by mp2 with LMTPS id CKMXLgZNV2HldwAAB5/wlQ (envelope-from ) for ; Fri, 01 Oct 2021 18:01:42 +0000 Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by aspmx1.migadu.com (Postfix) with ESMTPS id 216C912785 for ; Fri, 1 Oct 2021 20:01:41 +0200 (CEST) Received: from localhost ([::1]:58964 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1mWMqq-0004iO-2f for larch@yhetil.org; Fri, 01 Oct 2021 14:01:40 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:58142) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1mWMIM-0002S8-Ra for guix-patches@gnu.org; Fri, 01 Oct 2021 13:26:03 -0400 Received: from debbugs.gnu.org ([209.51.188.43]:45743) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1mWMIM-0007mt-Ji for guix-patches@gnu.org; Fri, 01 Oct 2021 13:26:02 -0400 Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1mWMIM-0004JI-CI for guix-patches@gnu.org; Fri, 01 Oct 2021 13:26:02 -0400 X-Loop: help-debbugs@gnu.org Subject: [bug#50843] [PATCHES] Stackage update to 18.10. References: Resent-From: Xinglu Chen Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Fri, 01 Oct 2021 17:26:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 50843 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: Lars-Dominik Braun , 50843@debbugs.gnu.org Cc: john.kehayias@protonmail.com, rekado@elephly.net, philip@munksgaard.me Received: via spool by 50843-submit@debbugs.gnu.org id=B50843.163310910316493 (code B ref 50843); Fri, 01 Oct 2021 17:26:02 +0000 Received: (at 50843) by debbugs.gnu.org; 1 Oct 2021 17:25:03 +0000 Received: from localhost ([127.0.0.1]:57289 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1mWMHF-0004HQ-EI for submit@debbugs.gnu.org; Fri, 01 Oct 2021 13:25:03 -0400 Received: from h87-96-130-155.cust.a3fiber.se ([87.96.130.155]:54334 helo=mail.yoctocell.xyz) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1mWMH9-0004H9-80 for 50843@debbugs.gnu.org; Fri, 01 Oct 2021 13:24:51 -0400 From: Xinglu Chen DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=yoctocell.xyz; s=mail; t=1633109080; bh=fkZPfR+2OrJrVVzos9twFtCuLl3XxLcR4M0eoWnhDfk=; h=From:To:Cc:Subject:In-Reply-To:Date; b=X5+Yw349YOhCAhEhubdae22T8/MDqyYiLT3Os9vOOwjzKV6fhWiQYRARr7yfU4F2t Z4U0NnR3PkxYdzw/6tWXNq11L5zelIprI+tHzBBrUR3oqjhJF3d5audf+Du5TnZXFj YJlHCLMOgQ8istPEP65FtYqqUU9PEJOjiylgSnB8= In-Reply-To: Date: Fri, 01 Oct 2021 19:24:34 +0200 Message-ID: <877dewlktp.fsf@yoctocell.xyz> MIME-Version: 1.0 Content-Type: multipart/signed; boundary="==-=-="; micalg=pgp-sha256; protocol="application/pgp-signature" X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list X-BeenThere: guix-patches@gnu.org List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guix-patches-bounces+larch=yhetil.org@gnu.org Sender: "Guix-patches" X-Migadu-Flow: FLOW_IN ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=yhetil.org; s=key1; t=1633111302; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:resent-cc:resent-from:resent-sender: resent-message-id:in-reply-to:in-reply-to:references:references: list-id:list-help:list-unsubscribe:list-subscribe:list-post: dkim-signature; bh=AM7ejexX1ebvieFtbLf0TpRZzhASTT7NTd6iJY8Pe24=; b=nhbtDXADqVz9yYUa1VEtxMVh200UW85+GSJ2NBfWQ6UycRcyda95rlMWtObkamKyJmnBsW BsM/DnLBNDhB6JV3yZCgtH0ngqPlr6/6A3aAKZoX0dQzguQZf1d6IjUMP4xOpyRce8S4cz ZS01NWywo4Jme48lCzELeZTGXj/RuStU16p3sa+zOg7QJe7TR/PaXzdUYFS4vdRZYLXXot TkCxC+j+ZDRS7Hl45vq5H4UdHkh/jqGwTlMrTALIWuo91Kp32G/BFfWMNuaFvmSSViwuad nTi3x435iMfR3W8Cvggp8b3nXtbDopFylEQzV0ciengtyaVKp+6rLMiRABVNgQ== ARC-Seal: i=1; s=key1; d=yhetil.org; t=1633111302; a=rsa-sha256; cv=none; b=cE7edvazb2DJSltiW54zQXyNJ6j6D3qElfVyIwNxxeFFHs+/ImPnDfCojTwWjXb99McbUd 0oBrDJE2rZIJzlCXsYkpdnNbcjBNripewX9Fj5aNljhxTqbjJLcOyUXWOnjtzXlyb+cDEd NVihcfhO85QS1CwSnzmoUpGVRgnjOjuyNrhaeEjJ9qlTMcwBgkdOPtDYOfXK9l41NQif56 BPkrf5EhzpoX9ejt2JW0FZDlxXTSbsbhdiVaNDhaZf8EOOMLqdHitqTM6T0WYr5JTnv8+x 1XJXeXDNDHcQmLDH1Yg37NLQwZu7soBuKypdu0AGnq1d4LvyWvUDPw945oIeXw== ARC-Authentication-Results: i=1; aspmx1.migadu.com; dkim=fail ("headers rsa verify failed") header.d=yoctocell.xyz header.s=mail header.b=X5+Yw349; dmarc=fail reason="SPF not aligned (relaxed)" header.from=yoctocell.xyz (policy=none); spf=pass (aspmx1.migadu.com: domain of guix-patches-bounces@gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=guix-patches-bounces@gnu.org X-Migadu-Spam-Score: -3.40 Authentication-Results: aspmx1.migadu.com; dkim=fail ("headers rsa verify failed") header.d=yoctocell.xyz header.s=mail header.b=X5+Yw349; dmarc=fail reason="SPF not aligned (relaxed)" header.from=yoctocell.xyz (policy=none); spf=pass (aspmx1.migadu.com: domain of guix-patches-bounces@gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=guix-patches-bounces@gnu.org X-Migadu-Queue-Id: 216C912785 X-Spam-Score: -3.40 X-Migadu-Scanner: scn0.migadu.com X-TUID: cOsYy99yZydz --==-=-= Content-Type: multipart/mixed; boundary="=-=-=" --=-=-= Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable On Mon, Sep 27 2021, Lars-Dominik Braun wrote: > Hi everyone, > > I just pushed to the wip-haskell branch (it=E2=80=99s based on master), > which now contains various changes to haskell-build-system as well > as an update to Stackage 18.10 or the latest Hackage package version > where applicable. CI is currently building the changes[1], but from > local building I know all but three packages using haskell-build-system > build. These are ngless, cabal-install and idris. I need your help to > fix them! There are also packages that cannot be updated via `guix > refresh` currently. They have been left mostly untouched. > > I was also thinking about unconditionally adding > --allow-newer/--allow-older to haskell-build-system, so patching > .cabal-files is not necessary any more. Thoughs? > > Let=E2=80=99s use this issue to track/review the changes and provide feed= back > on them. Below is a list of questions/things-that-should-be-fixed that I found. * What exacty does the TODO comment for =E2=80=98ghc-hsyaml=E2=80=99 mean? = The =E2=80=98native-inputs=E2=80=99 comment should also be removed if tests a= ren=E2=80=99t enabled. This applies to =E2=80=98ghc-stmonadtrans=E2=80=99 as well * The =E2=80=98inputs=E2=80=99 comments for =E2=80=98ghc-silently=E2=80=99 = should probably be removed. I noticed that a lot of new packages have been auto-generated and added as-is, without checking licenses and fixing descriptions. I have attached a patch that fixes these (I hope I didn=E2=80=99t miss any package= s). --=-=-= Content-Type: text/x-patch; charset=utf-8 Content-Disposition: attachment; filename=0001-fixup-gnu-Update-Haskell-ecosystem.patch Content-Transfer-Encoding: quoted-printable From=20921cf30835963bc27fcf6672b33da45dbcfe6da0 Mon Sep 17 00:00:00 2001 Message-Id: <921cf30835963bc27fcf6672b33da45dbcfe6da0.1633108979.git.public= @yoctocell.xyz> From: Xinglu Chen Date: Mon, 27 Sep 2021 17:13:32 +0200 Subject: [PATCH] fixup! gnu: Update Haskell ecosystem. =2D-- gnu/packages/haskell-check.scm | 18 +- gnu/packages/haskell-web.scm | 5 +- gnu/packages/haskell-xyz.scm | 1343 ++++++++++++++++++-------------- gnu/packages/purescript.scm | 5 +- 4 files changed, 767 insertions(+), 604 deletions(-) diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm index 42ec3e9c27..bfceb2e45b 100644 =2D-- a/gnu/packages/haskell-check.scm +++ b/gnu/packages/haskell-check.scm @@ -1176,9 +1176,10 @@ (define-public ghc-doctest-exitcode-stdio ("ghc-quickcheck" ,ghc-quickcheck) ("ghc-semigroups" ,ghc-semigroups))) (home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/") =2D (synopsis "Run doctest's in a Cabal.Test.exitcode-stdio environment") + (synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environm= ent") (description =2D "Run doctest's in a Cabal.Test.exitcode-stdio environment. For use= with the @doctest-extract@ utility. Normally, you should not need to impor= t a module from this package, only generated code will do this.") + "This package allows on to run Doctests in a Cabal.Test.exitcode-std= io +environment.") (license license:bsd-3))) =20 (define-public ghc-cabal-doctest @@ -1199,9 +1200,9 @@ (define-public ghc-cabal-doctest `(#:cabal-revision ("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb"))) (home-page "https://github.com/phadej/cabal-doctest") =2D (synopsis "A Setup.hs helper for doctests running") + (synopsis "@file{Setup.hs} helper for Doctests running") (description =2D "Currently (beginning of 2017), there isn't @cabal doctest@ comman= d. Yet, to properly work doctest needs plenty of configuration. This librar= y provides the common bits for writing custom Setup.hs See for the progress of @cabal doctes= t@, i.e. whether this library is obsolete.") + "This package provides helpers for running Doctests in @file{Setup.h= s}." (license license:bsd-3))) =20 (define-public ghc-tasty-silver @@ -1232,8 +1233,13 @@ (define-public ghc-tasty-silver `(#:cabal-revision ("1" "0mgdk77xz38zc46qbxvss6vnp4yk328zbpw1l0c1n0f5gyf6sbav"))) (home-page "https://github.com/phile314/tasty-silver") =2D (synopsis "A fancy test runner, including support for golden tests.") + (synopsis "Fancy test runner, including support for golden tests") (description =2D "This package provides a fancy test runner and support for =C3=82= =C2=ABgolden testing=C3=82=C2=BB. A golden test is an IO action that writes= its result to a file. To pass the test, this output file should be identic= al to the corresponding =C3=82=C2=ABgolden=C3=82=C2=BB file, which contains= the correct result for the test. The test runner allows filtering tests us= ing regexes, and to interactively inspect the result of golden tests. This = package is a heavily extended fork of tasty-golden.") + "This package provides a fancy test runner and support for @dfn{gold= en +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 +``golden'' file, which contains the correct result for the test. The test +runner allows filtering tests using regexes, and to interactively inspect = the +result of golden tests.") (license license:expat))) =20 diff --git a/gnu/packages/haskell-web.scm b/gnu/packages/haskell-web.scm index 76c5e906f4..ad8713dbd8 100644 =2D-- a/gnu/packages/haskell-web.scm +++ b/gnu/packages/haskell-web.scm @@ -2310,8 +2310,9 @@ (define-public ghc-network-run (base32 "0w3dmwk03j4n01xkiq8m4sqa27bskh239mpw7m4ihjmkxqcwc5gl"))= )) (build-system haskell-build-system) (inputs `(("ghc-network" ,ghc-network))) =2D (home-page "http://hackage.haskell.org/package/network-run") + (home-page "https://hackage.haskell.org/package/network-run") (synopsis "Simple network runner library") =2D (description "Simple functions to run network clients and servers.") + (description + "This package provides a simple network runner library in Haskell.") (license license:bsd-3))) =20 diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm index 3df5320c09..b07e5a1ee5 100644 =2D-- a/gnu/packages/haskell-xyz.scm +++ b/gnu/packages/haskell-xyz.scm @@ -6655,9 +6655,8 @@ (define-public ghc-intervals `(("ghc-quickcheck" ,ghc-quickcheck))) (home-page "https://github.com/ekmett/intervals") (synopsis "Interval arithmetic") =2D (description "This library provides =2D@code{Numeric.Interval.Interval}, which represets a closed, convex set =2Dof floating point values.") + (description "This library provides @code{Numeric.Interval.Interval}, +which represets a closed, convex set of floating point values.") (license license:bsd-3))) =20 (define-public ghc-invariant @@ -6869,8 +6868,8 @@ (define-public ghc-json (home-page "https://hackage.haskell.org/package/json") (synopsis "Serializes Haskell data to and from JSON") (description "This package provides a parser and pretty printer for =2Dconverting between Haskell values and JSON. =2DJSON (JavaScript Object Notation) is a lightweight data-interchange form= at.") +converting between Haskell values and JSON. @acronym{JavaScript Object +Notation, JSON} is a lightweight data-interchange format.") (license license:bsd-3))) =20 (define-public ghc-juicypixels @@ -12942,7 +12941,6 @@ (define ghc-system-fileio-bootstrap which can't be decoded in the current locale encoding.") (license license:expat))) =20 =2D (define-public ghc-system-filepath (package (name "ghc-system-filepath") @@ -15492,28 +15490,48 @@ (define-public ghc-zstd targeting real-time compression scenarios at zlib-level and better compression ratios.") (license license:bsd-3))) + (define-public ghc-indexed-traversable (package (name "ghc-indexed-traversable") (version "0.1.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/indexed-traversable/= indexed-traversable-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0fc18vdm1894yjbjkj9wjm27bf37ac3gvkzak677mgiw2pinmhvs"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/indexed-traversable/inde= xed-traversable-" + version + ".tar.gz")) + (sha256 + (base32 "0fc18vdm1894yjbjkj9wjm27bf37ac3gvkzak677mgiw2pinmhvs")))) (build-system haskell-build-system) (inputs `(("ghc-generic-deriving" ,ghc-generic-deriving))) (arguments =2D `(#:cabal-revision =2D ("1" "0krvp9v5dh4w2076kar48cpkk62ndqp769v2ai3b38rsa5bj6q74"))) =2D (home-page "http://hackage.haskell.org/package/indexed-traversable") =2D (synopsis "FunctorWithIndex, FoldableWithIndex, TraversableWithIndex= ") + `(#:cabal-revision + ("1" "0krvp9v5dh4w2076kar48cpkk62ndqp769v2ai3b38rsa5bj6q74"))) + (home-page "https://hackage.haskell.org/package/indexed-traversable") + (synopsis "Indexed Functor, Foldable, and Traversable typeclasses") (description =2D "This package provides three useful generalizations: . @ class Fun= ctor f =3D> FunctorWithIndex i f | f -> i where \\ imap :: (i -> a -> b) -= > f a -> f b @ . @ class Foldable f =3D> FoldableWithIndex i f | f -> i whe= re \\ ifoldMap :: Monoid m =3D> (i -> a -> m) -> f a -> m @ . @ class (Fun= ctorWithIndex i t, FoldableWithIndex i t, Traversable t) =3D> TraversableWi= thIndex i t | t -> i where \\ itraverse :: Applicative f =3D> (i -> a -> f= b) -> t a -> f (t b) @ . This package contains instances for types in GHC = boot libraries. For some additional instances see [indexed-traversable-inst= ances](https://hackage.haskell.org/package/indexed-traversable-instances). = . The [keys](https://hackage.haskell.org/package/keys) package provides sim= ilar functionality, but uses (associated) @TypeFamilies@ instead of @Functi= onalDependencies@.") + "This Haskell package provides three useful generalizations: + +@example +class Functor f =3D> FunctorWithIndex i f | f -> i where + imap :: (i -> a -> b) -> f a -> f b +@end example + +@example +class Foldable f =3D> FoldableWithIndex i f | f -> i where + ifoldMap :: Monoid m =3D> (i -> a -> m) -> f a -> m +@end example + +@example +class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) + =3D> TraversableWithIndex i t | t -> i where + itraverse :: Applicative f =3D> (i -> a -> f b) -> t a -> f (t b) +@end example + +The @code{ghc-keys} package provides similar functionality, but uses +associated @code{TypeFamilies} instead of @code{FunctionalDependencies}.") (license license:bsd-2))) =20 (define-public ghc-type-equality @@ -15521,22 +15539,31 @@ (define-public ghc-type-equality (name "ghc-type-equality") (version "1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/type-equality/type-e= quality-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1s4cl11rvvv7n95i3pq9lmmx08kwh4z7l3d1hbv4wi8il81baa27"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/type-equality/type-equal= ity-" + version + ".tar.gz")) + (sha256 + (base32 "1s4cl11rvvv7n95i3pq9lmmx08kwh4z7l3d1hbv4wi8il81baa27")))) (build-system haskell-build-system) (arguments =2D `(#:cabal-revision =2D ("2" "1a3irpv5kyg3rywhmcp5fwg5irrdbdr0hrlw7asdk113nakrba7j"))) + `(#:cabal-revision + ("2" "1a3irpv5kyg3rywhmcp5fwg5irrdbdr0hrlw7asdk113nakrba7j"))) (home-page "https://github.com/hesselink/type-equality") =2D (synopsis "Data.Type.Equality compat package") + (synopsis "@code{Data.Type.Equality} compatibility package") (description =2D "This library defines a propositional equality data type, shims @D= ata.Type.Equality@ as well as possible for older GHCs (< 7.8). . @ data a := ~: b where \\ Refl :: a :~: a @ . The module @Data.Type.Equality.Hetero@= shims @:~~:@ equality, for compilers with @PolyKinds@") + "This library defines a propositional equality data type, shims +@code{Data.Type.Equality} as well as possible for older GHC versions (< 7.= 8). + +@example +data a :~: b where + Refl :: a :~: a +@end example + +The module @code{Data.Type.Equality.Hetero} shims @@code{:~~:} equality, a= nd +for compilers with @code{PolyKinds}.") (license license:bsd-3))) =20 (define-public ghc-selective @@ -15544,24 +15571,28 @@ (define-public ghc-selective (name "ghc-selective") (version "0.4.2") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/selective/selective-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/selective/selective-" + version + ".tar.gz")) + (sha256 + (base32 "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l")))) (build-system haskell-build-system) (native-inputs =2D `(("ghc-quickcheck" ,ghc-quickcheck) =2D ("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure) =2D ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) (home-page "https://github.com/snowleopard/selective") (synopsis "Selective applicative functors") (description =2D "Selective applicative functors: declare your effects statically, = select which to execute dynamically. . This is a library for /selective app= licative functors/, or just /selective functors/ for short, an abstraction = between applicative functors and monads, introduced in .") + "This package implements selective applicative functors, which allow = you +to declare your effects statically, and select which to execute dynamicall= y. +See the +@uref{https://www.staff.ncl.ac.uk/andrey.mokhov/selective-functors.pdf, pa= per +on selective functors} for more details.") (license license:expat))) =20 (define-public ghc-keys @@ -15569,28 +15600,31 @@ (define-public ghc-keys (name "ghc-keys") (version "3.12.3") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/keys/keys-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/keys/keys-" + version + ".tar.gz")) + (sha256 + (base32 "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm")))) (build-system haskell-build-system) (inputs =2D `(("ghc-comonad" ,ghc-comonad) =2D ("ghc-free" ,ghc-free) =2D ("ghc-hashable" ,ghc-hashable) =2D ("ghc-semigroupoids" ,ghc-semigroupoids) =2D ("ghc-semigroups" ,ghc-semigroups) =2D ("ghc-tagged" ,ghc-tagged) =2D ("ghc-transformers-compat" ,ghc-transformers-compat) =2D ("ghc-unordered-containers" ,ghc-unordered-containers))) + `(("ghc-comonad" ,ghc-comonad) + ("ghc-free" ,ghc-free) + ("ghc-hashable" ,ghc-hashable) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-tagged" ,ghc-tagged) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-unordered-containers" ,ghc-unordered-containers))) (home-page "http://github.com/ekmett/keys/") (synopsis "Keyed functors and containers") (description =2D "This package provides a bunch of ad hoc classes for accessing par= ts of a container. . In practice this package is largely subsumed by the , but it is maintained= for now as it has much simpler dependencies.") + "This package provides a bunch of ad hoc classes for accessing parts = of +a container. In practice this package is largely subsumed by the +@code{ghc-lens}, but it is maintained for now as it has much simpler +dependencies.") (license license:bsd-3))) =20 (define-public ghc-pointed @@ -15598,28 +15632,29 @@ (define-public ghc-pointed (name "ghc-pointed") (version "5.0.2") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/pointed/pointed-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "07p92y62dibys3xa59rvx52xyyr39nghl73z7hzwnksa3ry3vfmq"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/pointed/pointed-" + version + ".tar.gz")) + (sha256 + (base32 "07p92y62dibys3xa59rvx52xyyr39nghl73z7hzwnksa3ry3vfmq")))) (build-system haskell-build-system) (inputs =2D `(("ghc-data-default-class" ,ghc-data-default-class) =2D ("ghc-comonad" ,ghc-comonad) =2D ("ghc-kan-extensions" ,ghc-kan-extensions) =2D ("ghc-semigroupoids" ,ghc-semigroupoids) =2D ("ghc-semigroups" ,ghc-semigroups) =2D ("ghc-tagged" ,ghc-tagged) =2D ("ghc-transformers-compat" ,ghc-transformers-compat) =2D ("ghc-hashable" ,ghc-hashable) =2D ("ghc-unordered-containers" ,ghc-unordered-containers))) =2D (home-page "http://github.com/ekmett/pointed/") =2D (synopsis "Pointed and copointed data") =2D (description "Pointed and copointed data.") + `(("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-comonad" ,ghc-comonad) + ("ghc-kan-extensions" ,ghc-kan-extensions) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-tagged" ,ghc-tagged) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-hashable" ,ghc-hashable) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (home-page "https://github.com/ekmett/pointed/") + (synopsis "Pointed and copointed data types") + (description + "This Haskell library provides pointed and copointed data types.") (license license:bsd-3))) =20 (define-public ghc-vector-instances @@ -15627,26 +15662,28 @@ (define-public ghc-vector-instances (name "ghc-vector-instances") (version "3.4") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/vector-instances/vec= tor-instances-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "10akvpa5w9bp0d8hflab63r9laa9gy2hv167smhjsdzq1kplc0hv"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/vector-instances/vector-= instances-" + version + ".tar.gz")) + (sha256 + (base32 "10akvpa5w9bp0d8hflab63r9laa9gy2hv167smhjsdzq1kplc0hv")))) (build-system haskell-build-system) (inputs =2D `(("ghc-vector" ,ghc-vector) =2D ("ghc-semigroupoids" ,ghc-semigroupoids) =2D ("ghc-semigroups" ,ghc-semigroups) =2D ("ghc-comonad" ,ghc-comonad) =2D ("ghc-pointed" ,ghc-pointed) =2D ("ghc-keys" ,ghc-keys) =2D ("ghc-hashable" ,ghc-hashable))) =2D (home-page "http://github.com/ekmett/vector-instances") =2D (synopsis "Orphan Instances for 'Data.Vector'") =2D (description "") + `(("ghc-vector" ,ghc-vector) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-comonad" ,ghc-comonad) + ("ghc-pointed" ,ghc-pointed) + ("ghc-keys" ,ghc-keys) + ("ghc-hashable" ,ghc-hashable))) + (home-page "https://github.com/ekmett/vector-instances") + (synopsis "Orphan instances for @code{Data.Vector}") + (description + "This Haskell library provides a place for lots of orphan instances f= or +the @code{ghc-vector} package.") (license license:bsd-3))) =20 (define-public ghc-th-compat @@ -15654,23 +15691,28 @@ (define-public ghc-th-compat (name "ghc-th-compat") (version "0.1.3") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/th-compat/th-compat-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/th-compat/th-compat-" + version + ".tar.gz")) + (sha256 + (base32 "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b")))) (build-system haskell-build-system) (native-inputs =2D `(("ghc-base-compat" ,ghc-base-compat) =2D ("ghc-hspec" ,ghc-hspec) =2D ("hspec-discover" ,hspec-discover))) + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover))) (home-page "https://github.com/haskell-compat/th-compat") =2D (synopsis "Backward- (and forward-)compatible Quote and Code types") + (synopsis + "Backward- and forward-compatible @code{Quote} and @code{Code} types") (description =2D "This package defines a \"Language.Haskell.TH.Syntax.Compat\" modu= le, which backports the @Quote@ and @Code@ types to work across a wide rang= e of @template-haskell@ versions. On recent versions of @template-haskell@ = (2.17.0.0 or later), this module simply reexports @Quote@ and @Code@ from \= "Language.Haskell.TH.Syntax\". Refer to the Haddocks for \"Language.Haskell= .TH.Syntax.Compat\" for examples of how to use this module.") + "This package defines a @code{Language.Haskell.TH.Syntax.Compat} modu= le, +which backports the @code{Quote} and @code{Code} types to work across a wi= de +range of @code{template-haskell} versions. On recent versions of +@code{template-haskell} (2.17.0.0 or later), this module simply re-exports +@code{Quote} and @code{Code} from @code{Language.Haskell.TH.Syntax}.") (license license:bsd-3))) =20 (define-public ghc-filepattern @@ -15678,21 +15720,43 @@ (define-public ghc-filepattern (name "ghc-filepattern") (version "0.1.2") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/filepattern/filepatt= ern-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0nznzji5haxl4ninm2a79dqf4c7fj6pc3z9gdc6wbf5h1pp14afr"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/filepattern/filepattern-" + version + ".tar.gz")) + (sha256 + (base32 "0nznzji5haxl4ninm2a79dqf4c7fj6pc3z9gdc6wbf5h1pp14afr")))) (build-system haskell-build-system) =2D (inputs `(("ghc-extra" ,ghc-extra) ("ghc-semigroups" ,ghc-semigroups= ))) + (inputs + `(("ghc-extra" ,ghc-extra) + ("ghc-semigroups" ,ghc-semigroups))) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck))) =2D (home-page "https://github.com/ndmitchell/filepattern#readme") + (home-page "https://github.com/ndmitchell/filepattern") (synopsis "File path glob-like matching") (description =2D "A library for matching files using patterns such as @\\\"src\\/**= \\/*.png\\\"@ for all @.png@ files recursively under the @src@ directory. F= eatures: . * All matching is /O(n)/. Most functions precompute some informa= tion given only one argument. . * See \"System.FilePattern\" and @?=3D=3D@ = simple matching and semantics. . * Use @match@ and @substitute@ to extract = suitable strings from the @*@ and @**@ matches, and substitute them back in= to other patterns. . * Use @step@ and @matchMany@ to perform bulk matching = of many patterns against many paths simultaneously. . * Use \"System.FilePa= ttern.Directory\" to perform optimised directory traverals using patterns. = . Originally taken from the .") + "This package provides Haskell library for matching files using patte= rns +such as @code{\\\"src\\/**\\/*.png\\\"} for all @@file{.png} files recursi= vely +under the @@file{src} directory. + +Some of its features include: + +@itemize +@item All matching is O(n). + +@item Most functions pre-compute some information given only one argument. + +@item Uses @code{match} and @code{substitute} to extract suitable strings = from +the @code{*} and @code{**} matches, and substitutes them back into other +patterns. + +@item Uses @code{step} and @code{matchMany} to perform bulk matching of ma= ny +patterns against many paths simultaneously. + +@item Uses @code{System.FilePattern.Directory} to perform optimised direct= ory +traverals using patterns. +@end itemize") (license license:bsd-3))) =20 (define-public ghc-lib-parser-ex @@ -15700,24 +15764,24 @@ (define-public ghc-lib-parser-ex (name "ghc-lib-parser-ex") (version "8.10.0.23") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/ghc-lib-parser-ex/gh= c-lib-parser-ex-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0r5sl7hhn0cxp0b1dskx1lshplc0yka7hcvs2nh10nrj07fjd3vj"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/ghc-lib-parser-ex/ghc-li= b-parser-ex-" + version + ".tar.gz")) + (sha256 + (base32 "0r5sl7hhn0cxp0b1dskx1lshplc0yka7hcvs2nh10nrj07fjd3vj")))) (build-system haskell-build-system) (inputs `(("ghc-uniplate" ,ghc-uniplate))) (native-inputs =2D `(("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-hunit" ,ghc-tasty-hunit) =2D ("ghc-extra" ,ghc-extra))) =2D (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex#rea= dme") + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-extra" ,ghc-extra))) + (home-page "https://github.com/shayne-fletcher/ghc-lib-parser-ex") (synopsis "Algorithms on GHC parse trees") (description =2D "Please see the README on GitHub at ") + "The @code{ghc-lib-parser-ex} package contains GHC API parse tree uti= lities.") (license license:bsd-3))) =20 (define-public ghc-lift-type @@ -15725,20 +15789,22 @@ (define-public ghc-lift-type (name "ghc-lift-type") (version "0.1.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/lift-type/lift-type-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/lift-type/lift-type-" + version + ".tar.gz")) + (sha256 + (base32 "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf")))) (build-system haskell-build-system) =2D (home-page "https://github.com/parsonsmatt/lift-type#readme") + (home-page "https://github.com/parsonsmatt/lift-type") (synopsis =2D "Lift a type from a Typeable constraint to a Template Haskell type= ") + "Lift a type from a Typeable constraint to a Template Haskell type") (description =2D "Lift your types from a Typeable constraint to a Template Haskell = type") + "This library provides a utility function @code{liftType}, which acce= pts a type +application argument and returns the Template Haskell @code{Type} represen= tation of +it.") (license license:bsd-3))) =20 (define-public ghc-unicode-collation @@ -15746,87 +15812,106 @@ (define-public ghc-unicode-collation (name "ghc-unicode-collation") (version "0.1.3") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/unicode-collation/un= icode-collation-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/unicode-collation/unicod= e-collation-" + version + ".tar.gz")) + (sha256 + (base32 "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi")))) (build-system haskell-build-system) (inputs `(("ghc-th-lift-instances" ,ghc-th-lift-instances))) (native-inputs =2D `(("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) =2D ("ghc-tasty-hunit" ,ghc-tasty-hunit) =2D ("ghc-unicode-transforms" ,ghc-unicode-transforms) =2D ("ghc-doctest" ,ghc-doctest))) + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-unicode-transforms" ,ghc-unicode-transforms) + ("ghc-doctest" ,ghc-doctest))) (home-page "https://github.com/jgm/unicode-collation") (synopsis "Haskell implementation of the Unicode Collation Algorithm") (description =2D "This library provides a pure Haskell implementation of the Unicod= e Collation Algorithm described at . = It is not as fully-featured or as performant as @text-icu@, but it avoids = a dependency on a large C library. Locale-specific tailorings are also prov= ided.") =2D (license #f))) + "This library provides a pure Haskell implementation of the Unicode +Collation Algorithm described at @uref{http://www.unicode.org/reports/tr10= /}. +It is not as fully-featured or as performant as @code{text-icu}, but it av= oids +a dependency on a large C library. Locale-specific tailorings are also +provided.") + (license license:bsd-3))) =20 (define-public ghc-citeproc (package (name "ghc-citeproc") (version "0.4.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/citeproc/citeproc-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/citeproc/citeproc-" + version + ".tar.gz")) + (sha256 + (base32 "13hgbcbr7jbyfbxp8fsc43c2wq4fhlbxzqwh1plfkdi5n9bif1lv")))) (build-system haskell-build-system) (inputs =2D `(("ghc-safe" ,ghc-safe) =2D ("ghc-case-insensitive" ,ghc-case-insensitive) =2D ("ghc-vector" ,ghc-vector) =2D ("ghc-scientific" ,ghc-scientific) =2D ("ghc-uniplate" ,ghc-uniplate) =2D ("ghc-xml-conduit" ,ghc-xml-conduit) =2D ("ghc-attoparsec" ,ghc-attoparsec) =2D ("ghc-data-default" ,ghc-data-default) =2D ("ghc-aeson" ,ghc-aeson) =2D ("ghc-file-embed" ,ghc-file-embed) =2D ("ghc-pandoc-types" ,ghc-pandoc-types) =2D ("ghc-unicode-collation" ,ghc-unicode-collation) =2D ("ghc-base-compat" ,ghc-base-compat) =2D ("ghc-aeson-pretty" ,ghc-aeson-pretty))) + `(("ghc-safe" ,ghc-safe) + ("ghc-case-insensitive" ,ghc-case-insensitive) + ("ghc-vector" ,ghc-vector) + ("ghc-scientific" ,ghc-scientific) + ("ghc-uniplate" ,ghc-uniplate) + ("ghc-xml-conduit" ,ghc-xml-conduit) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-data-default" ,ghc-data-default) + ("ghc-aeson" ,ghc-aeson) + ("ghc-file-embed" ,ghc-file-embed) + ("ghc-pandoc-types" ,ghc-pandoc-types) + ("ghc-unicode-collation" ,ghc-unicode-collation) + ("ghc-base-compat" ,ghc-base-compat) + ("ghc-aeson-pretty" ,ghc-aeson-pretty))) (native-inputs `(("ghc-timeit" ,ghc-timeit) ("ghc-diff" ,ghc-diff))) =2D (home-page "http://hackage.haskell.org/package/citeproc") =2D (synopsis "Generates citations and bibliography from CSL styles.") + (home-page "https://hackage.haskell.org/package/citeproc") + (synopsis "Generate citations and bibliography from CSL styles") (description =2D "citeproc parses CSL style files and uses them to generate a list = of formatted citations and bibliography entries. For more information abou= t CSL, see .") =2D (license #f))) + "@code{ghc-citeproc} parses @acronym{Citation Style Language, CSL} st= yle files +and uses them to generate a list of formatted citations and bibliography +entries. For more information about CSL, see @urefhttps://citationstyles.= org/}.") + (license license:bsd-2))) =20 (define-public ghc-commonmark (package (name "ghc-commonmark") (version "0.2.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/commonmark/commonmar= k-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1vba7v1zaqh811v3j4x42g7mhwvxwgzm997kq1kzd0njby14fq5b"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/commonmark/commonmark-" + version + ".tar.gz")) + (sha256 + (base32 "1vba7v1zaqh811v3j4x42g7mhwvxwgzm997kq1kzd0njby14fq5b")))) (build-system haskell-build-system) (inputs `(("ghc-unicode-transforms" ,ghc-unicode-transforms))) (native-inputs =2D `(("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) =2D ("ghc-tasty-hunit" ,ghc-tasty-hunit))) + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-tasty-hunit" ,ghc-tasty-hunit))) (home-page "https://github.com/jgm/commonmark-hs") =2D (synopsis "Pure Haskell commonmark parser.") + (synopsis "Pure Haskell Commonmark parser") (description =2D "This library provides the core data types and functions for parsi= ng commonmark (). The parser is fully commonma= rk-compliant and passes the test suite. It is designed to be customizable = and easily extensible. To customize the output, create an AST, or support a= new output format, one need only define some new typeclass instances. It i= s also easy to add new syntax elements or modify existing ones. . Accurate = information about source positions is available for all block and inline el= ements. Thus the library can be used to create an accurate syntax highligh= ter or an editor with live preview. . The parser has been designed for robu= st performance even in pathological cases that tend to cause stack overflow= s or exponential slowdowns in other parsers, with parsing speed that varies= linearly with input length. . Related packages: . - commonmark-extensions = (which defines a number of syntax extensions) - commonmark-pandoc (which al= lows using this parser to create a Pandoc structure) - commonmark-cli (a co= mmand-line tool for converting and syntax-highlighting commonmark documents= )") + "This library provides the core data types and functions for parsing +@uref{https://spec.commonmark.org, Commonmark}. The parser is fully +Commonmark-compliant and passes the test suite. It is designed to be +customizable and easily extensible. To customize the output, create an AS= T, +or support a new output format, one need only define some new typeclass +instances. It is also easy to add new syntax elements or modify existing +ones. + +Accurate information about source positions is available for all block and +inline elements. Thus the library can be used to create an accurate syntax +highlighter or an editor with live preview. The parser has been designed f= or +robust performance even in pathological cases that tend to cause stack +overflows or exponential slowdowns in other parsers, with parsing speed th= at +varies linearly with input length.") (license license:bsd-3))) =20 (define-public ghc-commonmark-extensions @@ -15834,25 +15919,27 @@ (define-public ghc-commonmark-extensions (name "ghc-commonmark-extensions") (version "0.2.1.2") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/commonmark-extension= s/commonmark-extensions-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1ky0j7086a8mqpg26j2nkrc5wfwiw5cd3h3jqncpy59vmj1prkx4"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/commonmark-extensions/co= mmonmark-extensions-" + version + ".tar.gz")) + (sha256 + (base32 "1ky0j7086a8mqpg26j2nkrc5wfwiw5cd3h3jqncpy59vmj1prkx4")))) (build-system haskell-build-system) (inputs =2D `(("ghc-network-uri" ,ghc-network-uri) =2D ("ghc-commonmark" ,ghc-commonmark) =2D ("ghc-emojis" ,ghc-emojis))) + `(("ghc-network-uri" ,ghc-network-uri) + ("ghc-commonmark" ,ghc-commonmark) + ("ghc-emojis" ,ghc-emojis))) (native-inputs =2D `(("ghc-tasty" ,ghc-tasty) ("ghc-tasty-hunit" ,ghc-tasty-hunit))) + `(("ghc-tasty" ,ghc-tasty) ("ghc-tasty-hunit" ,ghc-tasty-hunit))) (home-page "https://github.com/jgm/commonmark-hs") =2D (synopsis "Pure Haskell commonmark parser.") + (synopsis "Extensions for @code{ghc-commonmark}") (description =2D "This library provides some useful extensions to core commonmark s= yntax: smart quotes, definition lists, tables, footnotes, math, and more.") + "This library provides some useful extensions for @code{ghc-commonmar= k} +to parser core commonmark syntax: smart quotes, definition lists, tables, +footnotes, math, and more.") (license license:bsd-3))) =20 (define-public ghc-commonmark-pandoc @@ -15860,23 +15947,24 @@ (define-public ghc-commonmark-pandoc (name "ghc-commonmark-pandoc") (version "0.2.1.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/commonmark-pandoc/co= mmonmark-pandoc-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/commonmark-pandoc/common= mark-pandoc-" + version + ".tar.gz")) + (sha256 + (base32 "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp")))) (build-system haskell-build-system) (inputs =2D `(("ghc-commonmark" ,ghc-commonmark) =2D ("ghc-commonmark-extensions" ,ghc-commonmark-extensions) =2D ("ghc-pandoc-types" ,ghc-pandoc-types))) + `(("ghc-commonmark" ,ghc-commonmark) + ("ghc-commonmark-extensions" ,ghc-commonmark-extensions) + ("ghc-pandoc-types" ,ghc-pandoc-types))) (home-page "https://github.com/jgm/commonmark-hs") =2D (synopsis "Bridge between commonmark and pandoc AST.") + (synopsis "Bridge between Commonmark and Pandoc AST.") (description =2D "This library provides typeclasses for rendering commonmark to Pan= doc types.") + "This library provides typeclasses for rendering @code{ghc-commonmark= } to +Pandoc types.") (license license:bsd-3))) =20 (define-public ghc-hslua-module-path @@ -15884,24 +15972,25 @@ (define-public ghc-hslua-module-path (name "ghc-hslua-module-path") (version "0.1.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/hslua-module-path/hs= lua-module-path-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1zxfljcn74rky26ijqmba6grpj0h9plgr47wxdaf7gcz1y8dhn68"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/hslua-module-path/hslua-= module-path-" + version + ".tar.gz")) + (sha256 + (base32 "1zxfljcn74rky26ijqmba6grpj0h9plgr47wxdaf7gcz1y8dhn68")))) (build-system haskell-build-system) (inputs `(("ghc-hslua" ,ghc-hslua))) (native-inputs =2D `(("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-hunit" ,ghc-tasty-hunit) =2D ("ghc-tasty-lua" ,ghc-tasty-lua))) + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-lua" ,ghc-tasty-lua))) (home-page "https://github.com/hslua/hslua-module-path") =2D (synopsis "Lua module to work with file paths.") + (synopsis "Lua module to work with file paths") (description =2D "Lua module to work with file paths in a platform independent way.= ") + "This Haskell library provides a Lua module to work with file paths i= n a +platform independent way.") (license license:expat))) =20 (define-public ghc-template-haskell @@ -15909,20 +15998,23 @@ (define-public ghc-template-haskell (name "ghc-template-haskell") (version "2.16.0.0") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/template-haskell/tem= plate-haskell-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1nk1cv35szp80qkhbyh5gn6vn194zzl0wz186qrqdrdx3a9r9w4g"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/template-haskell/templat= e-haskell-" + version + ".tar.gz")) + (sha256 + (base32 "1nk1cv35szp80qkhbyh5gn6vn194zzl0wz186qrqdrdx3a9r9w4g")))) (build-system haskell-build-system) (inputs `(("ghc-boot-th" ,ghc-boot-th))) (home-page "http://hackage.haskell.org/package/template-haskell") (synopsis "Support library for Template Haskell") (description =2D "This package provides modules containing facilities for manipulat= ing Haskell source code using Template Haskell. . See for more information.") + "This package provides modules containing facilities for manipulating +Haskell source code using Template Haskell. See +@uref{http://www.haskell.org/haskellwiki/Template_Haskell} for more +information.") (license license:bsd-3))) =20 (define-public ghc-genvalidity-hspec @@ -15930,27 +16022,28 @@ (define-public ghc-genvalidity-hspec (name "ghc-genvalidity-hspec") (version "0.7.0.4") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/genvalidity-hspec/ge= nvalidity-hspec-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0aajx07n2rznyqxb0c4pn9j2cvkzw5brz9ki4grhhigbcri3jzmv"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/genvalidity-hspec/genval= idity-hspec-" + version + ".tar.gz")) + (sha256 + (base32 "0aajx07n2rznyqxb0c4pn9j2cvkzw5brz9ki4grhhigbcri3jzmv")))) (build-system haskell-build-system) (inputs =2D `(("ghc-quickcheck" ,ghc-quickcheck) =2D ("ghc-genvalidity" ,ghc-genvalidity) =2D ("ghc-genvalidity-property" ,ghc-genvalidity-property) =2D ("ghc-hspec" ,ghc-hspec) =2D ("hspec-discover" ,hspec-discover) =2D ("ghc-hspec-core" ,ghc-hspec-core) =2D ("ghc-validity" ,ghc-validity))) =2D (home-page "https://github.com/NorfairKing/validity#readme") =2D (synopsis "Standard spec's for GenValidity instances") + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-genvalidity" ,ghc-genvalidity) + ("ghc-genvalidity-property" ,ghc-genvalidity-property) + ("ghc-hspec" ,ghc-hspec) + ("hspec-discover" ,hspec-discover) + ("ghc-hspec-core" ,ghc-hspec-core) + ("ghc-validity" ,ghc-validity))) + (home-page "https://github.com/NorfairKing/validity") + (synopsis "Standard spec's for @code{GenValidity} instances") (description =2D "Note: There are companion packages for this library: . * . * . * . * ") + "This haskell library provides validity and validity-based testing for +@code{ghc-hspec}. ") (license license:expat))) =20 (define-public ghc-boot-th @@ -15958,49 +16051,53 @@ (define-public ghc-boot-th (name "ghc-boot-th") (version "8.10.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/ghc-boot-th/ghc-boot= -th-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0vhhmsd32p7zn9vhpv4d0k0b55n2dyhzy42xblndrma617kz8gli"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/ghc-boot-th/ghc-boot-th-" + version + ".tar.gz")) + (sha256 + (base32 "0vhhmsd32p7zn9vhpv4d0k0b55n2dyhzy42xblndrma617kz8gli")))) (build-system haskell-build-system) (home-page "http://hackage.haskell.org/package/ghc-boot-th") (synopsis =2D "Shared functionality between GHC and the `template-haskell` libra= ry") + "Shared functionality between GHC and Template Haskell" (description =2D "This library contains various bits shared between the @ghc@ and @= template-haskell@ libraries. . This package exists to ensure that @template= -haskell@ has a minimal set of transitive dependencies, since it is intende= d to be depended upon by user code.") =2D (license license:bsd-3))) + "This library contains various bits shared between GHC and Template +Haskell. This package exists to ensure that @code{template-haskell} has a +minimal set of transitive dependencies, since it is intended to be depended +upon by user code.") + (license license:bsd-3)))) =20 (define-public ghc-binary-orphans (package (name "ghc-binary-orphans") (version "1.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/binary-orphans/binar= y-orphans-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0gbmn5rpvyxhw5bxjmxwld6918lslv03b2f6hshssaw1il5x86j3"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/binary-orphans/binary-or= phans-" + version + ".tar.gz")) + (sha256 + (base32 "0gbmn5rpvyxhw5bxjmxwld6918lslv03b2f6hshssaw1il5x86j3")))) (build-system haskell-build-system) (native-inputs =2D `(("ghc-quickcheck" ,ghc-quickcheck) =2D ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) =2D ("ghc-tagged" ,ghc-tagged) =2D ("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) + ("ghc-tagged" ,ghc-tagged) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) (arguments =2D `(#:cabal-revision =2D ("5" "1h2d37szfrcwn9rphnijn4q9l947b0wwqjs1aqmm62xkhbad7jf6"))) + `(#:cabal-revision + ("5" "1h2d37szfrcwn9rphnijn4q9l947b0wwqjs1aqmm62xkhbad7jf6"))) (home-page "http://hackage.haskell.org/package/binary-orphans") =2D (synopsis "Compatibility package for binary; provides instances") + (synopsis "Compatibility package for binary") (description =2D "This package provides instances defined in later versions of @bin= ary@ package . Prior version 1 this packages provided instances for other p= ackages. That functionality is moved to [binary-instances](https://hackage.= haskell.org/package/binary-instances) package.") + "This package provides instances defined in later versions of +@code{ghc-binary} package.") (license license:bsd-3))) =20 (define-public ghc-netlink @@ -16008,24 +16105,27 @@ (define-public ghc-netlink (name "ghc-netlink") (version "1.1.1.0") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/netlink/netlink-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1q8sxycv93sap6dgbw70scklnpjj5vav6qlvsxm5500jlvb3jnf0"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/netlink/netlink-" + version + ".tar.gz")) + (sha256 + (base32 "1q8sxycv93sap6dgbw70scklnpjj5vav6qlvsxm5500jlvb3jnf0")))) (build-system haskell-build-system) (inputs =2D `(("ghc-cereal" ,ghc-cereal) =2D ("ghc-monad-loops" ,ghc-monad-loops) =2D ("ghc-pretty-hex" ,ghc-pretty-hex) =2D ("ghc-language-c" ,ghc-language-c) =2D ("ghc-regex-pcre" ,ghc-regex-pcre))) + `(("ghc-cereal" ,ghc-cereal) + ("ghc-monad-loops" ,ghc-monad-loops) + ("ghc-pretty-hex" ,ghc-pretty-hex) + ("ghc-language-c" ,ghc-language-c) + ("ghc-regex-pcre" ,ghc-regex-pcre))) (home-page "https://github.com/Ongy/netlink-hs") (synopsis "Netlink communication for Haskell") =2D (description "Library to comminicate with Linux kernel via Netlink") + (description + "This is library provides utility to use Netlink from Haskell. The s= cope of +this package extends over general Netlink support to specific implementati= ons +of Netlink families.") (license license:bsd-3))) =20 (define-public ghc-doctest-driver-gen @@ -16033,21 +16133,22 @@ (define-public ghc-doctest-driver-gen (name "ghc-doctest-driver-gen") (version "0.3.0.4") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/doctest-driver-gen/d= octest-driver-gen-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/doctest-driver-gen/docte= st-driver-gen-" + version + ".tar.gz")) + (sha256 + (base32 "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; TODO: Fail to open shared library. (native-inputs `(("ghc-doctest" ,ghc-doctest))) =2D (home-page "https://github.com/Hexirp/doctest-driver-gen#readme") =2D (synopsis "Generate driver file for doctest's cabal integration") + (home-page "https://github.com/Hexirp/doctest-driver-gen") + (synopsis "Generate driver file for Doctest's Cabal integration") (description =2D "doctest-driver-gen is a doctest's driver file generator. It lets = you automatically generate driver file for doctest's cabal integration.") + "@code{ghc-doctest-driver-gen} is a Doctest's driver file generator. = It +lets you automatically generate driver file for Doctest's Cabal integratio= n.") (license license:bsd-3))) =20 (define-public ghc-template-haskell-compat-v0208 @@ -16055,20 +16156,20 @@ (define-public ghc-template-haskell-compat-v0208 (name "ghc-template-haskell-compat-v0208") (version "0.1.6") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/template-haskell-com= pat-v0208/template-haskell-compat-v0208-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/template-haskell-compat-= v0208/template-haskell-compat-v0208-" + version + ".tar.gz")) + (sha256 + (base32 "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8")))) (build-system haskell-build-system) =2D (home-page =2D "https://github.com/nikita-volkov/template-haskell-compat-v0208") =2D (synopsis =2D "A backwards compatibility layer for Template Haskell newer than 2= .8") =2D (description "") + (home-page "https://github.com/nikita-volkov/template-haskell-compat-v= 0208") + (synopsis "Backwards compatibility layer for Template Haskell newer th= an 2.8") + (description + "This package provides a backwards compatibility layer for Template +Haskell newer than 2.8.") (license license:expat))) =20 (define-public ghc-mysql @@ -16076,14 +16177,14 @@ (define-public ghc-mysql (name "ghc-mysql") (version "0.2.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/mysql/mysql-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "16m8hv9yy2nf4jwgqg6n9z53n2pzskbc3gwbp2i3kgff8wsmf8sd"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/mysql/mysql-" + version + ".tar.gz")) + (sha256 + (base32 "16m8hv9yy2nf4jwgqg6n9z53n2pzskbc3gwbp2i3kgff8wsmf8sd")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; TODO: Fails to connect to server. (inputs @@ -16092,9 +16193,16 @@ (define-public ghc-mysql ("openssl" ,openssl))) (native-inputs `(("ghc-hspec" ,ghc-hspec))) (home-page "https://github.com/paul-rouse/mysql") =2D (synopsis "A low-level MySQL client library.") + (synopsis "Low-level MySQL client library") (description =2D "A low-level client library for the MySQL database, implemented as= bindings to the C @mysqlclient@ API. . /Important licensing note/: This li= brary is BSD-licensed under the terms of the MySQL FOSS License Exception <= http://www.mysql.com/about/legal/licensing/foss-exception/>. . Since this l= ibrary links against the GPL-licensed @mysqlclient@ library, a non-open-sou= rce application that uses it /may/ be subject to the terms of the GPL.") + "This library provides Haskell bindings to the MySQL @code{mysqlclien= t} +client library. It is a fairly faithful, low level library that implements +most of the MySQL client API. The major departure from the C API is that = in +Haskell, resource management is mostly automatic and safe. + +This library deliberately avoids the question of providing a ``good'' API. +Its purpose is to serve as a base upon which higher-level libraries can be +built.") (license license:bsd-3))) =20 (define-public ghc-blaze-textual @@ -16102,28 +16210,29 @@ (define-public ghc-blaze-textual (name "ghc-blaze-textual") (version "0.2.2.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/blaze-textual/blaze-= textual-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0zjnwnjpcpnnm0815h9ngr3a3iy0szsnb3nrcavkbx4905s9k4bs"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/blaze-textual/blaze-text= ual-" + version + ".tar.gz")) + (sha256 + (base32 "0zjnwnjpcpnnm0815h9ngr3a3iy0szsnb3nrcavkbx4905s9k4bs")))) (build-system haskell-build-system) (inputs =2D `(("ghc-blaze-builder" ,ghc-blaze-builder) =2D ("ghc-old-locale" ,ghc-old-locale) =2D ("ghc-vector" ,ghc-vector))) + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-old-locale" ,ghc-old-locale) + ("ghc-vector" ,ghc-vector))) (native-inputs =2D `(("ghc-quickcheck" ,ghc-quickcheck) =2D ("ghc-double-conversion" ,ghc-double-conversion) =2D ("ghc-test-framework" ,ghc-test-framework) =2D ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck= 2))) =2D (home-page "http://github.com/bos/blaze-textual") + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-double-conversion" ,ghc-double-conversion) + ("ghc-test-framework" ,ghc-test-framework) + ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2))) + (home-page "https://github.com/bos/blaze-textual") (synopsis "Fast rendering of common datatypes") (description =2D "A library for efficiently rendering Haskell datatypes to bytestri= ngs. . /Note/: if you use GHCi or Template Haskell, please see the @README@= file for important details about building this package, and other packages= that depend on it: ") + "@code{ghc-blaze-textual} is a fast Haskell library for rendering com= mon +Haskell datatypes in text form using the @code{ghc-blaze-builder} library.= ") (license license:bsd-3))) =20 (define-public ghc-mysql-simple @@ -16131,31 +16240,32 @@ (define-public ghc-mysql-simple (name "ghc-mysql-simple") (version "0.4.6") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/mysql-simple/mysql-s= imple-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1am8ck092s9cv4x1ambalil4mlazkp8w5qhjbl4nq0j2hpy73rby"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/mysql-simple/mysql-simpl= e-" + version + ".tar.gz")) + (sha256 + (base32 "1am8ck092s9cv4x1ambalil4mlazkp8w5qhjbl4nq0j2hpy73rby")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; TODO: Fails to connect to server. (inputs =2D `(("ghc-attoparsec" ,ghc-attoparsec) =2D ("ghc-base16-bytestring" ,ghc-base16-bytestring) =2D ("ghc-blaze-builder" ,ghc-blaze-builder) =2D ("ghc-mysql" ,ghc-mysql) =2D ("ghc-pcre-light" ,ghc-pcre-light) =2D ("ghc-old-locale" ,ghc-old-locale) =2D ("ghc-blaze-textual" ,ghc-blaze-textual) =2D ("openssl" ,openssl) =2D ("zlib" ,zlib))) + `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-base16-bytestring" ,ghc-base16-bytestring) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-mysql" ,ghc-mysql) + ("ghc-pcre-light" ,ghc-pcre-light) + ("ghc-old-locale" ,ghc-old-locale) + ("ghc-blaze-textual" ,ghc-blaze-textual) + ("openssl" ,openssl) + ("zlib" ,zlib))) (native-inputs `(("ghc-hspec" ,ghc-hspec))) (home-page "https://github.com/paul-rouse/mysql-simple") =2D (synopsis "A mid-level MySQL client library.") + (synopsis "Mid-level MySQL client library") (description =2D "A mid-level client library for the MySQL database, intended to be= fast and easy to use. . /Important licensing note/: This library is BSD-li= censed under the terms of the MySQL FOSS License Exception . . Since this library links ag= ainst the GPL-licensed @mysqlclient@ library, a non-open-source application= that uses it /may/ be subject to the terms of the GPL.") + "This library implements mid-level Haskell bindings to the MySQL +@code{mysqlclient} client library. It is aimed at speed and ease of use.") (license license:bsd-3))) =20 (define-public ghc-persistent-qq @@ -16163,76 +16273,81 @@ (define-public ghc-persistent-qq (name "ghc-persistent-qq") (version "2.12.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/persistent-qq/persis= tent-qq-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1dvniapxjaw2vmdqd5cplwxdxiy2l6z6gns8gp3ci3rn3xp0pf6p"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/persistent-qq/persistent= -qq-" + version + ".tar.gz")) + (sha256 + (base32 "1dvniapxjaw2vmdqd5cplwxdxiy2l6z6gns8gp3ci3rn3xp0pf6p")))) (build-system haskell-build-system) (inputs =2D `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta) =2D ("ghc-persistent" ,ghc-persistent))) + `(("ghc-haskell-src-meta" ,ghc-haskell-src-meta) + ("ghc-persistent" ,ghc-persistent))) (native-inputs =2D `(("ghc-hunit" ,ghc-hunit) =2D ("ghc-aeson" ,ghc-aeson) =2D ("ghc-fast-logger" ,ghc-fast-logger) =2D ("ghc-hspec" ,ghc-hspec) =2D ("ghc-monad-logger" ,ghc-monad-logger) =2D ("ghc-persistent-sqlite" ,ghc-persistent-sqlite) =2D ("ghc-resourcet" ,ghc-resourcet) =2D ("ghc-unliftio" ,ghc-unliftio))) =2D (home-page "https://github.com/yesodweb/persistent#readme") =2D (synopsis "Provides a quasi-quoter for raw SQL for persistent") + `(("ghc-hunit" ,ghc-hunit) + ("ghc-aeson" ,ghc-aeson) + ("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-hspec" ,ghc-hspec) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-persistent-sqlite" ,ghc-persistent-sqlite) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-unliftio" ,ghc-unliftio))) + (home-page "https://github.com/yesodweb/persistent") + (synopsis "Quasi-quoter for raw SQL for @code{ghc-persistent}") (description =2D "Please see README and API docs at .") =2D (license license:expat))) + "This package provides a quasi-quoter for raw @acronym{SQL, Structure= d Query +Language} for @code{ghc-persistent}." + (license license:expat)))) =20 (define-public ghc-persistent-mysql (package (name "ghc-persistent-mysql") (version "2.13.0.2") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/persistent-mysql/per= sistent-mysql-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/persistent-mysql/persist= ent-mysql-" + version + ".tar.gz")) + (sha256 + (base32 "18ji7a7lb1mjgqvi2mv2cg4vlgjkyzg2hgp09s7c9v071p3ll732")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; TODO: Fails to import MaybeFieldDefsTest. (inputs =2D `(("ghc-persistent" ,ghc-persistent) =2D ("ghc-aeson" ,ghc-aeson) =2D ("ghc-blaze-builder" ,ghc-blaze-builder) =2D ("ghc-conduit" ,ghc-conduit) =2D ("ghc-monad-logger" ,ghc-monad-logger) =2D ("ghc-mysql" ,ghc-mysql) =2D ("ghc-mysql-simple" ,ghc-mysql-simple) =2D ("ghc-resourcet" ,ghc-resourcet) =2D ("ghc-resource-pool" ,ghc-resource-pool) =2D ("ghc-unliftio-core" ,ghc-unliftio-core) =2D ("openssl" ,openssl) =2D ("zlib" ,zlib))) + `(("ghc-persistent" ,ghc-persistent) + ("ghc-aeson" ,ghc-aeson) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-conduit" ,ghc-conduit) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-mysql" ,ghc-mysql) + ("ghc-mysql-simple" ,ghc-mysql-simple) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-resource-pool" ,ghc-resource-pool) + ("ghc-unliftio-core" ,ghc-unliftio-core) + ("openssl" ,openssl) + ("zlib" ,zlib))) (native-inputs =2D `(("ghc-fast-logger" ,ghc-fast-logger) =2D ("ghc-hspec" ,ghc-hspec) =2D ("ghc-http-api-data" ,ghc-http-api-data) =2D ("ghc-hunit" ,ghc-hunit) =2D ("ghc-path-pieces" ,ghc-path-pieces) =2D ("ghc-persistent-qq" ,ghc-persistent-qq) =2D ("ghc-persistent-test" ,ghc-persistent-test) =2D ("ghc-quickcheck" ,ghc-quickcheck) =2D ("ghc-quickcheck-instances" ,ghc-quickcheck-instances))) + `(("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-hspec" ,ghc-hspec) + ("ghc-http-api-data" ,ghc-http-api-data) + ("ghc-hunit" ,ghc-hunit) + ("ghc-path-pieces" ,ghc-path-pieces) + ("ghc-persistent-qq" ,ghc-persistent-qq) + ("ghc-persistent-test" ,ghc-persistent-test) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances))) (home-page "http://www.yesodweb.com/book/persistent") (synopsis =2D "Backend for the persistent library using MySQL database server.") + "Backend for the @code{ghc-persistent} library using MySQL database s= erver") (description =2D "This package contains a backend for persistent using the MySQL da= tabase server. Internally it uses the @mysql-simple@ and @mysql@ packages = in order to access the database. . This package supports only MySQL 5.1 and= above. However, it has been tested only on MySQL 5.5. Only the InnoDB sto= rage engine is officially supported. . Known problems: . * This package doe= s not support statements inside other statements.") + "This package contains a backend for @code{ghc-persistent} using the = MySQL database +server. Internally it uses the @code{ghc-mysql-simple} and @code{mysql} p= ackages in order +to access the database. This package supports only MySQL 5.1 and above. +However, it has been tested only on MySQL 5.5. Only the InnoDB storage en= gine +is officially supported.") (license license:expat))) =20 (define-public ghc-hspec-expectations-lifted @@ -16240,19 +16355,21 @@ (define-public ghc-hspec-expectations-lifted (name "ghc-hspec-expectations-lifted") (version "0.10.0") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/hspec-expectations-l= ifted/hspec-expectations-lifted-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0a1qwz0n80lph8m9cq6cb06m8bsmqgg8ifx0acpylvrrkd8g3k92"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/hspec-expectations-lifte= d/hspec-expectations-lifted-" + version + ".tar.gz")) + (sha256 + (base32 "0a1qwz0n80lph8m9cq6cb06m8bsmqgg8ifx0acpylvrrkd8g3k92")))) (build-system haskell-build-system) (inputs `(("ghc-hspec-expectations" ,ghc-hspec-expectations))) =2D (home-page "http://hackage.haskell.org/package/hspec-expectations-li= fted") =2D (synopsis "A version of hspec-expectations generalized to MonadIO") =2D (description "A version of hspec-expectations generalized to MonadIO= ") + (home-page "https://hackage.haskell.org/package/hspec-expectations-lif= ted") + (synopsis "Version of @code{ghc-hspec-expectations} generalized to @co= de{MonadIO}") + (description + "This package provides a version of @code{ghc-hspec-expectations} gen= eralized +to @code{MonadIO}.") (license license:expat))) =20 (define-public ghc-string-conversions @@ -16260,25 +16377,26 @@ (define-public ghc-string-conversions (name "ghc-string-conversions") (version "0.4.0.1") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/string-conversions/s= tring-conversions-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "150rdank90h7v08x0wq4dffjbxv2daf5v9sqfs5mab76kinwxg26"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/string-conversions/strin= g-conversions-" + version + ".tar.gz")) + (sha256 + (base32 "150rdank90h7v08x0wq4dffjbxv2daf5v9sqfs5mab76kinwxg26")))) (build-system haskell-build-system) (inputs `(("ghc-utf8-string" ,ghc-utf8-string))) (native-inputs =2D `(("hspec-discover" ,hspec-discover) =2D ("ghc-hspec" ,ghc-hspec) =2D ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) =2D ("ghc-quickcheck" ,ghc-quickcheck))) =2D (home-page "https://github.com/soenkehahn/string-conversions#readme") =2D (synopsis "Simplifies dealing with different types for strings") + `(("hspec-discover" ,hspec-discover) + ("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://github.com/soenkehahn/string-conversions") + (synopsis "Simplify dealing with different types for strings") (description =2D "Provides a simple type class for converting values of different s= tring types into values of other string types.") + "This package provides a simple type class for converting values of d= ifferent +string types into values of other string types.") (license license:bsd-3))) =20 (define-public ghc-postgresql-libpq @@ -16286,23 +16404,26 @@ (define-public ghc-postgresql-libpq (name "ghc-postgresql-libpq") (version "0.9.4.3") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/postgresql-libpq/pos= tgresql-libpq-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "1gfnhc5pibn7zmifdf2g0c112xrpzsk756ln2kjzqljkspf4dqp3"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/postgresql-libpq/postgre= sql-libpq-" + version + ".tar.gz")) + (sha256 + (base32 "1gfnhc5pibn7zmifdf2g0c112xrpzsk756ln2kjzqljkspf4dqp3")))) (build-system haskell-build-system) (arguments =2D `(#:cabal-revision =2D ("1" "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2"))) + `(#:cabal-revision + ("1" "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2"))) (inputs `(("postgresql" ,postgresql))) (home-page "https://github.com/haskellari/postgresql-libpq") =2D (synopsis "low-level binding to libpq") + (synopsis "Low-level bindings to @code{libpq}") (description =2D "This is a binding to libpq: the C application programmer's interf= ace to PostgreSQL. libpq is a set of library functions that allow client pr= ograms to pass queries to the PostgreSQL backend server and to receive the = results of these queries.") + "This package provides bindings to @code{libpq}: the C application +programmer's interface to PostgreSQL. @code{libpq} is a set of library +functions that allow client programs to pass queries to the PostgreSQL bac= kend +server and to receive the results of these queries.") (license license:bsd-3))) =20 (define-public ghc-postgresql-simple @@ -16310,44 +16431,45 @@ (define-public ghc-postgresql-simple (name "ghc-postgresql-simple") (version "0.6.4") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/postgresql-simple/po= stgresql-simple-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d"= )))) =2D (build-system haskell-build-system) =2D (inputs =2D `(("ghc-time-compat" ,ghc-time-compat) =2D ("ghc-aeson" ,ghc-aeson) =2D ("ghc-attoparsec" ,ghc-attoparsec) =2D ("ghc-bytestring-builder" ,ghc-bytestring-builder) =2D ("ghc-case-insensitive" ,ghc-case-insensitive) =2D ("ghc-hashable" ,ghc-hashable) =2D ("ghc-only" ,ghc-only) =2D ("ghc-postgresql-libpq" ,ghc-postgresql-libpq) =2D ("ghc-scientific" ,ghc-scientific) =2D ("ghc-uuid-types" ,ghc-uuid-types) =2D ("ghc-vector" ,ghc-vector))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/postgresql-simple/postgr= esql-simple-" + version + ".tar.gz")) + (sha256 + (base32 "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d")))) + (build-system haskell-build-system) + (inputs + `(("ghc-time-compat" ,ghc-time-compat) + ("ghc-aeson" ,ghc-aeson) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-bytestring-builder" ,ghc-bytestring-builder) + ("ghc-case-insensitive" ,ghc-case-insensitive) + ("ghc-hashable" ,ghc-hashable) + ("ghc-only" ,ghc-only) + ("ghc-postgresql-libpq" ,ghc-postgresql-libpq) + ("ghc-scientific" ,ghc-scientific) + ("ghc-uuid-types" ,ghc-uuid-types) + ("ghc-vector" ,ghc-vector))) (native-inputs =2D `(("ghc-inspection-testing" ,ghc-inspection-testing) =2D ("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-hunit" ,ghc-tasty-hunit) =2D ("ghc-base16-bytestring" ,ghc-base16-bytestring) =2D ("ghc-cryptohash-md5" ,ghc-cryptohash-md5) =2D ("ghc-hunit" ,ghc-hunit) =2D ("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-golden" ,ghc-tasty-golden) =2D ("ghc-tasty-hunit" ,ghc-tasty-hunit))) + `(("ghc-inspection-testing" ,ghc-inspection-testing) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-base16-bytestring" ,ghc-base16-bytestring) + ("ghc-cryptohash-md5" ,ghc-cryptohash-md5) + ("ghc-hunit" ,ghc-hunit) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-golden" ,ghc-tasty-golden) + ("ghc-tasty-hunit" ,ghc-tasty-hunit))) (arguments =2D `(#:cabal-revision =2D ("2" "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv"))) + `(#:cabal-revision + ("2" "1kwjlj0bsc1yd4dgfc0ydawq9acfjlf0bymwc830dryp16wpj9zv"))) (home-page "http://hackage.haskell.org/package/postgresql-simple") (synopsis "Mid-Level PostgreSQL client library") (description =2D "Mid-Level PostgreSQL client library, forked from mysql-simple.") + "This package provides a mid-Level PostgreSQL client library, forked = from +@code{ghc-mysql-simple}.") (license license:bsd-3))) =20 (define-public ghc-persistent-postgresql @@ -16355,47 +16477,49 @@ (define-public ghc-persistent-postgresql (name "ghc-persistent-postgresql") (version "2.13.1.0") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/persistent-postgresq= l/persistent-postgresql-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "05bj3b7kdwaba3szrrsmafxr6vcnvdhq20jk5xx348jnf2flkw0i"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/persistent-postgresql/pe= rsistent-postgresql-" + version + ".tar.gz")) + (sha256 + (base32 "05bj3b7kdwaba3szrrsmafxr6vcnvdhq20jk5xx348jnf2flkw0i")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; TODO: Cannot import MaybeFieldDefsTest. (inputs =2D `(("ghc-persistent" ,ghc-persistent) =2D ("ghc-aeson" ,ghc-aeson) =2D ("ghc-attoparsec" ,ghc-attoparsec) =2D ("ghc-blaze-builder" ,ghc-blaze-builder) =2D ("ghc-conduit" ,ghc-conduit) =2D ("ghc-monad-logger" ,ghc-monad-logger) =2D ("ghc-postgresql-simple" ,ghc-postgresql-simple) =2D ("ghc-postgresql-libpq" ,ghc-postgresql-libpq) =2D ("ghc-resourcet" ,ghc-resourcet) =2D ("ghc-resource-pool" ,ghc-resource-pool) =2D ("ghc-string-conversions" ,ghc-string-conversions) =2D ("ghc-unliftio-core" ,ghc-unliftio-core) =2D ("ghc-unliftio" ,ghc-unliftio))) + `(("ghc-persistent" ,ghc-persistent) + ("ghc-aeson" ,ghc-aeson) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-conduit" ,ghc-conduit) + ("ghc-monad-logger" ,ghc-monad-logger) + ("ghc-postgresql-simple" ,ghc-postgresql-simple) + ("ghc-postgresql-libpq" ,ghc-postgresql-libpq) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-resource-pool" ,ghc-resource-pool) + ("ghc-string-conversions" ,ghc-string-conversions) + ("ghc-unliftio-core" ,ghc-unliftio-core) + ("ghc-unliftio" ,ghc-unliftio))) (native-inputs =2D `(("ghc-persistent-qq" ,ghc-persistent-qq) =2D ("ghc-persistent-test" ,ghc-persistent-test) =2D ("ghc-fast-logger" ,ghc-fast-logger) =2D ("ghc-hunit" ,ghc-hunit) =2D ("ghc-hspec" ,ghc-hspec) =2D ("ghc-hspec-expectations" ,ghc-hspec-expectations) =2D ("ghc-hspec-expectations-lifted" ,ghc-hspec-expectations-lifted) =2D ("ghc-quickcheck" ,ghc-quickcheck) =2D ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) =2D ("ghc-path-pieces" ,ghc-path-pieces) =2D ("ghc-http-api-data" ,ghc-http-api-data) =2D ("ghc-unordered-containers" ,ghc-unordered-containers) =2D ("ghc-vector" ,ghc-vector))) + `(("ghc-persistent-qq" ,ghc-persistent-qq) + ("ghc-persistent-test" ,ghc-persistent-test) + ("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-hunit" ,ghc-hunit) + ("ghc-hspec" ,ghc-hspec) + ("ghc-hspec-expectations" ,ghc-hspec-expectations) + ("ghc-hspec-expectations-lifted" ,ghc-hspec-expectations-lifted) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-quickcheck-instances" ,ghc-quickcheck-instances) + ("ghc-path-pieces" ,ghc-path-pieces) + ("ghc-http-api-data" ,ghc-http-api-data) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-vector" ,ghc-vector))) (home-page "http://www.yesodweb.com/book/persistent") =2D (synopsis "Backend for the persistent library using postgresql.") =2D (description "Based on the postgresql-simple package") + (synopsis "Backend for the @code{ghc-persistent library} using Postgre= sql") + (description + "This package provides a backend for the @code{ghc-persistent} library +using the @code{ghc-postgresql-simple} package.") (license license:expat))) =20 (define-public ghc-filtrable @@ -16403,23 +16527,23 @@ (define-public ghc-filtrable (name "ghc-filtrable") (version "0.1.6.0") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/filtrable/filtrable-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "058jl7wjaxzvcayc9qzpikxvi9x42civ4sb02jh66rcvpndbfh5y"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/filtrable/filtrable-" + version + ".tar.gz")) + (sha256 + (base32 "058jl7wjaxzvcayc9qzpikxvi9x42civ4sb02jh66rcvpndbfh5y")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; TODO: Needs tasty >=3D1.3.1 && <1.4 (native-inputs =2D `(("ghc-smallcheck" ,ghc-smallcheck) =2D ("ghc-tasty" ,ghc-tasty) =2D ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck))) + `(("ghc-smallcheck" ,ghc-smallcheck) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck))) (home-page "https://github.com/strake/filtrable.hs") (synopsis "Class of filtrable containers") =2D (description "See \"Data.Filtrable\".") + (description "This package provides filtrable containers.") (license license:bsd-3))) =20 (define-public ghc-filelock @@ -16427,20 +16551,22 @@ (define-public ghc-filelock (name "ghc-filelock") (version "0.1.1.5") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/filelock/filelock-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "06a44i7a956d7xkk2na4090xj2a7b7a228pk4spmccs4x20ymssh"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/filelock/filelock-" + version + ".tar.gz")) + (sha256 + (base32 "06a44i7a956d7xkk2na4090xj2a7b7a228pk4spmccs4x20ymssh")))) (build-system haskell-build-system) =2D (native-inputs `(("ghc-async" ,ghc-async) ("ghc-async" ,ghc-async))) =2D (home-page "http://github.com/takano-akio/filelock") =2D (synopsis "Portable interface to file locking (flock / LockFileEx)") + (native-inputs + `(("ghc-async" ,ghc-async) + ("ghc-async" ,ghc-async))) + (home-page "https://github.com/takano-akio/filelock") + (synopsis "Portable interface to file locking") (description =2D "This package provides an interface to Windows and Unix file locki= ng functionalities.") + "This package provides an interface to file locking functionalities.") (license license:public-domain))) =20 (define-public ghc-hsyaml-aeson @@ -16466,11 +16592,20 @@ (define-public ghc-hsyaml-aeson (arguments `(#:cabal-revision ("3" "0vhdndyj5f07vvvnssn5ybdja5wmaydq0n2lfpihvdg4dkhczrx2"))) =2D (home-page "http://hackage.haskell.org/package/HsYAML-aeson") =2D (synopsis "JSON to YAML Adapter") =2D (description =2D "The [YAML 1.2](https://yaml.org/spec/1.2/spec.html) format provide= s a much richer data-model and feature-set than the [JavaScript Object Nota= tion (JSON)](https://tools.ietf.org/html/rfc7159) format. However, sometime= s it's desirable to ignore the extra capabilities and treat YAML as if it w= as merely a more convenient markup format for humans to write JSON data. To= this end this module provides a compatibility layer atop [HsYAML](https://= hackage.haskell.org/package/HsYAML) which allows decoding YAML documents in= the more limited JSON data-model while also providing convenience by reusi= ng [aeson](https://hackage.haskell.org/package/aeson)'s 'FromJSON' instance= s for decoding the YAML data into native Haskell data types.") =2D (license #f))) + (home-page "https://hackage.haskell.org/package/HsYAML-aeson") + (synopsis "JSON to YAML adapter") + (description + "The @uref{https://yaml.org/spec/1.2/spec.html, YAML 1.2} format prov= ides +a much richer data-model and feature-set than the +@uref{https://tools.ietf.org/html/rfc7159, @acronym{JavaScript Object +Notation, JSON} format. However, sometimes it's desirable to ignore the e= xtra +capabilities and treat YAML as if it was merely a more convenient markup +format for humans to write JSON data. To this end this module provides a +compatibility layer atop @code{ghc-hsyaml} ,which allows decoding YAML +documents in the more limited JSON data-model while also providing conveni= ence +by reusing @code{ghc-aeson}'s @code{FromJSON instances for decoding the YA= ML +data into native Haskell data types.") + (license license:gpl2+))) =20 (define-public ghc-lukko (package @@ -16496,10 +16631,21 @@ (define-public ghc-lukko (arguments `(#:cabal-revision ("1" "0mmq1q82mrbayiij0p8wdnkf0j8drmq1iibg8kn4cak3nrn9pd1d"))) =2D (home-page "http://hackage.haskell.org/package/lukko") + (home-page "https://hackage.haskell.org/package/lukko") (synopsis "File locking") (description =2D "This package provides access to platform dependent file locking AP= Is: . * on Linux (\"Lukko.OFD\") * = BSD-style @flock(2)@ locks on UNIX platforms (\"Lukko.FLock\") * Windows lo= cking via (\"Lukko.Windows\") * No-op locking, which thro= ws exceptions (\"Lukko.NoOp\") * \"Lukko\" module exports the best option f= or the target platform with uniform API. . There are alternative file locki= ng packages: . * \"GHC.IO.Handle.Lock\" in @base >=3D 4.10@ is good enough = for most use cases. However, uses only 'Handle's so these locks cannot be u= sed for intra-process locking. (You should use e.g. 'MVar' in addition). . = * doesn't support O= FD locking. . /Lukko/ means lock in Finnish. . Submodules \"Lukko.OFD\", \"= Lukko.Windows\" etc are available based on following conditions. . @ if os(= windows) \\ cpp-options: -DHAS_WINDOWS_LOCK . elif (os(linux) && flag(ofd-= locking)) \\ cpp-options: -DHAS_OFD_LOCKING \\ cpp-options: -DHAS_FLOCK .= elif !(os(solaris) || os(aix)) \\ cpp-options: -DHAS_FLOCK @ . \"Lukko.FL= ock\" is available on not (Windows or Solaris or AIX). \"Lukko.NoOp\" is al= ways available.") + "This package provides access to platform dependent file locking APIs= . There +are alternative file locking packages: + +@itemize +@item @code{GHC.IO.Handle.Lock} in @codebase >=3D 4.10} is good enough for= most +use cases. However, uses only @code{Handle}s so these locks cannot be used +for intra-process locking. + +@item @code{ghc-filelock} doesn't support @acronym{OFD, open file descript= or} +locking. +@end itemize") + (license (list license:gpl2+ license:bsd-3)))) =20 (define-public ghc-dec @@ -16507,19 +16653,28 @@ (define-public ghc-dec (name "ghc-dec") (version "0.0.4") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/dec/dec-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/dec/dec-" + version + ".tar.gz")) + (sha256 + (base32 "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc")))) (build-system haskell-build-system) (home-page "https://github.com/phadej/vec") =2D (synopsis "Decidable propositions.") + (synopsis "Decidable propositions") (description =2D "This package provides a @Dec@ type. . @ type Neg a =3D a -> Void = . data Dec a \\ =3D Yes a \\ | No (Neg a) @") + "This package provides a @code{Dec} type for representing deciable +relations. + +@example +type Neg a =3D a -> Void + +data Dec a + =3D Yes a + | No (Neg a) +@end example") (license license:bsd-3))) =20 (define-public ghc-singleton-bool @@ -16527,22 +16682,22 @@ (define-public ghc-singleton-bool (name "ghc-singleton-bool") (version "0.1.5") (source =2D (origin =2D (method url-fetch) =2D (uri (string-append =2D "https://hackage.haskell.org/package/singleton-bool/singl= eton-bool-" =2D version =2D ".tar.gz")) =2D (sha256 =2D (base32 "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0"= )))) + (origin + (method url-fetch) + (uri (string-append + "https://hackage.haskell.org/package/singleton-bool/singleton= -bool-" + version + ".tar.gz")) + (sha256 + (base32 "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0")))) (build-system haskell-build-system) (inputs `(("ghc-dec" ,ghc-dec))) (arguments =2D `(#:cabal-revision =2D ("3" "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x"))) =2D (home-page "https://github.com/phadej/singleton-bool#readme") =2D (synopsis "Type level booleans") + `(#:cabal-revision + ("3" "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x"))) + (home-page "https://github.com/phadej/singleton-bool") + (synopsis "Type-level booleans") (description =2D "Type level booleans. . @singletons@ package provides similar func= tionality, but it has tight dependency constraints.") + "This package provides Type-level booleans.") (license license:bsd-3))) =20 diff --git a/gnu/packages/purescript.scm b/gnu/packages/purescript.scm index 1b24458a8c..ba8cbcd926 100644 =2D-- a/gnu/packages/purescript.scm +++ b/gnu/packages/purescript.scm @@ -160,9 +160,10 @@ (define-public ghc-purescript-cst ("ghc-serialise" ,ghc-serialise) ("ghc-vector" ,ghc-vector))) (native-inputs `(("ghc-happy" ,ghc-happy))) =2D (home-page "http://www.purescript.org/") + (home-page "https://www.purescript.org/") (synopsis "PureScript Programming Language Concrete Syntax Tree") =2D (description "The parser for the PureScript programming language.") + (description + "This package implements parser for the PureScript programming langua= ge.") (license license:bsd-3))) =20 (define-public ghc-optparse-applicative-0.15.1.0 base-commit: c1522b280137df2f670f47fa1e682e610406bb39 =2D-=20 2.33.0 --=-=-=-- --==-=-= Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iQJJBAEBCAAzFiEEAVhh4yyK5+SEykIzrPUJmaL7XHkFAmFXRFIVHHB1YmxpY0B5 b2N0b2NlbGwueHl6AAoJEKz1CZmi+1x5DgkP/iO5DoKPALrP1PbeGt2A0dWcs3uL lIFJh+bicEE5DLA3mnlYdCqeXANPFgr5LiHx6eCTSOC6ey8MLHBMIqZm7BMCDfDS D+Lbjaj2Jry52Wje9R1LApUjzb5u8L9T5W+v+Z+sGK1meVrcO5IU1Pec2W0i22Kl 6DWS8zTQr4HFen1QK04cBXzH0egyF8Aoh0daYgp5bhZsGss1uiPIROqb645rcZi6 eTBOgbao7Tum77sT0338UaAMiRx6XJ0rF1Y1AhQ4cMpnlBh3rr8q+VqMUsPdj21O OlQmCxZYHfncwthoUSnbDzAAyhgEaSbteU5kfAlwayiUIgu1mS6hiQnciUxm2IbK w1+20hTaR7I1fUbs2YBRe6XZzR5AFRG8xQDoKK5XGPmjTqoeXs/TixILtCQSp2uA PBXvI0UZ/9pl7FYRnmw/6xNZs+V14VQ6kav3GJDqeoBBIktwCXzSeZcsNxaImk9t w/B8ul02VxNuj0Uzjowxj/Sx6+GL0/RKH3dydsLzqFIBAUQOOVyNmJzK9pE3Cd+K dglXuQ0g/VrgQ9U/oNyyVN7Yin+FdRBB6bbF7har6cd9QfN14lcHt9zmpGAMdKLl 3W6qaqMmAfnqAmZarPTdV9p+8dKdgvY2EcXGItB+uoaMrywaK3SQCsMZPVLm6sYL 8DHESDvvL+wJM00y =zYzc -----END PGP SIGNATURE----- --==-=-=--