[bug#28884] [PATCH 00/38] Add ghc-aws and its dependencies.

[bug#28884] [PATCH 00/38] Add ghc-aws and its dependencies.

[rsiddharth]

This patch series adds `ghc-aws` and its dependencies.

Patch Notes:

 * The following packages cannot be upgraded to the latest version:

    - ghc-monadrandom: ghc-either 4.4.1.1 requires MonadRandom >=0.1 && <0.5¹
    - ghc-vector-builder: latest version of this package has dependencies not
      yet there in guix².

 * guix lint has trouble parsing https://hackage.haskell.org/package/entropy/entropy.cabal

     ./pre-inst-env guix lint ghc-entropy

   throws:

     Syntax error: unexpected token : custom-setup (at line 34, column 0)
     Syntax error: unexpected end of input
     warning: failed to parse https://hackage.haskell.org/package/entropy/entropy.cabal

¹: https://hackage.haskell.org/package/either-4.4.1.1/either-4.4.1.1.tar.gz
²: https://hackage.haskell.org/package/vector-builder-0.3.3.1/vector-builder-0.3.3.1.tar.gz

rsiddharth (38):
  gnu: Add ghc-errors.
  gnu: Add ghc-vector-th-unbox.
  gnu: Add ghc-erf.
  gnu: Add ghc-math-functions.
  gnu: Add ghc-mwc-random.
  gnu: Add ghc-vector-algorithms.
  gnu: Add ghc-language-haskell-extract.
  gnu: Add ghc-test-framework-th.
  gnu: Add ghc-abstract-par.
  gnu: Add ghc-monad-par-extras.
  gnu: Add ghc-abstract-deque.
  gnu: Add ghc-monad-par.
  gnu: ghc-base-orphans: Update to 0.6.
  gnu: Add ghc-statistics.
  gnu: Add ghc-chunked-data.
  gnu: Add ghc-base-prelude.
  gnu: Add ghc-tuple-th.
  gnu: Add ghc-contravariant-extras.
  gnu: Add ghc-monadrandom.
  gnu: Add ghc-either.
  gnu: Add ghc-entropy.
  gnu: Add ghc-crypto-api.
  gnu: Add ghc-crypto-api-tests.
  gnu: Add ghc-pretty-hex.
  gnu: Add ghc-puremd5
  gnu: Add ghc-cryptohash-md5.
  gnu: Add ghc-cryptohash-sha1.
  gnu: Add ghc-network-info.
  gnu: Add ghc-uuid-types.
  gnu: Add ghc-uuid.
  gnu: Add ghc-rebase.
  gnu: Add ghc-vector-builder.
  gnu: Add ghc-foldl.
  gnu: Add ghc-mono-traversable.
  gnu: ghc-conduit: Update to 1.2.12.1.
  gnu: ghc-conduit: Fix lint error.
  gnu: Add ghc-conduit-combinators.
  gnu: Add ghc-aws.

 gnu/packages/haskell.scm | 1220 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 1210 insertions(+), 10 deletions(-)

-- 
2.15.0.rc0

[bug#28884] [PATCH 01/38] gnu: Add ghc-errors.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 7e879f4ad..2d70c6938 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9005,4 +9005,30 @@ contents of the HTTP connection.  It also provides higher-level functions
 which allow you to avoid direct usage of conduits.")
     (license license:bsd-3)))
 
+(define-public ghc-errors
+  (package
+    (name "ghc-errors")
+    (version "2.2.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "errors-" version "/"
+                           "errors-" version ".tar.gz"))
+       (sha256
+        (base32
+         "13sflhglcm5skwrxb48fw96skdcx7ydiy4zg22200733pxhjncpn"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-exceptions" ,ghc-exceptions)
+       ("ghc-text" ,ghc-text)
+       ("ghc-transformers-compat" ,ghc-transformers-compat)
+       ("ghc-unexceptionalio" ,ghc-unexceptionalio)
+       ("ghc-safe" ,ghc-safe)))
+    (home-page "https://github.com/gabriel439/haskell-errors-library")
+    (synopsis "Error handling library for Haskell")
+    (description "This library encourages an error-handling style that
+directly uses the type system, rather than out-of-band exceptions.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 02/38] gnu: Add ghc-vector-th-unbox.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-vector-th-unbox): New variable.
---
 gnu/packages/haskell.scm | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 2d70c6938..bce1a4575 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9031,4 +9031,28 @@ which allow you to avoid direct usage of conduits.")
 directly uses the type system, rather than out-of-band exceptions.")
     (license license:bsd-3)))
 
+(define-public ghc-vector-th-unbox
+  (package
+    (name "ghc-vector-th-unbox")
+    (version "0.2.1.6")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "vector-th-unbox-" version "/"
+                           "vector-th-unbox-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0d82x55f5vvr1jvaia382m23rs690lg55pvavv8f4ph0y6kd91xy"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-data-default" ,ghc-data-default)))
+    (home-page "https://github.com/liyang/vector-th-unbox")
+    (synopsis "Deriver for Data.Vector.Unboxed using Template Haskell")
+    (description "This Haskell library provides a Template Haskell
+deriver for unboxed vectors, given a pair of coercion functions to
+and from some existing type with an Unbox instance.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 03/38] gnu: Add ghc-erf.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index bce1a4575..e6cefe1c1 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9055,4 +9055,25 @@ deriver for unboxed vectors, given a pair of coercion functions to
 and from some existing type with an Unbox instance.")
     (license license:bsd-3)))
 
+(define-public ghc-erf
+  (package
+    (name "ghc-erf")
+    (version "2.0.0.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "erf-" version "/"
+                           "erf-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14"))))
+    (build-system haskell-build-system)
+    (home-page "https://hackage.haskell.org/package/erf")
+    (synopsis "The error function, erf, and related functions for Haskell")
+    (description "This Haskell library provides a type class for the
+error function, erf, and related functions.  Instances for Float and
+Double.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 04/38] gnu: Add ghc-math-functions.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index e6cefe1c1..4d3f46598 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9076,4 +9076,35 @@ error function, erf, and related functions.  Instances for Float and
 Double.")
     (license license:bsd-3)))
 
+(define-public ghc-math-functions
+  (package
+    (name "ghc-math-functions")
+    (version "0.2.1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "math-functions-" version "/"
+                           "math-functions-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1sv5vabsx332v1lpb6v3jv4zrzvpx1n7yprzd8wlcda5vsc5a6zp"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-erf" ,ghc-erf)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/math-functions")
+    (synopsis "Special functions and Chebyshev polynomials for Haskell")
+    (description "This Haskell library provides implementations of
+special mathematical functions and Chebyshev polynomials.  These
+functions are often useful in statistical and numerical computing.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 05/38] gnu: Add ghc-mwc-random.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-mwc-random): New variable.
---
 gnu/packages/haskell.scm | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 4d3f46598..df6a27dc2 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9107,4 +9107,43 @@ special mathematical functions and Chebyshev polynomials.  These
 functions are often useful in statistical and numerical computing.")
     (license license:bsd-3)))
 
+(define-public ghc-mwc-random
+  (package
+    (name "ghc-mwc-random")
+    (version "0.13.6.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "mwc-random-" version "/"
+                           "mwc-random-" version ".tar.gz"))
+       (sha256
+        (base32
+         "05j7yh0hh9nxic3dijmzv44kc6gzclvamdph7sq7w19wq57k6pq6"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-primitive" ,ghc-primitive)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-math-functions" ,ghc-math-functions)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (home-page "https://github.com/bos/mwc-random")
+    (synopsis "Random number generation library for Haskell")
+    (description "This Haskell package contains code for generating
+high quality random numbers that follow either a uniform or normal
+distribution.  The generated numbers are suitable for use in
+statistical applications.
+
+The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222)
+multiply-with-carry generator, which has a period of 2^{8222} and
+fares well in tests of randomness.  It is also extremely fast,
+between 2 and 3 times faster than the Mersenne Twister.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 06/38] gnu: Add ghc-vector-algorithms.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index df6a27dc2..43a8565f6 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9146,4 +9146,29 @@ fares well in tests of randomness.  It is also extremely fast,
 between 2 and 3 times faster than the Mersenne Twister.")
     (license license:bsd-3)))
 
