[PATCH 0/8] Add ghc-brittany and dependencies

  • Open
  • quality assurance status badge
Details
One participant
  • Xinglu Chen
Owner
unassigned
Submitted by
Xinglu Chen
Severity
normal
X
X
Xinglu Chen wrote on 3 Jun 2021 17:55
(address . guix-patches@gnu.org)
cover.1622735640.git.public@yoctocell.xyz
This patch series adds the Brittany code formatter for Haskell.

Xinglu Chen (8):
gnu: Add ghc-strict-list.
gnu: Add ghc-neat-interpolation.
gnu: Add ghc-multistate.
gnu: Add ghc-monad-memo.
gnu: Add ghc-deque.
gnu: Add ghc-data-tree-print.
gnu: Add ghc-czipwith.
gnu: Add ghc-brittany.

gnu/packages/haskell-xyz.scm | 355 +++++++++++++++++++++++++++++++++++
1 file changed, 355 insertions(+)


base-commit: cf6be24529960c50706c6b4164193ed6c1dd5bc2
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 1/8] gnu: Add ghc-strict-list.
(address . 48813@debbugs.gnu.org)
c96b9c0b1972d1d8a3492f69b70c13dbf0c1243f.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-strict-list): New variable.
---
gnu/packages/haskell-xyz.scm | 34 ++++++++++++++++++++++++++++++++++
1 file changed, 34 insertions(+)

Toggle diff (54 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 1fa7310fab..f0054948f6 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -28,6 +28,7 @@
;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
;;; Copyright © 2020 Carlo Holl <carloholl@gmail.com>
;;; Copyright © 2020 Christopher Lemmer Webber <cwebber@dustycloud.org>
+;;; Copyright © 2021 Xinglu Chen <public@yoctocell.xyz>
;;;
;;; This file is part of GNU Guix.
;;;
@@ -12802,6 +12803,39 @@ types, such as pairs, @code{Maybe} and @code{Either}. It also contains strict
IO operations.")
(license license:bsd-3)))
+(define-public ghc-strict-list
+ (package
+ (name "ghc-strict-list")
+ (version "0.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/strict-list/strict-list-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "06mv208bspfl2mh1razi6af3fri8w7f5p3klkc3b9yx5ddv3hwxs"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-semigroupoids" ,ghc-semigroupoids)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances"
+ ,ghc-quickcheck-instances)
+ ("ghc-rerebase" ,ghc-rerebase)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page
+ "https://github.com/nikita-volkov/strict-list")
+ (synopsis "Strict linked list")
+ (description "This package provides an implementation of strict linked
+list with care taken about stack.")
+ (license license:expat)))
+
(define-public ghc-stringbuilder
(package
(name "ghc-stringbuilder")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 2/8] gnu: Add ghc-neat-interpolation.
(address . 48813@debbugs.gnu.org)
f68356db9f9ec536da3e3748e12c8b9c773f0b00.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-neat-interpolation): New variable.
---
gnu/packages/haskell-xyz.scm | 32 ++++++++++++++++++++++++++++++++
1 file changed, 32 insertions(+)

Toggle diff (45 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index f0054948f6..98093216ee 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -8514,6 +8514,38 @@ with pseudo-graphical interfaces. This package is a nice, modern binding to GNU
ncurses.")
(license license:gpl3)))
+(define-public ghc-neat-interpolation
+ (package
+ (name "ghc-neat-interpolation")
+ (version "0.3.2.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/neat-interpolation/neat-interpolation-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "10k5x47i84nycl54p61l8v1bpvi7mw663vnj8nn1qjpn03anz8z2"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-megaparsec" ,ghc-megaparsec)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances"
+ ,ghc-quickcheck-instances)
+ ("ghc-rerebase" ,ghc-rerebase)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "https://github.com/nikita-volkov/neat-interpolation")
+ (synopsis "Quasiquoter for neat and simple multiline text interpolation")
+ (description "This package provides a quasiquoter for producing Text
+values with support for a simple interpolation of input values. It removes the
+excessive indentation from the input and accurately manages the indentation of
+all lines of the interpolated variables.")
+ (license license:expat)))
+
(define-public ghc-network
(package
(name "ghc-network")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 3/8] gnu: Add ghc-multistate.
(address . 48813@debbugs.gnu.org)
04d86d2998b9bd069e6e9974276838fbdcafac0b.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-multistate): New variable.
---
gnu/packages/haskell-xyz.scm | 31 +++++++++++++++++++++++++++++++
1 file changed, 31 insertions(+)

