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

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

[Xinglu Chen]

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

[bug#48813] [PATCH 1/8] gnu: Add ghc-strict-list.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-strict-list): New variable.
---
 gnu/packages/haskell-xyz.scm | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

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

[bug#48813] [PATCH 2/8] gnu: Add ghc-neat-interpolation.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-neat-interpolation): New variable.
---
 gnu/packages/haskell-xyz.scm | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

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

[bug#48813] [PATCH 3/8] gnu: Add ghc-multistate.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-multistate): New variable.
---
 gnu/packages/haskell-xyz.scm | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

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

[bug#48813] [PATCH 4/8] gnu: Add ghc-monad-memo.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-monad-memo): New variable.
---
 gnu/packages/haskell-xyz.scm | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

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

[bug#48813] [PATCH 5/8] gnu: Add ghc-deque.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-deque): New variable.
---
 gnu/packages/haskell-xyz.scm | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

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

[bug#48813] [PATCH 6/8] gnu: Add ghc-data-tree-print.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-data-tree-print): New variable.
---
 gnu/packages/haskell-xyz.scm | 39 ++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

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

[bug#48813] [PATCH 7/8] gnu: Add ghc-czipwith.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-czipwith): New variable.
---
 gnu/packages/haskell-xyz.scm | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

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

[bug#48813] [PATCH 8/8] gnu: Add ghc-brittany.

[Xinglu Chen]

* gnu/packages/haskell-xyz.scm (ghc-brittany): New variable.
---
 gnu/packages/haskell-xyz.scm | 126 +++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)

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