+(define-public ghc-vector-algorithms
+  (package
+    (name "ghc-vector-algorithms")
+    (version "0.7.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "vector-algorithms-" version "/"
+                           "vector-algorithms-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0w4hf598lpxfg58rnimcqxrbnpqq2jmpjx82qa5md3q6r90hlipd"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-vector" ,ghc-vector)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-mwc-random" ,ghc-mwc-random)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/bos/math-functions")
+    (synopsis "Algorithms for vector arrays in Haskell")
+    (description "This Haskell library algorithms for vector arrays.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 07/38] gnu: Add ghc-language-haskell-extract.

[rsiddharth]

* gnu/packages/haskell.scm
(ghc-language-haskell-extract): New variable.
---
 gnu/packages/haskell.scm | 66 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 43a8565f6..2f064e2b2 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9171,4 +9171,70 @@ between 2 and 3 times faster than the Mersenne Twister.")
     (description "This Haskell library algorithms for vector arrays.")
     (license license:bsd-3)))
 
+(define-public ghc-language-haskell-extract
+  (package
+    (name "ghc-language-haskell-extract")
+    (version "0.2.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "language-haskell-extract-" version "/"
+                           "language-haskell-extract-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-regex-posix" ,ghc-regex-posix)))
+    (home-page "https://github.com/finnsson/template-helper")
+    (synopsis "Haskell module to automatically extract functions from
+the local code")
+    (description "This package contains helper functions on top of
+Template Haskell.
+
+@code{functionExtractor} extracts all functions after a regexp-pattern.
+
+@verbatim
+ foo = \"test\"
+ boo = \"testing\"
+ bar = $\(functionExtractor \"oo$\")
+@end verbatim
+
+will automagically extract the functions ending with @code{oo} such as
+
+@verbatim
+ bar = [\(\"foo\",foo), \(\"boo\",boo)]
+@end verbatim
+
+This can be useful if you wish to extract all functions beginning
+with test \(for a test-framework) or all functions beginning with wc
+\(for a web service).
+
+@code{functionExtractorMap} works like @code{functionsExtractor} but
+applies a function over all function-pairs.
+
+This functions is useful if the common return type of the functions is
+a type class.
+
+Example:
+
+@verbatim
+ secondTypeclassTest =
+   do let expected = [\"45\", \"88.8\", \"\\\"hej\\\"\"]
+          actual = $\(functionExtractorMap \"^tc\" [|\\n f -> show f|] )
+      expected @=? actual
+
+ tcInt :: Integer
+ tcInt = 45
+
+ tcDouble :: Double
+ tcDouble = 88.8
+
+ tcString :: String
+ tcString = \"hej\"
+@end verbatim
+")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 08/38] gnu: Add ghc-test-framework-th.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-test-framework-th): New variable.
---
 gnu/packages/haskell.scm | 75 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 2f064e2b2..d4078a307 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9237,4 +9237,79 @@ Example:
 ")
     (license license:bsd-3)))
 
+(define-public ghc-test-framework-th
+  (package
+    (name "ghc-test-framework-th")
+    (version "0.2.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "test-framework-th-" version "/"
+                           "test-framework-th-" version ".tar.gz"))
+       (sha256
+        (base32
+         "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-language-haskell-extract" ,ghc-language-haskell-extract)
+       ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+       ("ghc-regex-posix" ,ghc-regex-posix)))
+    (home-page "https://github.com/finnsson/test-generator")
+    (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code
+using Template Haskell")
+    (description "This library contains two functions:
+@code{defaultMainGenerator} and @code{testGroupGenerator}.
+
+@code{defaultMainGenerator} will extract all functions beginning with
+case_, prop_ or test_in the module and put them in a testGroup.
+
+@verbatim
+ -- file SomeModule.hs
+ \( -# LANGUAGE TemplateHaskell #- )
+ module SomeModule where
+ import Test.Framework.TH
+ import Test.Framework
+ import Test.HUnit
+ import Test.Framework.Providers.HUnit
+ import Test.Framework.Providers.QuickCheck2
+
+ -- observe this line!
+ main = $\(defaultMainGenerator)
+ case_1 = do 1 @=? 1
+ case_2 = do 2 @=? 2
+ prop_reverse xs = reverse \(reverse xs) == xs
+    where types = xs::[Int]
+@end verbatim
+
+   is the same as
+
+@verbatim
+ -- file SomeModule.hs
+ \( -# LANGUAGE TemplateHaskell #- )
+ module SomeModule where
+ import Test.Framework.TH
+ import Test.Framework
+ import Test.HUnit
+ import Test.Framework.Providers.HUnit
+ import Test.Framework.Providers.QuickCheck2
+
+ -- observe this line!
+ main =
+   defaultMain [
+     testGroup \"SomeModule\" [ testCase \"1\" case_1, testCase \"2\" \
+case_2, testProperty \"reverse\" prop_reverse]
+     ]
+ case_1 = do 1 @=? 1
+ case_2 = do 2 @=? 2
+ prop_reverse xs = reverse \(reverse xs) == xs
+    where types = xs::[Int]
+@end verbatim
+
+@code{testGroupGenerator} is like @code{defaultMainGenerator} but without
+@code{defaultMain}.  It is useful if you need a function for the testgroup
+\(e.g. if you want to be able to call the testgroup from another module).")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 09/38] gnu: Add ghc-abstract-par.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-abstract-par): New variable.
---
 gnu/packages/haskell.scm | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index d4078a307..bb66d5d0a 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9312,4 +9312,27 @@ case_2, testProperty \"reverse\" prop_reverse]
 \(e.g. if you want to be able to call the testgroup from another module).")
     (license license:bsd-3)))
 
+(define-public ghc-abstract-par
+  (package
+    (name "ghc-abstract-par")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "abstract-par-" version "/"
+                           "abstract-par-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/simonmar/monad-par")
+    (synopsis "Abstract parallelization interface for Haskell")
+    (description "This Haskell package is an abstract interface
+only.  It provides a number of type clasess, but not an
+implementation.  The type classes separate different levels
+of @code{Par} functionality.  See the @code{Control.Monad.Par.Class}
+module for more details.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 10/38] gnu: Add ghc-monad-par-extras.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-monad-par-extras): New variable.
---
 gnu/packages/haskell.scm | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index bb66d5d0a..73c4597b0 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9335,4 +9335,28 @@ of @code{Par} functionality.  See the @code{Control.Monad.Par.Class}
 module for more details.")
     (license license:bsd-3)))
 
+(define-public ghc-monad-par-extras
+  (package
+    (name "ghc-monad-par-extras")
+    (version "0.3.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monad-par-extras-" version "/"
+                           "monad-par-extras-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
+              ("ghc-cereal" ,ghc-cereal)
+              ("ghc-random" ,ghc-random)
+              ("ghc-mtl" ,ghc-mtl)))
+    (home-page "https://github.com/simonmar/monad-par")
+    (synopsis "Combinators and extra features for Par monads for Haskell")
+    (description "This Haskell package provides additional data structures,
+and other added capabilities layered on top of the @code{Par} monad.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 11/38] gnu: Add ghc-abstract-deque.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 73c4597b0..217f0e34b 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9359,4 +9359,41 @@ module for more details.")
 and other added capabilities layered on top of the @code{Par} monad.")
     (license license:bsd-3)))
 
+(define-public ghc-abstract-deque
+  (package
+    (name "ghc-abstract-deque")
+    (version "0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "abstract-deque-" version "/"
+                           "abstract-deque-" version ".tar.gz"))
+       (sha256
+        (base32
+         "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-random" ,ghc-random)))
+    (home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
+    (synopsis "Abstract, parameterized interface to mutable Deques for Haskell")
+    (description "This Haskell package provides an abstract interface to
+highly-parameterizable queues/deques.
+
+Background: There exists a feature space for queues that extends between:
+
+@itemize
+@item Simple, single-ended, non-concurrent, bounded queues
+
+@item Double-ended, threadsafe, growable queues with important points
+inbetween (such as the queues used for work-stealing).
+@end itemize
+
+This package includes an interface for Deques that allows the programmer
+to use a single API for all of the above, while using the type-system to
+select an efficient implementation given the requirements (using type families).
+
+This package also includes a simple reference implementation based on
+@code{IORef} and @code{Data.Sequence}.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 12/38] gnu: Add ghc-monad-par.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 217f0e34b..52380d1b8 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9396,4 +9396,40 @@ This package also includes a simple reference implementation based on
 @code{IORef} and @code{Data.Sequence}.")
     (license license:bsd-3)))
 
+(define-public ghc-monad-par
+  (package
+    (name "ghc-monad-par")
+    (version "0.3.4.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "monad-par-" version "/"
+                           "monad-par-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0ldrzqy24fsszvn2a2nr77m2ih7xm0h9bgkjyv1l274aj18xyk7q"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-abstract-par" ,ghc-abstract-par)
+              ("ghc-abstract-deque" ,ghc-abstract-deque)
+              ("ghc-monad-par-extras" ,ghc-monad-par-extras)
+              ("ghc-mwc-random" ,ghc-mwc-random)
+              ("ghc-parallel" ,ghc-parallel)
+              ("ghc-mtl" ,ghc-mtl)))
+    (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+                     ("ghc-test-framework-quickcheck2"
+                      ,ghc-test-framework-quickcheck2)
+                     ("ghc-test-framework" ,ghc-test-framework)
+                     ("ghc-test-framework-th" ,ghc-test-framework-th)))
+    (home-page "https://github.com/simonmar/monad-par")
+    (synopsis "Haskell library for parallel programming based on a monad")
+    (description "The @code{Par} monad offers an API for parallel
+programming.  The library works for parallelising both pure and @code{IO}
+computations, although only the pure version is deterministic.  The default
+implementation provides a work-stealing scheduler and supports forking tasks
+that are much lighter weight than IO-threads.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 13/38] gnu: ghc-base-orphans: Update to 0.6.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-base-orphans): Update to 0.6.
---
 gnu/packages/haskell.scm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 52380d1b8..52ac4f909 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -4282,7 +4282,7 @@ command line options in Haskell.")
 (define-public ghc-base-orphans
   (package
     (name "ghc-base-orphans")
-    (version "0.4.4")
+    (version "0.6")
     (source
      (origin
        (method url-fetch)
@@ -4292,7 +4292,7 @@ command line options in Haskell.")
              ".tar.gz"))
        (sha256
         (base32
-         "0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl"))))
+         "03mdww5j0gwai7aqlx3m71ldmjcr99jzpkcclzjfclk6a6kjla67"))))
     (build-system haskell-build-system)
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)
-- 
2.15.0.rc0

