Hackage :: [Package]

quickcheck-classes: QuickCheck common typeclasses

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

Warnings:

This library provides QuickCheck properties to ensure that typeclass instances adhere to the set of laws that they are supposed to. There are other libraries that do similar things, such as `genvalidity-hspec` and checkers. This library differs from other solutions by not introducing any new typeclasses that the user needs to learn.

Note: on GHC < 8.5, this library uses the higher-kinded typeclasses (Data.Functor.Classes.Show1, Data.Functor.Classes.Eq1, Data.Functor.Classes.Ord1, etc.), but on GHC >= 8.5, it uses `-XQuantifiedConstraints` to express these constraints more cleanly.

[Skip to Readme]

Properties

Versions 0.1, 0.2, 0.3, 0.3.1, 0.3.2, 0.3.3, 0.4.0, 0.4.1, 0.4.2, 0.4.3, 0.4.4, 0.4.5, 0.4.6, 0.4.7, 0.4.8, 0.4.9, 0.4.10, 0.4.11, 0.4.11.1, 0.4.12, 0.4.13, 0.4.14, 0.4.14.1, 0.4.14.2, 0.4.14.3, 0.5.0.0, 0.6.0.0, 0.6.1.0, 0.6.1.0, 0.6.2.0, 0.6.2.1, 0.6.2.2, 0.6.3.0, 0.6.4.0, 0.6.5.0
Change log changelog.md
Dependencies aeson (>=0.9), base (>=4.5 && <5), base-orphans (>=0.1), bifunctors, containers (>=0.4.2.1), fail, ghc-prim, primitive (>=0.6.1 && <0.7), QuickCheck (>=2.10.0), semigroupoids, semigroups (>=0.17), semirings (>=0.3.1.1), tagged, transformers (>=0.5.0 && <0.6), vector (>=0.12) [details]
License BSD-3-Clause
Copyright 2018 Andrew Martin
Author Andrew Martin, chessai
Maintainer andrew.thaddeus@gmail.com
Category Testing
Home page https://github.com/andrewthad/quickcheck-classes#readme
Source repo head: git clone https://github.com/andrewthad/quickcheck-classes
Uploaded by chessai at 2019-01-13T00:41:15Z

Modules

[Index] [Quick Jump]

Flags

Manual Flags

NameDescriptionDefault
aeson

You can disable the use of the aeson package using `-f-aeson`.

This may be useful for accelerating builds in sandboxes for expert users.

Enabled
semigroupoids

You can disable the use of the semigroupoids package using `-f-semigroupoids`.

This may be useful for accelerating builds in sandboxes for expert users.

Enabled
semirings

You can disable the use of the semirings package using `-f-semirings`.

This may be useful for accelerating builds in sandboxes for expert users.

Enabled
vector

You can disable the use of the vector package using `-f-vector`.

This may be useful for accelerating builds in sandboxes for expert users.

Enabled
unary-laws

Include infrastructure for testing class laws of unary type constructors.

Enabled
binary-laws

Include infrastructure for testing class laws of binary type constructors. Disabling `unary-laws` while keeping `binary-laws` enabled is an unsupported configuration.

Enabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Readme for quickcheck-classes-0.6.1.0

[back to package description]

quickcheck-classes

This library provides sets of properties that should hold for common typeclasses, along with three (3) simple functions that you can use to test them.

lawsCheck:

A convenience function for testing properties in GHCi. For example, at GHCi:

>>> lawsCheck (monoidLaws (Proxy :: Proxy Ordering))
Monoid: Associative +++ OK, passed 100 tests.
Monoid: Left Identity +++ OK, passed 100 tests.
Monoid: Right Identity +++ OK, passed 100 tests.

Assuming that the Arbitrary instance for Ordering is good, we now have confidence that the Monoid instance for Ordering satisfies the monoid laws.

lawsCheckMany:

A convenience function for checking multiple typeclass instances of multiple types. Consider the following Haskell source file:

import Data.Proxy (Proxy(..))
import Data.Map (Map)
import Data.Set (Set)

-- A 'Proxy' for 'Set' 'Int'. 
setInt :: Proxy (Set Int)
setInt = Proxy

-- A 'Proxy' for 'Map' 'Int' 'Int'.
mapInt :: Proxy (Map Int Int)
mapInt = Proxy

myLaws :: Proxy a -> [Laws]
myLaws p = [eqLaws p, monoidLaws p]

namedTests :: [(String, [Laws])]
namedTests =
  [ ("Set Int", myLaws setInt)
  , ("Map Int Int", myLaws mapInt)
  ]

Now, in GHCi:

>>> lawsCheckMany namedTests

Testing properties for common typeclasses
-------------
-- Set Int --
-------------

Eq: Transitive +++ OK, passed 100 tests.
Eq: Symmetric +++ OK, passed 100 tests.
Eq: Reflexive +++ OK, passed 100 tests.
Monoid: Associative +++ OK, passed 100 tests.
Monoid: Left Identity +++ OK, passed 100 tests.
Monoid: Right Identity +++ OK, passed 100 tests.
Monoid: Concatenation +++ OK, passed 100 tests.

-----------------
-- Map Int Int --
-----------------

Eq: Transitive +++ OK, passed 100 tests.
Eq: Symmetric +++ OK, passed 100 tests.
Eq: Reflexive +++ OK, passed 100 tests.
Monoid: Associative +++ OK, passed 100 tests.
Monoid: Left Identity +++ OK, passed 100 tests.
Monoid: Right Identity +++ OK, passed 100 tests.
Monoid: Concatenation +++ OK, passed 100 tests.

lawsCheckOne

A convenience function that allows one to check many typeclass instances of the same type.

For example, in GHCi:

>>> lawsCheckOne (Proxy :: Proxy Word) [jsonLaws, showReadLaws]
ToJSON/FromJSON: Encoding Equals Value +++ OK, passed 100 tests.
ToJSON/FromJSON: Partial Isomorphism +++ OK, passed 100 tests.
Show/Read: Partial Isomorphism +++ OK, passed 100 tests.