Toggle diff (44 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 98093216ee..405fe63a74 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -8384,6 +8384,37 @@ Therefore, you may have to declare @code{import Control.Monad.Except ()} at
the top of your file to get all of the ExceptT instances in scope.")
(license license:bsd-3)))
+(define-public ghc-multistate
+ (package
+ (name "ghc-multistate")
+ (version "0.8.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/multistate/multistate-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0hypksjacpjgpkgvjn76fd5rgdz7hi6ri36ihdy0bdhpi83jnhn5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-tagged" ,ghc-tagged)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-monad-control" ,ghc-monad-control)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/lspitzner/multistate")
+ (synopsis "Similar to mtl's ReaderT/WriterT/StateT, but more than one
+contained value/type.")
+ (description "When using multiple Read/Write/State transformers in the
+same monad stack, it becomes necessary to lift the operations in order to
+affect a specific transformer. Using heterogeneous lists (and all kinds of
+GHC extensions magic), this package provides transformers that remove that
+necessity: MultiReaderT/MultiWriterT/MultiStateT/MultiRWST can contain a
+heterogeneous list of values.")
+ (license license:bsd-3)))
+
(define-public ghc-murmur-hash
(package
(name "ghc-murmur-hash")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 4/8] gnu: Add ghc-monad-memo.
(address . 48813@debbugs.gnu.org)
1875aef1c39a0771c245148afdb9a6dec99f32fa.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-monad-memo): New variable.
---
gnu/packages/haskell-xyz.scm | 34 ++++++++++++++++++++++++++++++++++
1 file changed, 34 insertions(+)

Toggle diff (47 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 405fe63a74..a77d13f822 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -8158,6 +8158,40 @@ code locations of messages.")
operators for looping.")
(license license:public-domain)))
+(define-public ghc-monad-memo
+ (package
+ (name "ghc-monad-memo")
+ (version "0.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/monad-memo/monad-memo-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1zsvp0g2kzjf5zkv1js65jfc1p3yrkr95csp2ljpqx857qy4lnn6"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-vector" ,ghc-vector)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-transformers-compat"
+ ,ghc-transformers-compat)))
+ (native-inputs
+ `(("ghc-random" ,ghc-random)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework-quickcheck2"
+ ,ghc-test-framework-quickcheck2)
+ ("ghc-test-framework" ,ghc-test-framework)))
+ (home-page
+ "https://github.com/EduardSergeev/monad-memo")
+ (synopsis "Memoization monad transformer")
+ (description "This package provides a memoization monad transformer
+supporting most of the standard monad transformers and a range of memoization
+cache types: from default pure maps to extremely fast mutable vectors.")
+ (license license:bsd-3)))
+
(define-public ghc-monad-par
(package
(name "ghc-monad-par")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 5/8] gnu: Add ghc-deque.
(address . 48813@debbugs.gnu.org)
5a0fa813220d54ec7f6d937f1c31b3eb71e1d18b.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-deque): New variable.
---
gnu/packages/haskell-xyz.scm | 34 ++++++++++++++++++++++++++++++++++
1 file changed, 34 insertions(+)

Toggle diff (47 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index a77d13f822..c2c6432adb 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -3214,6 +3214,40 @@ providing an @code{rnf} implementation.")
related modules split from the statistics library.")
(license license:bsd-2)))
+(define-public ghc-deque
+ (package
+ (name "ghc-deque")
+ (version "0.4.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/deque/deque-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "19apwmcykprz3a91wszmc1w3qcz4x3rq79gmik514fszi9yhwsmp"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hashable" ,ghc-hashable)
+ ("ghc-strict-list" ,ghc-strict-list)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances"
+ ,ghc-quickcheck-instances)
+ ("ghc-rerebase" ,ghc-rerebase)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page
+ "https://github.com/nikita-volkov/deque")
+ (synopsis "Double-ended queues")
+ (description
+ "This package provides strict and lazy implementations of Double-Ended
+Queue (aka Dequeue or Deque) based on head-tail linked list.")
+ (license license:expat)))
+
(define-public ghc-descriptive
(package
(name "ghc-descriptive")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 6/8] gnu: Add ghc-data-tree-print.
(address . 48813@debbugs.gnu.org)
5ef92e1aae4954fdf8180d17a434d0fca50e0eb0.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-data-tree-print): New variable.
---
gnu/packages/haskell-xyz.scm | 39 ++++++++++++++++++++++++++++++++++++
1 file changed, 39 insertions(+)

Toggle diff (52 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index c2c6432adb..67ffdf0055 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -3078,6 +3078,45 @@ It includes hashing functions for all basic Haskell98 types.")
"This module provides set and multiset operations on ordered lists.")
(license license:bsd-3)))
+(define-public ghc-data-tree-print
+ (package
+ (name "ghc-data-tree-print")
+ (version "0.1.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/data-tree-print/data-tree-print-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "00jh37anim8qsn553467gmfhajcz1c61zrgh1ypkqsll0gc29vy3"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-syb" ,ghc-syb)))
+ (arguments
+ `(#:cabal-revision
+ ("2"
+ "00qpzhm3lndhpql8aj93aj6r3x9n0gw3nx6n0q60xxrd6agyjifq")))
+ (home-page "https://github.com/lspitzner/data-tree-print")
+ (synopsis "Print Data instances as a nested tree")
+ (description "This package provides functionality similar to that of the
+@code{Show} class: Taking some arbitrary value and returning a String.
+
+@itemize
+@item
+Output is not intended to be valid haskell.
+@item
+Requires a @code{Data.Data.Data} instance instead of a @code{Text.Show} one.
+@item
+Output, if large, is often easier to parse than @code{show} output due to the
+formatting as a nested tree.
+@item
+The user can adapt the behaviour at runtime using custom layouting expressed
+via syb-style extension.
+@end itemize")
+ (license license:bsd-3)))
+
(define-public ghc-dbus
(package
(name "ghc-dbus")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 7/8] gnu: Add ghc-czipwith.
(address . 48813@debbugs.gnu.org)
34abb29662774a61239f01a7ae4804c3042e5eb0.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-czipwith): New variable.
---
gnu/packages/haskell-xyz.scm | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)