[bug#28884] [PATCH 14/38] gnu: Add ghc-statistics.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 52ac4f909..c7d409bc5 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9432,4 +9432,63 @@ implementation provides a work-stealing scheduler and supports forking tasks
 that are much lighter weight than IO-threads.")
     (license license:bsd-3)))
 
+(define-public ghc-statistics
+  (package
+    (name "ghc-statistics")
+    (version "0.14.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "statistics-" version "/"
+                           "statistics-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0y27gafkib0x0fn39qfn2rkgsfrm09ng35sbb5dwr7rclhnxz59l"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-base-orphans" ,ghc-base-orphans)
+       ("ghc-erf" ,ghc-erf)
+       ("ghc-math-functions" ,ghc-math-functions)
+       ("ghc-monad-par" ,ghc-monad-par)
+       ("ghc-mwc-random" ,ghc-mwc-random)
+       ("ghc-primitive" ,ghc-primitive)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-vector-algorithms" ,ghc-vector-algorithms)
+       ("ghc-vector-th-unbox" ,ghc-vector-th-unbox)
+       ("ghc-vector-binary-instances" ,ghc-vector-binary-instances)))
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-ieee754", ghc-ieee754)
+       ("ghc-test-framework" ,ghc-test-framework)
+       ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+       ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+    (arguments
+     `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
+    (home-page "https://github.com/bos/mwc-random")
+    (synopsis "Haskell library of statistical types, data, and functions")
+    (description "This library provides a number of common functions
+and types useful in statistics.  We focus on high performance, numerical
+robustness, and use of good algorithms.  Where possible, we provide references
+to the statistical literature.
+
+The library's facilities can be divided into four broad categories:
+
+@itemize
+@item Working with widely used discrete and continuous probability
+distributions.  (There are dozens of exotic distributions in use; we focus
+on the most common.)
+
+@item Computing with sample data: quantile estimation, kernel density
+estimation, histograms, bootstrap methods, significance testing,
+and regression and autocorrelation analysis.
+
+@item Random variate generation under several different distributions.
+
+@item Common statistical tests for significant differences between samples.
+@end itemize")
+    (license license:bsd-2)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 15/38] gnu: Add ghc-chunked-data.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-chunked-data): New variable.
---
 gnu/packages/haskell.scm | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index c7d409bc5..8ad03aa24 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9491,4 +9491,27 @@ and regression and autocorrelation analysis.
 @end itemize")
     (license license:bsd-2)))
 
+(define-public ghc-chunked-data
+  (package
+    (name "ghc-chunked-data")
+    (version "0.3.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "chunked-data-" version "/"
+                           "chunked-data-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0bszq6fijnr4pmadzz89smj7kfmzx0ca3wd9ga8gv0in9jk9vgp1"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-vector" ,ghc-vector)
+              ("ghc-semigroups" ,ghc-semigroups)))
+    (home-page "https://github.com/snoyberg/mono-traversable")
+    (synopsis "Typeclasses for dealing with various chunked data
+representations for Haskell")
+    (description "This Haskell package was originally present in
+classy-prelude.")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 16/38] gnu: Add ghc-base-prelude.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-base-prelude): New variable.
---
 gnu/packages/haskell.scm | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 8ad03aa24..9af6d1f6a 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9514,4 +9514,37 @@ representations for Haskell")
 classy-prelude.")
     (license license:expat)))
 
+(define-public ghc-base-prelude
+  (package
+    (name "ghc-base-prelude")
+    (version "1.2.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "base-prelude-" version "/"
+                           "base-prelude-" version ".tar.gz"))
+       (sha256
+        (base32
+         "17hivs7lmsglagdlzxd9q9zsddmgqin2788mpq911zwnb57lj6l1"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/nikita-volkov/base-prelude")
+    (synopsis "The most complete prelude formed solely from the Haskell's base
+package")
+    (description "This Haskell package aims to reexport all the non-conflicting
+and most general definitions from the \"base\" package.
+
+This includes APIs for applicatives, arrows, monoids, foldables, traversables,
+exceptions, generics, ST, MVars and STM.
+
+This package will never have any dependencies other than \"base\".
+
+Versioning policy:
+
+The versioning policy of this package deviates from PVP in the sense
+that its exports in part are transitively determined by the version of \"base\".
+Therefore it's recommended for the users of @code{ghc-base-prelude} to specify
+the bounds of \"base\" as well.")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 17/38] gnu: Add ghc-tuple-th.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-tuple-th): New variable.
---
 gnu/packages/haskell.scm | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 9af6d1f6a..23e920351 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9547,4 +9547,26 @@ Therefore it's recommended for the users of @code{ghc-base-prelude} to specify
 the bounds of \"base\" as well.")
     (license license:expat)))
 
+(define-public ghc-tuple-th
+  (package
+    (name "ghc-tuple-th")
+    (version "0.2.5")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "tuple-th-" version "/"
+                           "tuple-th-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1mrl4vvxmby7sf1paf7hklzidnr6wq55822i73smqyz0xpf3gsjn"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/DanielSchuessler/tuple-th")
+    (synopsis "Generate utility functions for tuples of statically known size
+for Haskell")
+    (description "This Haskell package contains Template Haskell functions for
+generating functions similar to those in @code{Data.List} for tuples of
+statically known size.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 18/38] gnu: Add ghc-contravariant-extras.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-contravariant-extras): New variable.
---
 gnu/packages/haskell.scm | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 23e920351..23996ad3d 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9569,4 +9569,27 @@ generating functions similar to those in @code{Data.List} for tuples of
 statically known size.")
     (license license:bsd-3)))
 
+(define-public ghc-contravariant-extras
+  (package
+    (name "ghc-contravariant-extras")
+    (version "0.3.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "contravariant-extras-" version "/"
+                           "contravariant-extras-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1mbrgjybdx8fjdck4ldwi8955w4qnmm0ql56zix7dyn0s7s9spgk"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-tuple-th" ,ghc-tuple-th)
+              ("ghc-contravariant" ,ghc-contravariant)
+              ("ghc-base-prelude",ghc-base-prelude)))
+    (home-page "https://github.com/nikita-volkov/contravariant-extras")
+    (synopsis "Extras for the @code{ghc-contravariant} Haskell package")
+    (description "This Haskell package provides extras for the
+@code{ghc-contravariant} package.")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 19/38] gnu: Add ghc-monadrandom.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 23996ad3d..449022fce 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9592,4 +9592,29 @@ statically known size.")
 @code{ghc-contravariant} package.")
     (license license:expat)))
 
+(define-public ghc-monadrandom
+  (package
+    (name "ghc-monadrandom")
+    (version "0.4.2.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "MonadRandom-" version "/"
+                           "MonadRandom-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1h1nhswrcmhy3mq6vd530p0df51fcnnf4csbwnljar7cf0mb2h6y"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-transformers-compat" ,ghc-transformers-compat)
+              ("ghc-mtl" ,ghc-mtl)
+              ("ghc-primitive" ,ghc-primitive)
+              ("ghc-fail" ,ghc-fail)
+              ("ghc-random" ,ghc-random)))
+    (home-page "https://github.com/byorgey/MonadRandom")
+    (synopsis "Random-number generation monad for Haskell")
+    (description "This Haskell package provides support for computations
+which consume random values.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 20/38] gnu: Add ghc-either.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 449022fce..0bb13f964 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9617,4 +9617,33 @@ statically known size.")
 which consume random values.")
     (license license:bsd-3)))
 
+(define-public ghc-either
+  (package
+    (name "ghc-either")
+    (version "4.4.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "either-" version "/"
+                           "either-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1lrlwqqnm6ibfcydlv5qvvssw7bm0c6yypy0rayjzv1znq7wp1xh"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-bifunctors" ,ghc-bifunctors)
+              ("ghc-exceptions" ,ghc-exceptions)
+              ("ghc-free" ,ghc-free)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-manodrandom" ,ghc-monadrandom)
+              ("ghc-mtl" ,ghc-mtl)
+              ("ghc-mmorph" ,ghc-mmorph)
+              ("ghc-profunctors" ,ghc-profunctors)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-semigroupoids" ,ghc-semigroupoids)
+              ("ghc-transformers-base" ,ghc-transformers-base)))
+    (home-page "https://github.com/ekmett/either")
+    (synopsis "Provides an either monad transformer for Haskell")
+    (description "This Haskell package provides an either monad transformer.")
+    (license license:bsd-3)))
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 21/38] gnu: Add ghc-entropy.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 0bb13f964..6f6673896 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9646,4 +9646,25 @@ which consume random values.")
     (synopsis "Provides an either monad transformer for Haskell")
     (description "This Haskell package provides an either monad transformer.")
     (license license:bsd-3)))
+
+(define-public ghc-entropy
+  (package
+    (name "ghc-entropy")
+    (version "0.3.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "entropy-" version "/"
+                           "entropy-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1l3lfigqvdlmxkz1wl7zdkmc0i2r5p6z4xzhiw8xdsbsw7aljfkl"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/TomMD/entropy")
+    (synopsis "Provides platform independent entropy source for Haskell")
+    (description "This Haskell package provides a platform independent method
+to obtain cryptographically strong entropy.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 22/38] gnu: Add ghc-crypto-api.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 6f6673896..0f18dd6c6 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9667,4 +9667,35 @@ which consume random values.")
 to obtain cryptographically strong entropy.")
     (license license:bsd-3)))
 
+(define-public ghc-crypto-api
+  (package
+    (name "ghc-crypto-api")
+    (version "0.13.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "crypto-api-" version "/"
+                           "crypto-api-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1vc27qcgbg7hf50rkqhlrs58zn1888ilh4b6wrrm07bnm48xacak"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-cereal" ,ghc-cereal)
+              ("ghc-tagged" ,ghc-tagged)
+              ("ghc-entropy" ,ghc-entropy)))
+    (home-page "https://github.com/TomMD/crypto-api")
+    (synopsis "Provides generic interface for cryptographic operations
+for Haskell")
+    (description "This Haskell package provides a generic interface for
+cryptographic operations (hashes, ciphers, randomness).
+
+Maintainers of hash and cipher implementations are encouraged to add instances
+for the classes defined in @code{Crypto.Classes}.  @code{Crypto} users are
+similarly encouraged to use the interfaces defined in the @code{Classes} module.
+
+Any concepts or functions of general use to more than one cryptographic
+algorithm (ex: padding) is within scope of this package.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 23/38] gnu: Add ghc-crypto-api-tests.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-crypto-api-tests): New variable.
---
 gnu/packages/haskell.scm | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 0f18dd6c6..bea8e4dec 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9698,4 +9698,32 @@ Any concepts or functions of general use to more than one cryptographic
 algorithm (ex: padding) is within scope of this package.")
     (license license:bsd-3)))
 
+(define-public ghc-crypto-api-tests
+  (package
+    (name "ghc-crypto-api-tests")
+    (version "0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "crypto-api-tests-" version "/"
+                           "crypto-api-tests-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0w3j43jdrlj28jryp18hc6q84nkl2yf4vs1hhgrsk7gb9kfyqjpl"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+              ("ghc-crypto-api" ,ghc-crypto-api)
+              ("ghc-cereal" ,ghc-cereal)
+              ("ghc-test-framework" ,ghc-test-framework)
+              ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+              ("ghc-hunit" ,ghc-hunit)
+              ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/TomMD/crypto-api-tests")
+    (synopsis "Test framework and KATs for cryptographic operations for Haskell")
+    (description "This Haskell package provides a test framework for hash and
+cipher operations using the crypto-api interface.  Known answer tests (KATs)
+for common cryptographic algorithms are included.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 24/38] gnu: Add ghc-pretty-hex.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-pretty-hex): New variable.
---
 gnu/packages/haskell.scm | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index bea8e4dec..c0be64bf8 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9726,4 +9726,24 @@ cipher operations using the crypto-api interface.  Known answer tests (KATs)
 for common cryptographic algorithms are included.")
     (license license:bsd-3)))
 
+(define-public ghc-pretty-hex
+  (package
+    (name "ghc-pretty-hex")
+    (version "1.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "pretty-hex-" version "/"
+                           "pretty-hex-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0ylwkvvjvmpprha9nx83xb8gkhyanhk5fffc0r7lb96n4ch5z6pz"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/GaloisInc/hexdump")
+    (synopsis "Haskell library for hex dumps of ByteStrings")
+    (description "This Haskell library generates pretty hex dumps of
+ByteStrings in the style of other common *nix hex dump tools.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 25/38] gnu: Add ghc-puremd5

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index c0be64bf8..a0fec6d20 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9746,4 +9746,35 @@ for common cryptographic algorithms are included.")
 ByteStrings in the style of other common *nix hex dump tools.")
     (license license:bsd-3)))
 
+(define-public ghc-puremd5
+  (package
+    (name "ghc-puremd5")
+    (version "2.1.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "pureMD5-" version "/"
+                           "pureMD5-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0zdilz41cla2ck7mcw1a9702gyg2abq94mqahr4vci9sbs53bwxy"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-cereal" ,ghc-cereal)
+              ("ghc-crypto-api" ,ghc-crypto-api)
+              ("ghc-tagged" ,ghc-tagged)))
+    (native-inputs `(("ghc-crypto-api-tests" ,ghc-crypto-api-tests)
+                     ("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-test-framework" ,ghc-test-framework)
+                     ("ghc-test-framework-quickcheck2"
+                      ,ghc-test-framework-quickcheck2)
+                     ("ghc-pretty-hex" ,ghc-pretty-hex)))
+    (home-page "https://github.com/TomMD/pureMD5")
+    (synopsis "Provides implementation of the MD5 digest (hash) algorithm for
+Haskell")
+    (description "This package provides a Haskell-only implementation of
+the MD5 digest (hash) algorithm.  This now supports the @code{crypto-api} class
+interface.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 26/38] gnu: Add ghc-cryptohash-md5.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-cryptohash-md5): New variable.
---
 gnu/packages/haskell.scm | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index a0fec6d20..544e02dc0 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9777,4 +9777,30 @@ the MD5 digest (hash) algorithm.  This now supports the @code{crypto-api} class
 interface.")
     (license license:bsd-3)))
 
