This module extends QuickCheck so that it returns counterexamples as Haskell values instead of just printing them. To use it, import this module instead of Test.QuickCheck. The API and functionality are the same as normal QuickCheck; the only difference is that the return types of quickCheck (and related functions) include a counterexample.

Note that this module re-exports most functions from Test.QuickCheck. Those functions are not documented here! You will need to refer to the main Test.QuickCheck documentation when using this module.

Here is an example of getting counterexamples. Suppose we have the following property:

prop_reverse_append :: [Int] -> [Int] -> Property
prop_reverse_append xs ys =
  reverse (xs++ys) === reverse xs ++ reverse ys

If we look the type of quickCheck prop_reverse_append, we see that it returns a counterexample:

>>> :t quickCheck prop_reverse_append
quickCheck prop_reverse_append :: IO (Maybe ([Int] :&: [Int] :&: ()))

The Maybe is there because quickCheck will return Nothing if the property succeeds; :&: is a datatype of pairs.

If we run QuickCheck, we can get the counterexample as a normal Haskell value:

>>> Just (xs :&: ys :&: ()) <- quickCheck prop_reverse_append
*** Failed! Falsifiable (after 5 tests and 4 shrinks):
[0]
[1]
[1,0] /= [0,1]

>>> :t xs
xs :: [Int]

>>> xs
[0]

>>> ys
[1]

Here is how this module's API differs from normal QuickCheck, in more detail:

• The Testable class now has an associated type Counterexample which describes the counterexample. Property is now a synonym for PropertyOf (), where PropertyOf cex represents a property with an associated counterexample cex. The QuickCheck property combinators preserve the counterexample, by returning PropertyOf instead of Property.
• quickCheck and related functions return a Counterexample prop.
• Finally, there are a couple of new combinators, documented below.