Toggle diff (38 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 67ffdf0055..446e60477b 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -2829,6 +2829,31 @@ Values (CSV) Files}. This format is used, among many other things, as a
lingua franca for spreadsheets, and for certain web services.")
(license license:expat)))
+(define-public ghc-czipwith
+ (package
+ (name "ghc-czipwith")
+ (version "1.0.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/czipwith/czipwith-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "17zf2blgjp47dahjcprkpymg9kb1ll6386pkr109gjr78f261gs1"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/lspitzner/czipwith/")
+ (synopsis "CZipWith class and deriving via TH")
+ (description "This package provides a typeclass similar to
+@code{Data.Distributive}, but for data parameterised with a type constructor.
+The name comes from the resemblance of its method to the regular
+@code{zipWith} function. The abstraction is useful for example for program
+config handling.")
+ (license license:bsd-3)))
+
(define-public ghc-data-accessor
(package
(name "ghc-data-accessor")
--
2.31.1
X
X
Xinglu Chen wrote on 3 Jun 2021 17:58
[PATCH 8/8] gnu: Add ghc-brittany.
(address . 48813@debbugs.gnu.org)
49eb8fd90d7b7d285b0d9f6b2d7e99c8a6628570.1622735640.git.public@yoctocell.xyz
* gnu/packages/haskell-xyz.scm (ghc-brittany): New variable.
---
gnu/packages/haskell-xyz.scm | 126 +++++++++++++++++++++++++++++++++++
1 file changed, 126 insertions(+)

Toggle diff (139 lines)
diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm
index 446e60477b..ee54a65332 100644
--- a/gnu/packages/haskell-xyz.scm
+++ b/gnu/packages/haskell-xyz.scm
@@ -1211,6 +1211,132 @@ interface.")
using a simple box model.")
(license license:bsd-3)))
+(define-public ghc-brittany
+ (package
+ (name "ghc-brittany")
+ (version "0.12.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/brittany/brittany-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0nw7ymdb7xam634w42l1xjgyvpla8grcg02aj19fscw2fn9gfh7z"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-paths" ,ghc-paths)
+ ("ghc-exactprint" ,ghc-exactprint)
+ ("ghc-multistate" ,ghc-multistate)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-neat-interpolation"
+ ,ghc-neat-interpolation)
+ ("ghc-data-tree-print" ,ghc-data-tree-print)
+ ("ghc-butcher" ,ghc-butcher)
+ ("ghc-yaml" ,ghc-yaml)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-extra" ,ghc-extra)
+ ("ghc-uniplate" ,ghc-uniplate)
+ ("ghc-strict" ,ghc-strict)
+ ("ghc-monad-memo" ,ghc-monad-memo)
+ ("ghc-unsafe" ,ghc-unsafe)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-cmdargs" ,ghc-cmdargs)
+ ("ghc-czipwith" ,ghc-czipwith)
+ ("ghc-random" ,ghc-random)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec" ,ghc-hspec)))
+ (arguments
+ `(#:cabal-revision
+ ("2"
+ "0pfrm5vvh7x94f8gy8ka6rmq6yk6xxxgba68rd91bk8lbjxsmkxl")))
+ (home-page "https://github.com/lspitzner/brittany/")
+ (synopsis "Haskell source code formatter")
+ (description "Brittany is a Haskell source code formatter. The goal of
+this project is to:
+
+@itemize
+@item
+Always retain the semantics of the source being transformed;
+@item
+Be idempotent;
+@item
+Support the full GHC-haskell syntax including syntactic extensions (but
+excluding -XCPP which is too hard);
+@item
+Retain newlines and comments unmodified;
+@item
+Be clever about using the available horizontal space while not overflowing the
+column maximum unless it cannot be avoided;
+@item
+Be clever about aligning things horizontally (this can be turned off
+completely however);
+@item
+Have linear complexity in the size of the input.
+@end itemize")
+ (license license:agpl3)))
+
+(define-public ghc-butcher
+ (package
+ (name "ghc-butcher")
+ (version "1.3.2.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/butcher/butcher-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0lpicayq9k59m2ydz989xsypr653xwhp6mmhlp7nmjzk6jwpq5q5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-free" ,ghc-free)
+ ("ghc-unsafe" ,ghc-unsafe)
+ ("ghc-microlens" ,ghc-microlens)
+ ("ghc-microlens-th" ,ghc-microlens-th)
+ ("ghc-multistate" ,ghc-multistate)
+ ("ghc-extra" ,ghc-extra)
+ ("ghc-void" ,ghc-void)
+ ("ghc-bifunctors" ,ghc-bifunctors)
+ ("ghc-deque" ,ghc-deque)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)))
+ (arguments
+ `(#:cabal-revision
+ ("2"
+ "1751sllw8s81x3s1dhilbr5lqnv9cpdqiv17c8by466aa6304dxa")))
+ (home-page "https://github.com/lspitzner/butcher/")
+ (synopsis "Chops a command or program invocation into digestable pieces.")
+ (description "This package is similar to the optparse-applicative package,
+but less features, more flexibility and more evil.
+
+The main differences are:
+
+@itemize
+@item Provides a pure interface by default
+
+@item Exposes an evil monadic interface, which allows for much nicer binding
+of command part results to some variable name.
+
+In optparse-applicative you easily lose track of what field you are modifying
+after the 5th <*> (admittedly, i think -XRecordWildCards improves on that
+issue already.)
+
+Evil, because you are not allowed to use the monad's full power in this case,
+i.e. there is a constraint that is not statically enforced. See below.
+
+@item The monadic interface allows much clearer definitions of commandparses
+with (nested) subcommands. No pesky sum-types are necessary.
+@end itemize")
+
+ (license license:bsd-3)))
+
(define-public ghc-byteable
(package
(name "ghc-byteable")
--
2.31.1
?