+(define-public ghc-cryptohash-md5
+  (package
+    (name "ghc-cryptohash-md5")
+    (version "0.11.100.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "cryptohash-md5-" version "/"
+                           "cryptohash-md5-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1y8q7s2bn4gdknw1wjikdnar2b5pgz3nv3220lxrlgpsf23x82vi"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f)) ; tests require old version of ghc-hunit (0.9)
+    (native-inputs `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+                     ("ghc-puremd5" ,ghc-puremd5)
+                     ("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+                     ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/hvr/cryptohash-md5")
+    (synopsis "MD5 Implementation for Haskell")
+    (description "This Haskell package provides implementation of MD5.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 27/38] gnu: Add ghc-cryptohash-sha1.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 544e02dc0..bba133ce1 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9803,4 +9803,36 @@ interface.")
     (description "This Haskell package provides implementation of MD5.")
     (license license:bsd-3)))
 
+(define-public ghc-cryptohash-sha1
+  (package
+    (name "ghc-cryptohash-sha1")
+    (version "0.11.100.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "cryptohash-sha1-" version "/"
+                           "cryptohash-sha1-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1aqdxdhxhl9jldh951djpwxx8z7gzaqspxl7iwpl84i5ahrsyy9w"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f)) ; tests require old version of ghc-hunit (0.9)
+    (native-inputs `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+                     ("ghc-sha" ,ghc-sha)
+                     ("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+                     ("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/hvr/cryptohash-sha1")
+    (synopsis "SHA-1 Implementation for Haskell")
+    (description "This Haskell package provides an incremental and one-pass,
+pure API to the @uref{https://en.wikipedia.org/wiki/SHA-1, SHA-1 hash algorithm},
+including @uref{https://en.wikipedia.org/wiki/HMAC, HMAC support}, with
+performance close to the fastest implementations available in other languages.
+
+The implementation is made in C with a haskell FFI wrapper that hides
+the C implementation.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 28/38] gnu: Add ghc-network-info.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-network-info): New variable.
---
 gnu/packages/haskell.scm | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index bba133ce1..3550ca23e 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9835,4 +9835,26 @@ The implementation is made in C with a haskell FFI wrapper that hides
 the C implementation.")
     (license license:bsd-3)))
 
+(define-public ghc-network-info
+  (package
+    (name "ghc-network-info")
+    (version "0.2.0.8")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "network-info-" version "/"
+                           "network-info-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0xndvg776241fgjmynxfpy81f1csjmh8dg33yf0c8m71ychz3pzc"))))
+    (build-system haskell-build-system)
+    (home-page "https://github.com/jystic/network-info")
+    (synopsis "Access the local computer's basic network configuration")
+    (description "This Haskell library provides simple read-only access to the
+local computer's networking configuration.  It is currently capable of
+getting a list of all the network interfaces and their respective
+IPv4, IPv6 and MAC addresses.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 29/38] gnu: Add ghc-uuid-types.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 3550ca23e..087fcbf7f 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9857,4 +9857,35 @@ getting a list of all the network interfaces and their respective
 IPv4, IPv6 and MAC addresses.")
     (license license:bsd-3)))
 
