gnu: Move testing packages from haskell to haskell-check.

* gnu/packages/haskell.scm (ghc-clock-bootstrap, ghc-tasty-ant-xml,
ghc-tasty-smallcheck, ghc-tasty-quickcheck, ghc-tasty-golden, ghc-tasty,
ghc-tasty-hunit, ghc-tasty-kat, ghc-tasty-th, ghc-tasty-rerun,
ghc-quickcheck-instances, ghc-quickcheck-unicode, ghc-quickcheck-io,
ghc-quickcheck, ghc-test-framework, ghc-test-framework-hunit,
ghc-test-framework-quickcheck2, ghc-test-framework-th, ghc-hunit,
hspec-discover, ghc-hspec-core, ghc-hspec-meta, ghc-hspec, ghc-hspec-contrib,
ghc-hspec-expectations): Move variables to ...
* gnu/packages/haskell-check.scm: ... this new file.
* gnu/local.mk (GNU_SYSTEM_MODULES): Add it.
* gnu/packages/haskell.scm,
gnu/packages/idris.scm,
gnu/packages/version-control.scm,
gnu/packages/wm.scm: Include haskell-check module.

5 files changed, 732 insertions, 696 deletions

diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm
new file mode 100644
index 0000000000..190ee7cc93
--- /dev/null
+++ b/gnu/packages/haskell-check.scm
@@ -0,0 +1,728 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
+;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
+;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
+;;; Copyright © 2015, 2016, 2017 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2016 ng0 <ng0@infotropique.org>
+;;; Copyright © 2016 David Craven <david@craven.ch>
+;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
+;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
+;;;
+;;; This file is part of GNU Guix.
+;;;
+;;; GNU Guix is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3 of the License, or (at
+;;; your option) any later version.
+;;;
+;;; GNU Guix is distributed in the hope that it will be useful, but
+;;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (gnu packages haskell-check)
+  #:use-module (gnu packages)
+  #:use-module (gnu packages haskell)
+  #:use-module (guix build-system haskell)
+  #:use-module (guix download)
+  #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (guix packages)
+  #:use-module (guix utils))
+
+(define-public ghc-tasty-ant-xml
+  (package
+    (name "ghc-tasty-ant-xml")
+    (version "1.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-generic-deriving" ,ghc-generic-deriving)
+       ("ghc-xml" ,ghc-xml)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-stm" ,ghc-stm)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-tasty" ,ghc-tasty)))
+    (home-page
+     "https://github.com/ocharles/tasty-ant-xml")
+    (synopsis
+     "Render tasty output to XML for Jenkins")
+    (description
+     "A tasty ingredient to output test results in XML, using the Ant
+schema.  This XML can be consumed by the Jenkins continuous integration
+framework.")
+    (license license:bsd-3)))
+
+(define-public ghc-tasty-smallcheck
+  (package
+    (name "ghc-tasty-smallcheck")
+    (version "0.8.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-smallcheck" ,ghc-smallcheck)
+       ("ghc-async" ,ghc-async)
+       ("ghc-tagged" ,ghc-tagged)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "SmallCheck support for the Tasty test framework")
+    (description "This package provides SmallCheck support for the Tasty
+Haskell test framework.")
+    (license license:bsd-3)))
+
+(define-public ghc-tasty-quickcheck
+  (package
+    (name "ghc-tasty-quickcheck")
+    (version "0.8.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty-quickcheck/"
+             "tasty-quickcheck-" version ".tar.gz"))
+       (sha256
+        (base32
+         "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-random" ,ghc-random)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-pcre-light" ,ghc-pcre-light)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "QuickCheck support for the Tasty test framework")
+    (description "This package provides QuickCheck support for the Tasty
+Haskell test framework.")
+    (license license:expat)))
+
+(define-public ghc-tasty-golden
+  (package
+    (name "ghc-tasty-golden")
+    (version "2.3.0.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-temporary" ,ghc-temporary)
+       ("ghc-tasty" ,ghc-tasty)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-async" ,ghc-async)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+       ("ghc-temporary-rc" ,ghc-temporary-rc)))
+    (home-page
+     "https://github.com/feuerbach/tasty-golden")
+    (synopsis "Golden tests support for tasty")
+    (description
+     "This package provides support for 'golden testing'.  A golden test is an
+IO action that writes its result to a file.  To pass the test, this output
+file should be identical to the corresponding 'golden' file, which contains
+the correct result for the test.")
+    (license license:expat)))
+
+;; This package builds `clock` without tests, since the tests rely on tasty
+;; and tasty-quickcheck, which in turn require clock to build.
+(define ghc-clock-bootstrap
+  (package
+    (name "ghc-clock-bootstrap")
+    (version "0.5.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "clock/"
+             "clock-" version ".tar.gz"))
+       (sha256
+        (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
+                               ;; tasty-quickcheck, which need clock to build.
+    (home-page "https://hackage.haskell.org/package/clock")
+    (synopsis "High-resolution clock for Haskell")
+    (description "A package for convenient access to high-resolution clock and
+timer functions of different operating systems via a unified API.")
+    (license license:bsd-3)))
+
+(define-public ghc-tasty
+  (package
+    (name "ghc-tasty")
+    (version "0.11.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty/tasty-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-stm" ,ghc-stm)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-unbounded-delays" ,ghc-unbounded-delays)
+       ("ghc-async" ,ghc-async)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "Modern and extensible testing framework")
+    (description "Tasty is a modern testing framework for Haskell.  It lets
+you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
+and any other types of tests into a single test suite.")
+    (license license:expat)))
+
+(define-public ghc-tasty-hunit
+  (package
+    (name "ghc-tasty-hunit")
+    (version "0.9.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)))
+    (home-page "http://documentup.com/feuerbach/tasty")
+    (synopsis "HUnit support for the Tasty test framework")
+    (description "This package provides HUnit support for the Tasty Haskell
+test framework.")
+    (license license:expat)))
+
+(define-public ghc-tasty-kat
+  (package
+    (name "ghc-tasty-kat")
+    (version "0.0.3")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "tasty-kat/tasty-kat-" version ".tar.gz"))
+              (sha256
+               (base32
+                "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)
+       ("ghc-mtl" ,ghc-mtl)
+       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+    (home-page "https://github.com/vincenthz/tasty-kat")
+    (synopsis "Known Answer Tests (KAT) framework for tasty")
+    (description
+     "This package provides a @dfn{Known Answer Tests} (KAT) framework for
+tasty.")
+    (license license:expat)))
+
+(define-public ghc-tasty-th
+  (package
+    (name "ghc-tasty-th")
+    (version "0.1.4")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/tasty-th/tasty-th-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-tasty" ,ghc-tasty)))
+    (home-page "https://github.com/bennofs/tasty-th")
+    (synopsis "Automatically generate tasty TestTrees")
+    (description
+      "Tasty-th automatically generates tasty TestTrees from functions of the
+current module, using TemplateHaskell.  This is a fork the original
+test-framework-th package, modified to work with tasty instead of
+test-framework.")
+    (license license:bsd-3)))
+
+(define-public ghc-tasty-rerun
+  (package
+    (name "ghc-tasty-rerun")
+    (version "1.1.6")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "https://hackage.haskell.org/package/tasty-rerun/"
+                    "tasty-rerun-" version ".tar.gz"))
+              (sha256
+               (base32
+                "0ycxg7whabgcxyzy6gr536x8ykzx45whh1wrbsc7c58zi862fczd"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-mtl" ,ghc-mtl)
+       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+       ("ghc-reducers" ,ghc-reducers)
+       ("ghc-split" ,ghc-split)
+       ("ghc-stm" ,ghc-stm)
+       ("ghc-tagged" ,ghc-tagged)
+       ("ghc-tasty" ,ghc-tasty)))
+    (home-page "https://github.com/ocharles/tasty-rerun")
+    (synopsis "Run tests by filtering the test tree")
+    (description "This package adds the ability to run tests by filtering the
+test tree based on the result of a previous test run.  You can use this to run
+only those tests that failed in the last run, or to only run the tests that have
+been added since previous test run.")
+  (license license:bsd-3)))
+
+(define-public ghc-quickcheck-instances
+  (package
+    (name "ghc-quickcheck-instances")
+    (version "0.3.12")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/"
+             "quickcheck-instances/quickcheck-instances-"
+             version ".tar.gz"))
+       (sha256
+        (base32
+         "1wwvkzpams7i0j7nk5qj8vvhj8x5zcbgbgrpczszgvshva4bkmfx"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-old-time" ,ghc-old-time)
+       ("ghc-unordered-containers" ,ghc-unordered-containers)
+       ("ghc-hashable" ,ghc-hashable)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-scientific" ,ghc-scientific)
+       ("ghc-vector" ,ghc-vector)
+       ("ghc-text" ,ghc-text)))
+    (home-page
+     "https://github.com/aslatter/qc-instances")
+    (synopsis "Common quickcheck instances")
+    (description "This package provides QuickCheck instances for types
+provided by the Haskell Platform.")
+    (license license:bsd-3)))
+
+(define-public ghc-quickcheck-unicode
+  (package
+    (name "ghc-quickcheck-unicode")
+    (version "1.0.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+    (home-page
+     "https://github.com/bos/quickcheck-unicode")
+    (synopsis "Generator functions Unicode-related tests")
+    (description "This package provides generator and shrink functions for
+testing Unicode-related software.")
+    (license license:bsd-3)))
+
+(define-public ghc-quickcheck-io
+  (package
+    (name "ghc-quickcheck-io")
+    (version "0.1.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)))
+    (home-page
+     "https://github.com/hspec/quickcheck-io#readme")
+    (synopsis "Use HUnit assertions as QuickCheck properties")
+    (description "This package provides an orphan instance that allows you to
+use HUnit assertions as QuickCheck properties.")
+    (license license:expat)))
+
+(define-public ghc-quickcheck
+  (package
+    (name "ghc-quickcheck")
+    (version "2.8.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1ai6k5v0bibaxq8xffcblc6rwmmk6gf8vjyd9p2h3y6vwbhlvilq"))))
+    (build-system haskell-build-system)
+    (arguments
+     `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
+       #:configure-flags '("-f base4")))
+    (inputs
+     `(("ghc-tf-random" ,ghc-tf-random)))
+    (home-page
+     "https://github.com/nick8325/quickcheck")
+    (synopsis
+     "Automatic testing of Haskell programs")
+    (description
+     "QuickCheck is a library for random testing of program properties.")
+    (license license:bsd-3)))
+
+(define-public ghc-test-framework
+  (package
+    (name "ghc-test-framework")
+    (version "0.8.1.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/test-framework/"
+                           "test-framework-" version ".tar.gz"))
+       (sha256
+        (base32
+         "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
+    (build-system haskell-build-system)
+    (native-inputs
+     `(("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (inputs
+     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+       ("ghc-hostname" ,ghc-hostname)
+       ("ghc-old-locale" ,ghc-old-locale)
+       ("ghc-random" ,ghc-random)
+       ("ghc-regex-posix" ,ghc-regex-posix)
+       ("ghc-xml" ,ghc-xml)
+       ("ghc-libxml" ,ghc-libxml)))
+    (home-page "https://batterseapower.github.io/test-framework/")
+    (synopsis "Framework for running and organising tests")
+    (description
+     "This package allows tests such as QuickCheck properties and HUnit test
+cases to be assembled into test groups, run in parallel (but reported in
+deterministic order, to aid diff interpretation) and filtered and controlled
+by command line options.  All of this comes with colored test output, progress
+reporting and test statistics output.")
+    (license license:bsd-3)))
+
+(define-public ghc-test-framework-hunit
+  (package
+    (name "ghc-test-framework-hunit")
+    (version "0.3.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "test-framework-hunit/test-framework-hunit-"
+                           version ".tar.gz"))
+       (sha256
+        (base32
+         "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-test-framework" ,ghc-test-framework)))
+    (home-page "https://batterseapower.github.io/test-framework/")
+    (synopsis "HUnit support for test-framework")
+    (description
+     "This package provides HUnit support for the test-framework package.")
+    (license license:bsd-3)))
+
+(define-public ghc-test-framework-quickcheck2
+  (package
+    (name "ghc-test-framework-quickcheck2")
+    (version "0.3.0.3")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://hackage.haskell.org/package/"
+                           "test-framework-quickcheck2/"
+                           "test-framework-quickcheck2-" version ".tar.gz"))
+       (sha256
+        (base32
+         "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
+       (modules '((guix build utils)))
+       (snippet
+        ;; The Hackage page and the cabal file linked there for this package
+        ;; both list 2.9 as the upper version limit, but the source tarball
+        ;; specifies 2.8.  Assume the Hackage page is correct.
+        '(substitute* "test-framework-quickcheck2.cabal"
+           (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-random" ,ghc-random)
+       ("ghc-test-framework" ,ghc-test-framework)))
+    (home-page "https://batterseapower.github.io/test-framework/")
+    (synopsis "QuickCheck2 support for test-framework")
+    (description
+     "This packages provides QuickCheck2 support for the test-framework
+package.")
+    (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
+@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
+\(e.g. if you want to be able to call the testgroup from another module).")
+    (license license:bsd-3)))
+
+(define-public ghc-hunit
+  (package
+    (name "ghc-hunit")
+    (version "1.2.5.2")
+    (outputs '("out" "doc"))
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/HUnit/HUnit-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
+    (build-system haskell-build-system)
+    (home-page "http://hunit.sourceforge.net/")
+    (synopsis "Unit testing framework for Haskell")
+    (description
+     "HUnit is a unit testing framework for Haskell, inspired by the
+JUnit tool for Java.")
+    (license license:bsd-3)))
+
+(define-public hspec-discover
+  (package
+    (name "hspec-discover")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hspec-discover/hspec-discover-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
+    (build-system haskell-build-system)
+    (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
+                                 ; documentation files.
+    (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Automatically discover and run Hspec tests")
+    (description "hspec-discover is a tool which automatically discovers and
+runs Hspec tests.")
+    (license license:expat)))
+
+(define-public ghc-hspec-core
+  (package
+    (name "ghc-hspec-core")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hspec-core/hspec-core-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
+    (build-system haskell-build-system)
+    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+    (inputs
+     `(("ghc-setenv" ,ghc-setenv)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-async" ,ghc-async)
+       ("ghc-quickcheck-io" ,ghc-quickcheck-io)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-silently" ,ghc-silently)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Testing framework for Haskell")
+    (description "This library exposes internal types and functions that can
+be used to extend Hspec's functionality.")
+    (license license:expat)))
+
+(define-public ghc-hspec-meta
+  (package
+    (name "ghc-hspec-meta")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hspec-meta/hspec-meta-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
+       ("ghc-async" ,ghc-async)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-setenv" ,ghc-setenv)
+       ("ghc-random" ,ghc-random)
+       ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Version of Hspec to test Hspec itself")
+    (description "This library provides a stable version of Hspec which is
+used to test the in-development version of Hspec.")
+    (license license:expat)))
+
+(define-public ghc-hspec
+  (package
+    (name "ghc-hspec")
+    (version "2.2.0")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hspec/hspec-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hspec-core" ,ghc-hspec-core)
+       ("hspec-discover" ,hspec-discover)
+       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+       ("ghc-quickcheck" ,ghc-quickcheck)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-stringbuilder" ,ghc-stringbuilder)
+       ("ghc-hspec-meta" ,ghc-hspec-meta)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Testing Framework for Haskell")
+    (description "This library provides the Hspec testing framework for
+Haskell, inspired by the Ruby library RSpec.")
+    (license license:expat)))
+
+(define-public ghc-hspec-contrib
+  (package
+    (name "ghc-hspec-contrib")
+    (version "0.3.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://hackage.haskell.org/package/"
+                                  "hspec-contrib/hspec-contrib-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
+    (build-system haskell-build-system)
+    (inputs
+     `(("ghc-hspec-core" ,ghc-hspec-core)
+       ("ghc-hunit" ,ghc-hunit)
+       ("ghc-hspec" ,ghc-hspec)
+       ("ghc-quickcheck" ,ghc-quickcheck)))
+    (native-inputs
+     `(("hspec-discover" ,hspec-discover)))
+    (home-page "http://hspec.github.io/")
+    (synopsis "Contributed functionality for Hspec")
+    (description
+     "This package provides contributed Hspec extensions.")
+    (license license:expat)))
+
+(define-public ghc-hspec-expectations
+  (package
+    (name "ghc-hspec-expectations")
+    (version "0.7.2")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
+             version
+             ".tar.gz"))
+       (sha256
+        (base32
+         "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
+    (build-system haskell-build-system)
+    (inputs `(("ghc-hunit" ,ghc-hunit)))
+    (home-page "https://github.com/sol/hspec-expectations")
+    (synopsis "Catchy combinators for HUnit")
+    (description "This library provides catchy combinators for HUnit, see
+@uref{https://github.com/sol/hspec-expectations#readme, the README}.")
+    (license license:expat)))
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 87e60a8861..68324b1210 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -36,6 +36,7 @@
   #:use-module (gnu packages gcc)
   #:use-module (gnu packages ghostscript)
   #:use-module (gnu packages gl)
+  #:use-module (gnu packages haskell-check)
   #:use-module (gnu packages libffi)
   #:use-module (gnu packages lisp)
   #:use-module (gnu packages lua)
@@ -1944,29 +1945,6 @@ implementation is pure Haskell, so it might be a bit slower than a C FFI
 binding.")
     (license license:bsd-3)))
 
-(define-public ghc-hunit
-  (package
-    (name "ghc-hunit")
-    (version "1.2.5.2")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/HUnit/HUnit-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
-    (build-system haskell-build-system)
-    (home-page "http://hunit.sourceforge.net/")
-    (synopsis "Unit testing framework for Haskell")
-    (description
-     "HUnit is a unit testing framework for Haskell, inspired by the
-JUnit tool for Java.")
-    (license license:bsd-3)))
-
 (define-public ghc-random
   (package
     (name "ghc-random")
@@ -2011,98 +1989,6 @@ library, including the ability to split random number generators.")
      "This package provides various primitive memory-related operations.")
     (license license:bsd-3)))
 
-(define-public ghc-test-framework
-  (package
-    (name "ghc-test-framework")
-    (version "0.8.1.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/test-framework/"
-                           "test-framework-" version ".tar.gz"))
-       (sha256
-        (base32
-         "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
-    (build-system haskell-build-system)
-    (native-inputs
-     `(("ghc-hunit" ,ghc-hunit)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
-    (inputs
-     `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
-       ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
-       ("ghc-hostname" ,ghc-hostname)
-       ("ghc-old-locale" ,ghc-old-locale)
-       ("ghc-random" ,ghc-random)
-       ("ghc-regex-posix" ,ghc-regex-posix)
-       ("ghc-xml" ,ghc-xml)
-       ("ghc-libxml" ,ghc-libxml)))
-    (home-page "https://batterseapower.github.io/test-framework/")
-    (synopsis "Framework for running and organising tests")
-    (description
-     "This package allows tests such as QuickCheck properties and HUnit test
-cases to be assembled into test groups, run in parallel (but reported in
-deterministic order, to aid diff interpretation) and filtered and controlled
-by command line options.  All of this comes with colored test output, progress
-reporting and test statistics output.")
-    (license license:bsd-3)))
-
-(define-public ghc-test-framework-hunit
-  (package
-    (name "ghc-test-framework-hunit")
-    (version "0.3.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "test-framework-hunit/test-framework-hunit-"
-                           version ".tar.gz"))
-       (sha256
-        (base32
-         "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-test-framework" ,ghc-test-framework)))
-    (home-page "https://batterseapower.github.io/test-framework/")
-    (synopsis "HUnit support for test-framework")
-    (description
-     "This package provides HUnit support for the test-framework package.")
-    (license license:bsd-3)))
-
-(define-public ghc-test-framework-quickcheck2
-  (package
-    (name "ghc-test-framework-quickcheck2")
-    (version "0.3.0.3")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://hackage.haskell.org/package/"
-                           "test-framework-quickcheck2/"
-                           "test-framework-quickcheck2-" version ".tar.gz"))
-       (sha256
-        (base32
-         "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
-       (modules '((guix build utils)))
-       (snippet
-        ;; The Hackage page and the cabal file linked there for this package
-        ;; both list 2.9 as the upper version limit, but the source tarball
-        ;; specifies 2.8.  Assume the Hackage page is correct.
-        '(substitute* "test-framework-quickcheck2.cabal"
-           (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
-       ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-random" ,ghc-random)
-       ("ghc-test-framework" ,ghc-test-framework)))
-    (home-page "https://batterseapower.github.io/test-framework/")
-    (synopsis "QuickCheck2 support for test-framework")
-    (description
-     "This packages provides QuickCheck2 support for the test-framework
-package.")
-    (license license:bsd-3)))
-
 (define-public ghc-tf-random
   (package
     (name "ghc-tf-random")
@@ -3020,64 +2906,6 @@ properties for all test cases up to some depth.  The test cases are generated
 automatically by SmallCheck.")
     (license license:bsd-3)))
 
-(define-public ghc-tasty-ant-xml
-  (package
-    (name "ghc-tasty-ant-xml")
-    (version "1.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-generic-deriving" ,ghc-generic-deriving)
-       ("ghc-xml" ,ghc-xml)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-stm" ,ghc-stm)
-       ("ghc-tagged" ,ghc-tagged)
-       ("ghc-tasty" ,ghc-tasty)))
-    (home-page
-     "https://github.com/ocharles/tasty-ant-xml")
-    (synopsis
-     "Render tasty output to XML for Jenkins")
-    (description
-     "A tasty ingredient to output test results in XML, using the Ant
-schema.  This XML can be consumed by the Jenkins continuous integration
-framework.")
-    (license license:bsd-3)))
-
-(define-public ghc-tasty-smallcheck
-  (package
-    (name "ghc-tasty-smallcheck")
-    (version "0.8.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-tasty" ,ghc-tasty)
-       ("ghc-smallcheck" ,ghc-smallcheck)
-       ("ghc-async" ,ghc-async)
-       ("ghc-tagged" ,ghc-tagged)))
-    (home-page "http://documentup.com/feuerbach/tasty")
-    (synopsis "SmallCheck support for the Tasty test framework")
-    (description "This package provides SmallCheck support for the Tasty
-Haskell test framework.")
-    (license license:bsd-3)))
-
 (define-public ghc-silently
   (package
     (name "ghc-silently")
@@ -3102,113 +2930,6 @@ Haskell test framework.")
 writing to stdout and other handles.")
     (license license:bsd-3)))
 
-(define-public ghc-quickcheck-instances
-  (package
-    (name "ghc-quickcheck-instances")
-    (version "0.3.12")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/"
-             "quickcheck-instances/quickcheck-instances-"
-             version ".tar.gz"))
-       (sha256
-        (base32
-         "1wwvkzpams7i0j7nk5qj8vvhj8x5zcbgbgrpczszgvshva4bkmfx"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-old-time" ,ghc-old-time)
-       ("ghc-unordered-containers" ,ghc-unordered-containers)
-       ("ghc-hashable" ,ghc-hashable)
-       ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-scientific" ,ghc-scientific)
-       ("ghc-vector" ,ghc-vector)
-       ("ghc-text" ,ghc-text)))
-    (home-page
-     "https://github.com/aslatter/qc-instances")
-    (synopsis "Common quickcheck instances")
-    (description "This package provides QuickCheck instances for types
-provided by the Haskell Platform.")
-    (license license:bsd-3)))
-
-(define-public ghc-quickcheck-unicode
-  (package
-    (name "ghc-quickcheck-unicode")
-    (version "1.0.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
-    (build-system haskell-build-system)
-    (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
-    (home-page
-     "https://github.com/bos/quickcheck-unicode")
-    (synopsis "Generator functions Unicode-related tests")
-    (description "This package provides generator and shrink functions for
-testing Unicode-related software.")
-    (license license:bsd-3)))
-
-(define-public ghc-quickcheck-io
-  (package
-    (name "ghc-quickcheck-io")
-    (version "0.1.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-hunit" ,ghc-hunit)))
-    (home-page
-     "https://github.com/hspec/quickcheck-io#readme")
-    (synopsis "Use HUnit assertions as QuickCheck properties")
-    (description "This package provides an orphan instance that allows you to
-use HUnit assertions as QuickCheck properties.")
-    (license license:expat)))
-
-(define-public ghc-quickcheck
-  (package
-    (name "ghc-quickcheck")
-    (version "2.8.2")
-    (outputs '("out" "doc"))
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1ai6k5v0bibaxq8xffcblc6rwmmk6gf8vjyd9p2h3y6vwbhlvilq"))))
-    (build-system haskell-build-system)
-    (arguments
-     `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
-       #:configure-flags '("-f base4")))
-    (inputs
-     `(("ghc-tf-random" ,ghc-tf-random)))
-    (home-page
-     "https://github.com/nick8325/quickcheck")
-    (synopsis
-     "Automatic testing of Haskell programs")
-    (description
-     "QuickCheck is a library for random testing of program properties.")
-    (license license:bsd-3)))
-
 (define-public ghc-case-insensitive
   (package
     (name "ghc-case-insensitive")
@@ -3722,168 +3443,6 @@ lets you set up HTTP connections, transmitting requests and processing the
 responses coming back.")
     (license license:bsd-3)))
 
-(define-public ghc-hspec
-  (package
-    (name "ghc-hspec")
-    (version "2.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/hspec/hspec-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-hspec-core" ,ghc-hspec-core)
-       ("hspec-discover" ,hspec-discover)
-       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
-       ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-stringbuilder" ,ghc-stringbuilder)
-       ("ghc-hspec-meta" ,ghc-hspec-meta)))
-    (home-page "http://hspec.github.io/")
-    (synopsis "Testing Framework for Haskell")
-    (description "This library provides the Hspec testing framework for
-Haskell, inspired by the Ruby library RSpec.")
-    (license license:expat)))
-
-(define-public ghc-hspec-contrib
-  (package
-    (name "ghc-hspec-contrib")
-    (version "0.3.0")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "hspec-contrib/hspec-contrib-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-hspec-core" ,ghc-hspec-core)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-hspec" ,ghc-hspec)
-       ("ghc-quickcheck" ,ghc-quickcheck)))
-    (native-inputs
-     `(("hspec-discover" ,hspec-discover)))
-    (home-page "http://hspec.github.io/")
-    (synopsis "Contributed functionality for Hspec")
-    (description
-     "This package provides contributed Hspec extensions.")
-    (license license:expat)))
-
-(define-public ghc-hspec-expectations
-  (package
-    (name "ghc-hspec-expectations")
-    (version "0.7.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
-    (build-system haskell-build-system)
-    (inputs `(("ghc-hunit" ,ghc-hunit)))
-    (home-page "https://github.com/sol/hspec-expectations")
-    (synopsis "Catchy combinators for HUnit")
-    (description "This library provides catchy combinators for HUnit, see
-@uref{https://github.com/sol/hspec-expectations#readme, the README}.")
-    (license license:expat)))
-
-(define-public hspec-discover
-  (package
-    (name "hspec-discover")
-    (version "2.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/hspec-discover/hspec-discover-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
-    (build-system haskell-build-system)
-    (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
-                                 ; documentation files.
-    (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
-    (home-page "http://hspec.github.io/")
-    (synopsis "Automatically discover and run Hspec tests")
-    (description "hspec-discover is a tool which automatically discovers and
-runs Hspec tests.")
-    (license license:expat)))
-
-(define-public ghc-hspec-core
-  (package
-    (name "ghc-hspec-core")
-    (version "2.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/hspec-core/hspec-core-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
-    (build-system haskell-build-system)
-    (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
-    (inputs
-     `(("ghc-setenv" ,ghc-setenv)
-       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
-       ("ghc-async" ,ghc-async)
-       ("ghc-quickcheck-io" ,ghc-quickcheck-io)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
-       ("ghc-silently" ,ghc-silently)))
-    (home-page "http://hspec.github.io/")
-    (synopsis "Testing framework for Haskell")
-    (description "This library exposes internal types and functions that can
-be used to extend Hspec's functionality.")
-    (license license:expat)))
-
-(define-public ghc-hspec-meta
-  (package
-    (name "ghc-hspec-meta")
-    (version "2.2.0")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/hspec-meta/hspec-meta-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-hunit" ,ghc-hunit)
-       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
-       ("ghc-async" ,ghc-async)
-       ("ghc-hspec-expectations" ,ghc-hspec-expectations)
-       ("ghc-setenv" ,ghc-setenv)
-       ("ghc-random" ,ghc-random)
-       ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
-    (home-page "http://hspec.github.io/")
-    (synopsis "Version of Hspec to test Hspec itself")
-    (description "This library provides a stable version of Hspec which is
-used to test the in-development version of Hspec.")
-    (license license:expat)))
-
 (define-public ghc-vault
   (package
     (name "ghc-vault")
@@ -4370,31 +3929,6 @@ or timeout period.  This package provides alternative functions which use the
 unbounded @code{Integer} type.")
     (license license:bsd-3)))
 
-;; This package builds `clock` without tests, since the tests rely on tasty
-;; and tasty-quickcheck, which in turn require clock to build.  When tasty and
-;; tasty-quickcheck are added, we will add ghc-clock with tests enabled.
-(define ghc-clock-bootstrap
-  (package
-    (name "ghc-clock-bootstrap")
-    (version "0.5.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/"
-             "clock/"
-             "clock-" version ".tar.gz"))
-       (sha256
-        (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
-    (build-system haskell-build-system)
-    (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
-                               ;; tasty-quickcheck, which need clock to build.
-    (home-page "https://hackage.haskell.org/package/clock")
-    (synopsis "High-resolution clock for Haskell")
-    (description "A package for convenient access to high-resolution clock and
-timer functions of different operating systems via a unified API.")
-    (license license:bsd-3)))
-
 (define-public ghc-clock
   (package
     (name "ghc-clock")
@@ -5060,123 +4594,6 @@ functions for breaking or splitting on substrings and replacing all
 occurrences of a substring (the first in case of overlaps) with another.")
     (license license:bsd-3)))
 
-(define-public ghc-tasty-quickcheck
-  (package
-    (name "ghc-tasty-quickcheck")
-    (version "0.8.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty-quickcheck/"
-             "tasty-quickcheck-" version ".tar.gz"))
-       (sha256
-        (base32
-         "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-quickcheck" ,ghc-quickcheck)
-       ("ghc-tagged" ,ghc-tagged)
-       ("ghc-tasty" ,ghc-tasty)
-       ("ghc-random" ,ghc-random)
-       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
-       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-       ("ghc-pcre-light" ,ghc-pcre-light)))
-    (home-page "http://documentup.com/feuerbach/tasty")
-    (synopsis "QuickCheck support for the Tasty test framework")
-    (description "This package provides QuickCheck support for the Tasty
-Haskell test framework.")
-    (license license:expat)))
-
-(define-public ghc-tasty-golden
-  (package
-    (name "ghc-tasty-golden")
-    (version "2.3.0.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-temporary" ,ghc-temporary)
-       ("ghc-tasty" ,ghc-tasty)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
-       ("ghc-tagged" ,ghc-tagged)
-       ("ghc-async" ,ghc-async)
-       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
-       ("ghc-temporary-rc" ,ghc-temporary-rc)))
-    (home-page
-     "https://github.com/feuerbach/tasty-golden")
-    (synopsis "Golden tests support for tasty")
-    (description
-     "This package provides support for 'golden testing'.  A golden test is an
-IO action that writes its result to a file.  To pass the test, this output
-file should be identical to the corresponding 'golden' file, which contains
-the correct result for the test.")
-    (license license:expat)))
-
-(define-public ghc-tasty
-  (package
-    (name "ghc-tasty")
-    (version "0.11.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty/tasty-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-stm" ,ghc-stm)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-tagged" ,ghc-tagged)
-       ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
-       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
-       ("ghc-unbounded-delays" ,ghc-unbounded-delays)
-       ("ghc-async" ,ghc-async)
-       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
-       ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
-    (home-page "http://documentup.com/feuerbach/tasty")
-    (synopsis "Modern and extensible testing framework")
-    (description "Tasty is a modern testing framework for Haskell.  It lets
-you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
-and any other types of tests into a single test suite.")
-    (license license:expat)))
-
-(define-public ghc-tasty-hunit
-  (package
-    (name "ghc-tasty-hunit")
-    (version "0.9.2")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
-             version
-             ".tar.gz"))
-       (sha256
-        (base32
-         "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-tasty" ,ghc-tasty)))
-    (home-page "http://documentup.com/feuerbach/tasty")
-    (synopsis "HUnit support for the Tasty test framework")
-    (description "This package provides HUnit support for the Tasty Haskell
-test framework.")
-    (license license:expat)))
-
 (define-public ghc-cookie
   (package
     (name "ghc-cookie")
@@ -6399,30 +5816,6 @@ distances for fuzzy matching, including Levenshtein and restricted
 Damerau-Levenshtein algorithms.")
     (license license:bsd-3)))
 
-(define-public ghc-tasty-kat
-  (package
-    (name "ghc-tasty-kat")
-    (version "0.0.3")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "https://hackage.haskell.org/package/"
-                                  "tasty-kat/tasty-kat-" version ".tar.gz"))
-              (sha256
-               (base32
-                "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-tasty" ,ghc-tasty)
-       ("ghc-mtl" ,ghc-mtl)
-       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
-       ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
-    (home-page "https://github.com/vincenthz/tasty-kat")
-    (synopsis "Known Answer Tests (KAT) framework for tasty")
-    (description
-     "This package provides a @dfn{Known Answer Tests} (KAT) framework for
-tasty.")
-    (license license:expat)))
-
 (define-public ghc-cryptonite
   (package
     (name "ghc-cryptonite")
@@ -7225,31 +6618,6 @@ This is not good for Unicode users.  This modified regex-compat uses regex-tdfa
 this problem.")
     (license license:bsd-3)))
 
-(define-public ghc-tasty-th
-  (package
-    (name "ghc-tasty-th")
-    (version "0.1.4")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://hackage.haskell.org/package/tasty-th/tasty-th-"
-             version ".tar.gz"))
-       (sha256
-        (base32
-         "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-tasty" ,ghc-tasty)))
-    (home-page "https://github.com/bennofs/tasty-th")
-    (synopsis "Automatically generate tasty TestTrees")
-    (description
-      "Tasty-th automatically generates tasty TestTrees from functions of the
-current module, using TemplateHaskell.  This is a fork the original
-test-framework-th package, modified to work with tasty instead of
-test-framework.")
-    (license license:bsd-3)))
-
 (define-public ghc-sandi
   (package
     (name "ghc-sandi")
@@ -8348,35 +7716,6 @@ deletion notification. This library builds upon existing libraries for platform
 specific Windows, Mac, and Linux filesystem event notification.")
     (license license:bsd-3)))
 
-(define-public ghc-tasty-rerun
-  (package
-    (name "ghc-tasty-rerun")
-    (version "1.1.6")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append
-                    "https://hackage.haskell.org/package/tasty-rerun/"
-                    "tasty-rerun-" version ".tar.gz"))
-              (sha256
-               (base32
-                "0ycxg7whabgcxyzy6gr536x8ykzx45whh1wrbsc7c58zi862fczd"))))
-    (build-system haskell-build-system)
-    (inputs
-     `(("ghc-mtl" ,ghc-mtl)
-       ("ghc-optparse-applicative" ,ghc-optparse-applicative)
-       ("ghc-reducers" ,ghc-reducers)
-       ("ghc-split" ,ghc-split)
-       ("ghc-stm" ,ghc-stm)
-       ("ghc-tagged" ,ghc-tagged)
-       ("ghc-tasty" ,ghc-tasty)))
-    (home-page "https://github.com/ocharles/tasty-rerun")
-    (synopsis "Run tests by filtering the test tree")
-    (description "This package adds the ability to run tests by filtering the
-test tree based on the result of a previous test run.  You can use this to run
-only those tests that failed in the last run, or to only run the tests that have
-been added since previous test run.")
-  (license license:bsd-3)))
-
 (define-public ghc-ieee754
   (package
     (name "ghc-ieee754")
@@ -9201,40 +8540,6 @@ beginning with @code{test} (for a test framework) or all functions beginning
 with @code{wc} (for a web service).")
     (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
-@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
-\(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")
diff --git a/gnu/packages/idris.scm b/gnu/packages/idris.scm
index de9b5dd1d0..438e582fe3 100644
--- a/gnu/packages/idris.scm
+++ b/gnu/packages/idris.scm
@@ -19,6 +19,7 @@
 
 (define-module (gnu packages idris)
   #:use-module (gnu packages haskell)
+  #:use-module (gnu packages haskell-check)
   #:use-module (gnu packages multiprecision)
   #:use-module (gnu packages ncurses)
   #:use-module (guix build-system gnu)
diff --git a/gnu/packages/version-control.scm b/gnu/packages/version-control.scm
index 7f50af1390..6ef3f8b060 100644
--- a/gnu/packages/version-control.scm
+++ b/gnu/packages/version-control.scm
@@ -59,6 +59,7 @@
   #:use-module (gnu packages gettext)
   #:use-module (gnu packages groff)
   #:use-module (gnu packages haskell)
+  #:use-module (gnu packages haskell-check)
   #:use-module (gnu packages java)
   #:use-module (gnu packages linux)
   #:use-module (gnu packages nano)
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index 09c10eaa0e..cdffb0d852 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -42,6 +42,7 @@
   #:use-module (guix build-system perl)
   #:use-module (guix build-system python)
   #:use-module (gnu packages haskell)
+  #:use-module (gnu packages haskell-check)
   #:use-module (gnu packages base)
   #:use-module (gnu packages pkg-config)
   #:use-module (gnu packages perl)