+(define-public ghc-uuid-types
+  (package
+    (name "ghc-uuid-types")
+    (version "1.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "uuid-types-" version "/"
+                           "uuid-types-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-hashable" ,ghc-hashable)
+              ("ghc-random" ,ghc-random)
+              ("ghc-text" ,ghc-text)))
+    (native-inputs `(("ghc-hunit" ,ghc-hunit)
+                     ("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://github.com/hvr/uuid")
+    (synopsis "Provides Type definitions for Universally Unique Identifiers
+for Haskell")
+    (description "This Haskell library contains type definitions for
+Universally Unique Identifiers and basic conversion functions.
+
+See @uref{http://en.wikipedia.org/wiki/UUID} for the general idea.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 30/38] gnu: Add ghc-uuid.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 087fcbf7f..2e30aea41 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9885,6 +9885,41 @@ for Haskell")
     (description "This Haskell library contains type definitions for
 Universally Unique Identifiers and basic conversion functions.
 
+See @uref{http://en.wikipedia.org/wiki/UUID} for the general idea.")
+    (license license:bsd-3)))
+
+(define-public ghc-uuid
+  (package
+    (name "ghc-uuid")
+    (version "1.3.13")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "uuid-" version "/"
+                           "uuid-" version ".tar.gz"))
+       (sha256
+        (base32
+         "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-cryptohash-sha1" ,ghc-cryptohash-sha1)
+              ("ghc-cryptohash-md5" ,ghc-cryptohash-md5)
+              ("ghc-entropy" ,ghc-entropy)
+              ("ghc-network-info" ,ghc-network-info)
+              ("ghc-random" ,ghc-random)
+              ("ghc-text" ,ghc-text)
+              ("ghc-uuid-types" ,ghc-uuid-types)))
+    (native-inputs `(("ghc-hunit" ,ghc-hunit)
+                     ("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+    (home-page "https://github.com/hvr/uuid")
+    (synopsis "Haskell library for creating, comparing, parsing and printing
+UUID")
+    (description "This Haskell library provides utilities creating, comparing,
+parsing and printing Universally Unique Identifiers.
+
 See @uref{http://en.wikipedia.org/wiki/UUID} for the general idea.")
     (license license:bsd-3)))
 
-- 
2.15.0.rc0

[bug#28884] [PATCH 31/38] gnu: Add ghc-rebase.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 2e30aea41..129f1792e 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9923,4 +9923,62 @@ parsing and printing Universally Unique Identifiers.
 See @uref{http://en.wikipedia.org/wiki/UUID} for the general idea.")
     (license license:bsd-3)))
 
+(define-public ghc-rebase
+  (package
+    (name "ghc-rebase")
+    (version "1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "rebase-" version "/"
+                           "rebase-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1qkhnpcc4g2vd6jmbf3b6psqkan6hyawqzrwzqdd931hsb02l6ia"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-stm" ,ghc-stm)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-text" ,ghc-text)
+              ("ghc-scientific" ,ghc-scientific)
+              ("ghc-uuid" ,ghc-uuid)
+              ("ghc-dlist" ,ghc-dlist)
+              ("ghc-void" ,ghc-void)
+              ("ghc-bifunctors" ,ghc-bifunctors)
+              ("ghc-profunctors" ,ghc-profunctors)
+              ("ghc-contravariant" ,ghc-contravariant)
+              ("ghc-contravariant-extras" ,ghc-contravariant-extras)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-mtl" ,ghc-mtl)
+              ("ghc-either" ,ghc-either)
+              ("ghc-fail" ,ghc-fail)
+              ("ghc-base-prelude" ,ghc-base-prelude)))
+    (home-page "https://github.com/nikita-volkov/rebase")
+    (synopsis "Progressive alternative to the base package
+for Haskell")
+    (description "This Haskell package is intended for those who are
+tired of keeping long lists of dependencies to the same essential libraries
+in each package as well as the endless imports of the same APIs all over again.
+
+It also supports the modern tendencies in the language.
+
+To solve those problems this package does the following:
+
+@itemize
+@item Reexport the original APIs under the @code{Rebase} namespace.
+
+@item Export all the possible non-conflicting symbols from the
+@code{Rebase.Prelude} module.
+
+@item Give priority to the modern practices in the conflicting cases.
+@end itemize
+
+The policy behind the package is only to reexport the non-ambiguous and
+non-controversial APIs, which the community has obviously settled on.
+The package is intended to rapidly evolve with the contribution from
+the community, with the missing features being added with pull-requests.")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 32/38] gnu: Add ghc-vector-builder.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-vector-builder): New variable.
---
 gnu/packages/haskell.scm | 57 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 129f1792e..682f2da1e 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9981,4 +9981,61 @@ The package is intended to rapidly evolve with the contribution from
 the community, with the missing features being added with pull-requests.")
     (license license:expat)))
 
+(define-public ghc-vector-builder
+  (package
+    (name "ghc-vector-builder")
+    (version "0.3.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "vector-builder-" version "/"
+                           "vector-builder-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1l6sfgd2s107zkp1qd1w6jdjcbznp31769qf99pxar087f697wvp"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-vector" ,ghc-vector)
+              ("ghc-semigroups" ,ghc-semigroups)
+              ("ghc-base-prelude" ,ghc-base-prelude)))
+    (native-inputs `(("ghc-tasty" ,ghc-tasty)
+                     ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+                     ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+                     ("ghc-hunit" ,ghc-hunit)
+                     ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+                     ("ghc-rebase" ,ghc-rebase)))
+    (home-page "https://github.com/nikita-volkov/vector-builder")
+    (synopsis "Vector builder for Haskell")
+    (description "This Haskell package provides an API for constructing vectors.
+
+It provides the composable @code{Builder} abstraction, which has instances of the
+@code{Monoid} and @code{Semigroup} classes.
+
+Usage:
+
+First you use the @code{Builder} abstraction to specify the structure of the
+vector.  Then you execute the builder to actually produce the vector.
+
+Example:
+
+The following code shows how you can efficiently concatenate different
+datastructures into a single immutable vector:
+
+@verbatim
+import qualified Data.Vector as A
+import qualified VectorBuilder.Builder as B
+import qualified VectorBuilder.Vector as C
+
+myVector :: A.Vector a -> [a] -> a -> A.Vector a
+myVector vector list element =
+ C.build builder
+  where
+    builder =
+      B.vector vector <>
+      foldMap B.singleton list <>
+      B.singleton element
+@end verbatim
+")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 33/38] gnu: Add ghc-foldl.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 682f2da1e..8c1b725fd 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -10038,4 +10038,36 @@ myVector vector list element =
 ")
     (license license:expat)))
 
+(define-public ghc-foldl
+  (package
+    (name "ghc-foldl")
+    (version "1.3.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "foldl-" version "/"
+                           "foldl-" version ".tar.gz"))
+       (sha256
+        (base32
+         "1z3xjz4khs2kr3mqkbh7dz4kd6gkdk2r67wjkvrxnmp533aqh90n"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-mwc-randam" ,ghc-mwc-random)
+              ("ghc-primitive" ,ghc-primitive)
+              ("ghc-text" ,ghc-text)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-contravariant" ,ghc-contravariant)
+              ("ghc-profunctors" ,ghc-profunctors)
+              ("ghc-comonad" ,ghc-comonad)
+              ("ghc-vector-builder" ,ghc-vector-builder)))
+    (home-page "https://github.com/Gabriel439/Haskell-Foldl-Library")
+    (synopsis "Composable, streaming, and efficient left folds for Haskell")
+    (description "This Haskell library provides strict left folds that stream
+in constant memory, and you can combine folds using @code{Applicative} style
+to derive new folds.  Derived folds still traverse the container just once
+and are often as efficient as hand-written folds.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 34/38] gnu: Add ghc-mono-traversable.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-mono-traversable): New variable.
---
 gnu/packages/haskell.scm | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 8c1b725fd..d622ee2e3 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -10070,4 +10070,39 @@ to derive new folds.  Derived folds still traverse the container just once
 and are often as efficient as hand-written folds.")
     (license license:bsd-3)))
 
+(define-public ghc-mono-traversable
+  (package
+    (name "ghc-mono-traversable")
+    (version "1.0.2.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "mono-traversable-" version "/"
+                           "mono-traversable-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0smirpwika7d5a98h20jr9jqg41n7vqfy7k31crmn449qfig9ljf"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-unordered-containers" ,ghc-unordered-containers)
+              ("ghc-hashable" ,ghc-hashable)
+              ("ghc-text" ,ghc-text)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-vector-algorithms" ,ghc-vector-algorithms)
+              ("ghc-split" ,ghc-split)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-hunit",ghc-hunit)
+                     ("ghc-quickcheck" ,ghc-quickcheck)
+                     ("ghc-semigroups" ,ghc-semigroups)
+                     ("ghc-foldl" ,ghc-foldl)))
+    (home-page "https://github.com/snoyberg/mono-traversable")
+    (synopsis "Haskell classes for mapping, folding, and traversing monomorphic
+containers")
+    (description "This Haskell package provides Monomorphic variants of the
+Functor, Foldable, and Traversable typeclasses.  If you understand Haskell's
+basic typeclasses, you understand mono-traversable.  In addition to what
+you are used to, it adds on an IsSequence typeclass and has code for marking
+data structures as non-empty.")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 35/38] gnu: ghc-conduit: Update to 1.2.12.1.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-conduit): Update to 1.2.12.1.
[native-inputs]: Add "ghc-split".
---
 gnu/packages/haskell.scm | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index d622ee2e3..1ef26ef52 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -5918,14 +5918,14 @@ of a JSON value into a @code{Data.Aeson.Value}.")
 (define-public ghc-conduit
   (package
     (name "ghc-conduit")
-    (version "1.2.5.1")
+    (version "1.2.12.1")
     (source (origin
               (method url-fetch)
               (uri (string-append "https://hackage.haskell.org/package/"
                                   "conduit/conduit-" version ".tar.gz"))
               (sha256
                (base32
-                "0aq6wswd5dkhdmy7sjhd99mldpq33dqpgbdcwpm94ahvckqxs7v5"))))
+                "0zl6gflh7y36y2vypjhqx13nhkk5y3h12c1zj7kjfclrmwnvnwh0"))))
     (build-system haskell-build-system)
     (inputs
      `(("ghc-exceptions" ,ghc-exceptions)
@@ -5938,7 +5938,8 @@ of a JSON value into a @code{Data.Aeson.Value}.")
     (native-inputs
      `(("ghc-quickcheck" ,ghc-quickcheck)
        ("ghc-hspec" ,ghc-hspec)
-       ("ghc-safe" ,ghc-safe)))
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-split" ,ghc-split)))
     (home-page "https://github.com/snoyberg/conduit")
     (synopsis "Streaming data library ")
     (description
-- 
2.15.0.rc0

[bug#28884] [PATCH 36/38] gnu: ghc-conduit: Fix lint error.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-conduit)[description]: Fix lint error.
---
 gnu/packages/haskell.scm | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 1ef26ef52..c4ce3f40b 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -5943,11 +5943,11 @@ of a JSON value into a @code{Data.Aeson.Value}.")
     (home-page "https://github.com/snoyberg/conduit")
     (synopsis "Streaming data library ")
     (description
-     "conduit is a solution to the streaming data problem, allowing for
-production, transformation, and consumption of streams of data in constant
-memory.  It is an alternative to lazy I/O which guarantees deterministic
-resource handling, and fits in the same general solution space as
-enumerator/iteratee and pipes." )
+     "The conduit package is a solution to the streaming data problem,
+allowing for production, transformation, and consumption of streams of data
+in constant memory.  It is an alternative to lazy I/O which guarantees
+deterministic resource handling, and fits in the same general solution
+space as enumerator/iteratee and pipes.")
     (license license:expat)))
 
 (define-public ghc-logging-facade
-- 
2.15.0.rc0

[bug#28884] [PATCH 37/38] gnu: Add ghc-conduit-combinators.

[rsiddharth]

* gnu/packages/haskell.scm (ghc-condui-combinators): New variable.
---
 gnu/packages/haskell.scm | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index c4ce3f40b..d8fab0909 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -10106,4 +10106,45 @@ you are used to, it adds on an IsSequence typeclass and has code for marking
 data structures as non-empty.")
     (license license:expat)))
 
+(define-public ghc-conduit-combinators
+  (package
+    (name "ghc-conduit-combinators")
+    (version "1.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "conduit-combinators-" version "/"
+                           "conduit-combinators-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0609miq03lq9visfb2dqqsxghmvgzm24pq39mqby1jnnah6yh8m0"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-conduit" ,ghc-conduit)
+              ("ghc-conduit-extra" ,ghc-conduit-extra)
+              ("ghc-transformers-base" ,ghc-transformers-base)
+              ("ghc-primitive" ,ghc-primitive)
+              ("ghc-vector" ,ghc-vector)
+              ("ghc-text" ,ghc-text)
+              ("ghc-void" ,ghc-void)
+              ("ghc-mwc-random" ,ghc-mwc-random)
+              ("ghc-unix-compat" ,ghc-unix-compat)
+              ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+              ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+              ("ghc-resourcet" ,ghc-resourcet)
+              ("ghc-monad-control" ,ghc-monad-control)
+              ("ghc-chunked-data" ,ghc-chunked-data)
+              ("ghc-mono-traversable" ,ghc-mono-traversable)))
+    (native-inputs `(("ghc-hspec" ,ghc-hspec)
+                     ("ghc-silently" ,ghc-silently)
+                     ("ghc-mtl" ,ghc-mtl)
+                     ("ghc-safe" ,ghc-safe)
+                     ("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page "https://github.com/snoyberg/mono-traversable")
+    (synopsis "Commonly used conduit functions, for both chunked and
+unchunked data")
+    (description "This Haskell package provides a replacement for Data.Conduit.List,
+as well as a convenient Conduit module.")
+    (license license:expat)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 38/38] gnu: Add ghc-aws.

[rsiddharth]

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

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index d8fab0909..47423b059 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -10147,4 +10147,62 @@ unchunked data")
 as well as a convenient Conduit module.")
     (license license:expat)))
 
+(define-public ghc-aws
+  (package
+    (name "ghc-aws")
+    (version "0.17.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "aws-" version "/aws-" version ".tar.gz"))
+       (sha256 (base32
+                "1q4qh58vj8447a4fl88n3nkpdc4yv293qsh02w6zvszd6ch61yh7"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; Tests require AWS credentials.
+    (inputs
+     `(("ghc-aeson" ,ghc-aeson)
+       ("ghc-attoparsec" ,ghc-attoparsec)
+       ("ghc-base16-bytestring" ,ghc-base16-bytestring)
+       ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+       ("ghc-blaze-builder" ,ghc-blaze-builder)
+       ("ghc-byteable" ,ghc-byteable)
+       ("ghc-case-insensitive" ,ghc-case-insensitive)
+       ("ghc-cereal" ,ghc-cereal)
+       ("ghc-conduit" ,ghc-conduit)
+       ("ghc-conduit-extra" ,ghc-conduit-extra)
+       ("ghc-cryptohash" ,ghc-cryptohash)
+       ("ghc-data-default" ,ghc-data-default)
+       ("ghc-http-conduit" ,ghc-http-conduit)
+       ("ghc-http-types" ,ghc-http-types)
+       ("ghc-monad-control" ,ghc-monad-control)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-network" ,ghc-network)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-safe" ,ghc-safe)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-text" ,ghc-text)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-utf8-string" ,ghc-utf8-string)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-xml-conduit" ,ghc-xml-conduit)))
+    (native-inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-errors" ,ghc-errors)
+       ("ghc-http-client" ,ghc-http-client)
+       ("ghc-http-client-tls" ,ghc-http-client-tls)
+       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-conduit-combinators" ,ghc-conduit-combinators)))
+    (home-page "https://github.com/aristidb/aws")
+    (synopsis "Amazon Web Services for Haskell")
+    (description "This package attempts to provide support for using
+Amazon Web Services like S3 (storage), SQS (queuing) and others to
+Haskell programmers.  The ultimate goal is to support all Amazon
+Web Services.")
+    (license license:bsd-3)))
+
 ;;; haskell.scm ends here
-- 
2.15.0.rc0

[bug#28884] [PATCH 00/38] Add ghc-aws and its dependencies.

[Ludovic Courtès]

Hello,

rsiddharth <s@ricketyspace.net> skribis:

> This patch series adds `ghc-aws` and its dependencies.

Impressive patch series!

> Patch Notes:
>
>  * The following packages cannot be upgraded to the latest version:
>
>     - ghc-monadrandom: ghc-either 4.4.1.1 requires MonadRandom >=0.1 && <0.5¹
>     - ghc-vector-builder: latest version of this package has dependencies not
>       yet there in guix².

OK.

>  * guix lint has trouble parsing https://hackage.haskell.org/package/entropy/entropy.cabal
>
>      ./pre-inst-env guix lint ghc-entropy
>
>    throws:
>
>      Syntax error: unexpected token : custom-setup (at line 34, column 0)
>      Syntax error: unexpected end of input
>      warning: failed to parse https://hackage.haskell.org/package/entropy/entropy.cabal

That’s harmless: it comes from the new ‘refresh’ check, which checks
whether new versions are available upstream (it does indicate a
limitation of the Cabal parser, though.)

It looks like you run ‘guix lint’ on all the packages, which is great.
I’ll apply the whole series in a day or two if there are no further
comments.

Thank you,
Ludo’.

[bug#28884] [PATCH 07/38] gnu: Add ghc-language-haskell-extract.

[Ludovic Courtès]

[-- Attachment #1: Type: text/plain, Size: 185 bytes --]

rsiddharth <s@ricketyspace.net> skribis:

> * gnu/packages/haskell.scm
> (ghc-language-haskell-extract): New variable.

For the record, I've committed this one with the changes below:


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: text/x-patch, Size: 1638 bytes --]

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 48da78bb9..3b93d8628 --- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9193,48 +9193,10 @@ the local code")
     (description "This package contains helper functions on top of
 Template Haskell.
 
-@code{functionExtractor} extracts all functions after a regexp-pattern.
-
-@verbatim
- foo = \"test\"
- boo = \"testing\"
- bar = $\(functionExtractor \"oo$\")
-@end verbatim
-
-will automagically extract the functions ending with @code{oo} such as
-
-@verbatim
- bar = [\(\"foo\",foo), \(\"boo\",boo)]
-@end verbatim
-
-This can be useful if you wish to extract all functions beginning
-with test \(for a test-framework) or all functions beginning with wc
-\(for a web service).
-
-@code{functionExtractorMap} works like @code{functionsExtractor} but
-applies a function over all function-pairs.
-
-This functions is useful if the common return type of the functions is
-a type class.
-
-Example:
-
-@verbatim
- secondTypeclassTest =
-   do let expected = [\"45\", \"88.8\", \"\\\"hej\\\"\"]
-          actual = $\(functionExtractorMap \"^tc\" [|\\n f -> show f|] )
-      expected @=? actual
-
- tcInt :: Integer
- tcInt = 45
-
- tcDouble :: Double
- tcDouble = 88.8
-
- tcString :: String
- tcString = \"hej\"
-@end verbatim
-")
+For example, @code{functionExtractor} extracts all functions after a
+regexp-pattern, which can be useful if you wish to extract all functions
+beginning with @code{test} (for a test-framework) or all functions beginning
+with @code{wc} (for a web service).")
     (license license:bsd-3)))
 
 ;;; haskell.scm ends here

[-- Attachment #3: Type: text/plain, Size: 12 bytes --]


Ludo’.

[bug#28884] [PATCH 08/38] gnu: Add ghc-test-framework-th.

[Ludovic Courtès]

[-- Attachment #1: Type: text/plain, Size: 208 bytes --]

rsiddharth <s@ricketyspace.net> skribis:

> * gnu/packages/haskell.scm (ghc-test-framework-th): New variable.

Applied after removing the example from the description (see below).

Thanks,
Ludo’.


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: text/x-patch, Size: 1707 bytes --]

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index efcad87c8..298d856ab 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9225,49 +9225,8 @@ using Template Haskell")
 @code{defaultMainGenerator} and @code{testGroupGenerator}.
 
 @code{defaultMainGenerator} will extract all functions beginning with
-case_, prop_ or test_in the module and put them in a testGroup.
-
-@verbatim
- -- file SomeModule.hs
- \( -# LANGUAGE TemplateHaskell #- )
- module SomeModule where
- import Test.Framework.TH
- import Test.Framework
- import Test.HUnit
- import Test.Framework.Providers.HUnit
- import Test.Framework.Providers.QuickCheck2
-
- -- observe this line!
- main = $\(defaultMainGenerator)
- case_1 = do 1 @=? 1
- case_2 = do 2 @=? 2
- prop_reverse xs = reverse \(reverse xs) == xs
-    where types = xs::[Int]
-@end verbatim
-
-   is the same as
-
-@verbatim
- -- file SomeModule.hs
- \( -# LANGUAGE TemplateHaskell #- )
- module SomeModule where
- import Test.Framework.TH
- import Test.Framework
- import Test.HUnit
- import Test.Framework.Providers.HUnit
- import Test.Framework.Providers.QuickCheck2
-
- -- observe this line!
- main =
-   defaultMain [
-     testGroup \"SomeModule\" [ testCase \"1\" case_1, testCase \"2\" \
-case_2, testProperty \"reverse\" prop_reverse]
-     ]
- case_1 = do 1 @=? 1
- case_2 = do 2 @=? 2
- prop_reverse xs = reverse \(reverse xs) == xs
-    where types = xs::[Int]
-@end verbatim
+@code{case_}, @code{prop_}, or @code{test_} in the module and put them in a
+@code{testGroup}.
 
 @code{testGroupGenerator} is like @code{defaultMainGenerator} but without
 @code{defaultMain}.  It is useful if you need a function for the testgroup

[bug#28884] [PATCH 25/38] gnu: Add ghc-puremd5

[Ludovic Courtès]

[-- Attachment #1: Type: text/plain, Size: 121 bytes --]

rsiddharth <s@ricketyspace.net> skribis:

> * gnu/packages/haskell.scm (ghc-puremd5): New variable.

Amended like this:


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: text/x-patch, Size: 740 bytes --]

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index af6b1ee2d..d33963c7d 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9691,8 +9691,7 @@ ByteStrings in the style of other common *nix hex dump tools.")
                       ,ghc-test-framework-quickcheck2)
                      ("ghc-pretty-hex" ,ghc-pretty-hex)))
     (home-page "https://github.com/TomMD/pureMD5")
-    (synopsis "Provides implementation of the MD5 digest (hash) algorithm for
-Haskell")
+    (synopsis "Haskell implementation of the MD5 hash algorithm")
     (description "This package provides a Haskell-only implementation of
 the MD5 digest (hash) algorithm.  This now supports the @code{crypto-api} class
 interface.")

[bug#28884] [PATCH 29/38] gnu: Add ghc-uuid-types.

[Ludovic Courtès]

[-- Attachment #1: Type: text/plain, Size: 125 bytes --]

rsiddharth <s@ricketyspace.net> skribis:

> * gnu/packages/haskell.scm (ghc-uuid-types): New variable.

Adjusted like this:


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: text/x-patch, Size: 931 bytes --]

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index a332e42a6..e3e375e6f 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9800,12 +9800,11 @@ IPv4, IPv6 and MAC addresses.")
                      ("ghc-tasty-hunit" ,ghc-tasty-hunit)
                      ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
     (home-page "https://github.com/hvr/uuid")
-    (synopsis "Provides Type definitions for Universally Unique Identifiers
-for Haskell")
+    (synopsis "Haskell type definitions for UUIDs")
     (description "This Haskell library contains type definitions for
-Universally Unique Identifiers and basic conversion functions.
-
-See @uref{http://en.wikipedia.org/wiki/UUID} for the general idea.")
+@dfn{Universally Unique Identifiers} or
+@uref{http://en.wikipedia.org/wiki/UUID, UUIDs}, and basic conversion
+functions.")
     (license license:bsd-3)))
 
 ;;; haskell.scm ends here

[bug#28884] [PATCH 32/38] gnu: Add ghc-vector-builder.

[Ludovic Courtès]

[-- Attachment #1: Type: text/plain, Size: 130 bytes --]

rsiddharth <s@ricketyspace.net> skribis:

> * gnu/packages/haskell.scm (ghc-vector-builder): New variable.

Removed the example:


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: text/x-patch, Size: 1471 bytes --]

diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 2c4752ac8..9fd28fe05 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -9922,35 +9922,12 @@ the community, with the missing features being added with pull-requests.")
     (home-page "https://github.com/nikita-volkov/vector-builder")
     (synopsis "Vector builder for Haskell")
     (description "This Haskell package provides an API for constructing vectors.
-
 It provides the composable @code{Builder} abstraction, which has instances of the
 @code{Monoid} and @code{Semigroup} classes.
 
-Usage:
-
-First you use the @code{Builder} abstraction to specify the structure of the
-vector.  Then you execute the builder to actually produce the vector.
-
-Example:
-
-The following code shows how you can efficiently concatenate different
-datastructures into a single immutable vector:
-
-@verbatim
-import qualified Data.Vector as A
-import qualified VectorBuilder.Builder as B
-import qualified VectorBuilder.Vector as C
-
-myVector :: A.Vector a -> [a] -> a -> A.Vector a
-myVector vector list element =
- C.build builder
-  where
-    builder =
-      B.vector vector <>
-      foldMap B.singleton list <>
-      B.singleton element
-@end verbatim
-")
+You would first use the @code{Builder} abstraction to specify the structure of
+the vector; then you can execute the builder to actually produce the
+vector. ")
     (license license:expat)))
 
 ;;; haskell.scm ends here

[bug#28884] [PATCH 01/38] gnu: Add ghc-errors.

[Ludovic Courtès]

rsiddharth <s@ricketyspace.net> skribis:

> * gnu/packages/haskell.scm (ghc-errors): New variable.

I added this copyright line for you:

;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>

Let me know if this should be changed.

Ludo’.

bug#28884: [PATCH 00/38] Add ghc-aws and its dependencies.

[Ludovic Courtès]

Heya rsiddharth,

rsiddharth <s@ricketyspace.net> skribis:

> This patch series adds `ghc-aws` and its dependencies.

I’ve now pushed the whole series, with
3a784700cd554c169d81b3013abb2a451f1e64b1 as its tip.

I successfully built ‘ghc-aws’ on my laptop (x86_64-linux,
/gnu/store/h0dwsgqwcq34bxydfk513pyszhb1s09w-ghc-aws-0.17.1).

Thank you!

Ludo’.

[bug#28884] [PATCH 01/38] gnu: Add ghc-errors.

[rsiddharth]

[-- Attachment #1: Type: text/plain, Size: 421 bytes --]

ludo@gnu.org (Ludovic Courtès) writes:

>> * gnu/packages/haskell.scm (ghc-errors): New variable.
>
> I added this copyright line for you:
>
> ;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
>
> Let me know if this should be changed.

Thank you :)

Also thanks for making corrections in ghc-language-haskell-extract,
ghc-test-framework-th, ghc-test-framework-th, ghc-uuid-types,
ghc-vector-builder.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 840 bytes --]