Test.QuickCheck.Counterexamples

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.

Documentation

data a :&: b infixr 6

A type of pairs. Used in counterexamples.

Constructors

a :&: b infixr 6

Instances

(Eq a, Eq b) => Eq (a :&: b)

Defined in Test.QuickCheck.Counterexamples

Methods

(==) :: (a :&: b) -> (a :&: b) -> Bool

(/=) :: (a :&: b) -> (a :&: b) -> Bool

(Ord a, Ord b) => Ord (a :&: b)

Defined in Test.QuickCheck.Counterexamples

Methods

compare :: (a :&: b) -> (a :&: b) -> Ordering

(<) :: (a :&: b) -> (a :&: b) -> Bool

(<=) :: (a :&: b) -> (a :&: b) -> Bool

(>) :: (a :&: b) -> (a :&: b) -> Bool

(>=) :: (a :&: b) -> (a :&: b) -> Bool

max :: (a :&: b) -> (a :&: b) -> a :&: b

min :: (a :&: b) -> (a :&: b) -> a :&: b

(Read a, Read b) => Read (a :&: b)

Defined in Test.QuickCheck.Counterexamples

Methods

readsPrec :: Int -> ReadS (a :&: b)

readList :: ReadS [a :&: b]

readPrec :: ReadPrec (a :&: b)

readListPrec :: ReadPrec [a :&: b]

(Show a, Show b) => Show (a :&: b)

Defined in Test.QuickCheck.Counterexamples

Methods

showsPrec :: Int -> (a :&: b) -> ShowS

show :: (a :&: b) -> String

showList :: [a :&: b] -> ShowS

class Testable prop => Testable prop where

The class of properties, i.e. types which QuickCheck knows how to test.

Minimal complete definition

property

Associated Types

type Counterexample prop

The type of counterexamples to the property.

Methods

property :: prop -> PropertyFrom prop

Convert the property to a PropertyOf.

Instances

Testable Bool

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample Bool :: *

Methods

property :: Bool -> PropertyFrom Bool

Testable Property

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample Property :: *

Methods

property :: Property -> PropertyFrom Property

Testable Discard

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample Discard :: *

Methods

property :: Discard -> PropertyFrom Discard

Testable prop => Testable (Gen prop)

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample (Gen prop) :: *

Methods

property :: Gen prop -> PropertyFrom (Gen prop)

Testable (PropertyOf cex)

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample (PropertyOf cex) :: *

Methods

property :: PropertyOf cex -> PropertyFrom (PropertyOf cex)

(Show a, Arbitrary a, Testable b) => Testable (a -> b)

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample (a -> b) :: *

Methods

property :: (a -> b) -> PropertyFrom (a -> b)

type PropertyFrom prop = PropertyOf (Counterexample prop)

A type synonym for the property which comes from a particular Testable instance.

type Property = PropertyOf ()

A property which doesn't produce a counterexample.

newtype PropertyOf cex

A property. cex is the type of counterexamples to the property.

Note that there is a Functor instance, which is useful when you want to manipulate the counterexample, e.g., to change its type. For example, when some branches of your property produce a counterexample and other branches do not, the types will not match up, but using fmap you can make the counterexample be a Maybe.

Constructors

MkProperty

Fields

• unProperty :: (cex -> IO ()) -> Property

  Implementation note: the property receives a callback to which it should pass the counterexample after shrinking.

Instances

Functor PropertyOf

Defined in Test.QuickCheck.Counterexamples

Methods

fmap :: (a -> b) -> PropertyOf a -> PropertyOf b

(<$) :: a -> PropertyOf b -> PropertyOf a

Testable (PropertyOf cex)

Defined in Test.QuickCheck.Counterexamples

Methods

property :: PropertyOf cex -> Property

Testable (PropertyOf cex)

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample (PropertyOf cex) :: *

Methods

property :: PropertyOf cex -> PropertyFrom (PropertyOf cex)

type Counterexample (PropertyOf cex)

Defined in Test.QuickCheck.Counterexamples

type Counterexample (PropertyOf cex) = cex

typedCounterexample :: Testable prop => a -> prop -> PropertyOf (a :&: Counterexample prop)

Add a value to the counterexample.

onProperty :: Testable prop => (Property -> Property) -> prop -> PropertyFrom prop

Lift an ordinary QuickCheck property combinator to one with counterexamples.

quickCheck :: Testable prop => prop -> IO (Maybe (Counterexample prop))

See quickCheck in Test.QuickCheck.

quickCheckWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))

See quickCheckWith in Test.QuickCheck.

quickCheckResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)

See quickCheckResult in Test.QuickCheck.

quickCheckWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)

See quickCheckWithResult in Test.QuickCheck.

verboseCheck :: Testable prop => prop -> IO (Maybe (Counterexample prop))

See verboseCheck in Test.QuickCheck.

verboseCheckWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))

See verboseCheckWith in Test.QuickCheck.

verboseCheckResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)

See verboseCheckResult in Test.QuickCheck.

verboseCheckWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)

See verboseCheckWithResult in Test.QuickCheck.

labelledExamples :: Testable prop => prop -> IO (Maybe (Counterexample prop))

See labelledExamples in Test.QuickCheck.

labelledExamplesWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))

See labelledExamplesWith in Test.QuickCheck.

labelledExamplesResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)

See labelledExamplesResult in Test.QuickCheck.

labelledExamplesWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)

See labelledExamplesWithResult in Test.QuickCheck.

polyQuickCheck :: Name -> ExpQ

See polyQuickCheck in Test.QuickCheck.

polyVerboseCheck :: Name -> ExpQ

See polyVerboseCheck in Test.QuickCheck.

forAll :: (Testable prop, Show a) => Gen a -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAll in Test.QuickCheck.

forAllShrink :: (Testable prop, Show a) => Gen a -> (a -> [a]) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAllShrink in Test.QuickCheck.

forAllShow :: Testable prop => Gen a -> (a -> String) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAllShow in Test.QuickCheck.

forAllShrinkShow :: Testable prop => Gen a -> (a -> [a]) -> (a -> String) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAllShrinkShow in Test.QuickCheck.

forAllBlind :: Testable prop => Gen a -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAllBlind in Test.QuickCheck.

forAllShrinkBlind :: Testable prop => Gen a -> (a -> [a]) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAllShrinkBlind in Test.QuickCheck.

shrinking :: Testable prop => (a -> [a]) -> a -> (a -> prop) -> PropertyFrom prop

See shrinking in Test.QuickCheck.

(==>) :: Testable prop => Bool -> prop -> PropertyFrom prop infixr 0

See ==> in Test.QuickCheck.

(===) :: (Eq a, Show a) => a -> a -> Property infix 4

See === in Test.QuickCheck.

(=/=) :: (Eq a, Show a) => a -> a -> Property infix 4

See =/= in Test.QuickCheck.

ioProperty :: Testable prop => IO prop -> PropertyFrom prop

See ioProperty in Test.QuickCheck.

idempotentIOProperty :: Testable prop => IO prop -> PropertyFrom prop

See idempotentIOProperty in Test.QuickCheck.

verbose :: Testable prop => prop -> PropertyFrom prop

See verbose in Test.QuickCheck.

verboseShrinking :: Testable prop => prop -> PropertyFrom prop

See verboseShrinking in Test.QuickCheck.

once :: Testable prop => prop -> PropertyFrom prop

See once in Test.QuickCheck.

again :: Testable prop => prop -> PropertyFrom prop

See again in Test.QuickCheck.

within :: Testable prop => Int -> prop -> PropertyFrom prop

See within in Test.QuickCheck.

noShrinking :: Testable prop => prop -> PropertyFrom prop

See noShrinking in Test.QuickCheck.

counterexample :: Testable prop => String -> prop -> PropertyFrom prop

See counterexample in Test.QuickCheck.

whenFail :: Testable prop => IO () -> prop -> PropertyFrom prop

See whenFail in Test.QuickCheck.

whenFail' :: Testable prop => IO () -> prop -> PropertyFrom prop

See whenFail' in Test.QuickCheck.

expectFailure :: Testable prop => prop -> PropertyFrom prop

See expectFailure in Test.QuickCheck.

label :: Testable prop => String -> prop -> PropertyFrom prop

See label in Test.QuickCheck.

collect :: (Show a, Testable prop) => a -> prop -> PropertyFrom prop

See collect in Test.QuickCheck.

classify :: Testable prop => Bool -> String -> prop -> PropertyFrom prop

See classify in Test.QuickCheck.

cover :: Testable prop => Double -> Bool -> String -> prop -> PropertyFrom prop

See cover in Test.QuickCheck.

tabulate :: Testable prop => String -> [String] -> prop -> PropertyFrom prop

See tabulate in Test.QuickCheck.

coverTables :: Testable prop => String -> [(String, Double)] -> prop -> PropertyFrom prop

See coverTables in Test.QuickCheck.

checkCoverage :: Testable prop => prop -> PropertyFrom prop

See checkCoverage in Test.QuickCheck.

checkCoverageWith :: Testable prop => Confidence -> prop -> PropertyFrom prop

See checkCoverageWith in Test.QuickCheck.

mapSize :: Testable prop => (Int -> Int) -> prop -> PropertyFrom prop

See mapSize in Test.QuickCheck.

verboseCheckAll :: Q Exp

Test all properties in the current module. This is just a convenience function that combines quickCheckAll and verbose.

verboseCheckAll has the same issue with scoping as quickCheckAll: see the note there about return [].

quickCheckAll :: Q Exp

Test all properties in the current module. The name of the property must begin with prop_. Polymorphic properties will be defaulted to Integer. Returns True if all tests succeeded, False otherwise.

To use quickCheckAll, add a definition to your module along the lines of

return []
runTests = $quickCheckAll

and then execute runTests.

Note: the bizarre return [] in the example above is needed on GHC 7.8 and later; without it, quickCheckAll will not be able to find any of the properties. For the curious, the return [] is a Template Haskell splice that makes GHC insert the empty list of declarations at that point in the program; GHC typechecks everything before the return [] before it starts on the rest of the module, which means that the later call to quickCheckAll can see everything that was defined before the return []. Yikes!

allProperties :: Q Exp

List all properties in the current module.

$allProperties has type [(String, Property)].

allProperties has the same issue with scoping as quickCheckAll: see the note there about return [].

forAllProperties :: Q Exp

Test all properties in the current module, using a custom quickCheck function. The same caveats as with quickCheckAll apply.

$forAllProperties has type (Property -> IO Result) -> IO Bool. An example invocation is $forAllProperties quickCheckResult, which does the same thing as $quickCheckAll.

forAllProperties has the same issue with scoping as quickCheckAll: see the note there about return [].

monomorphic :: Name -> ExpQ

Monomorphise an arbitrary property by defaulting all type variables to Integer.

For example, if f has type Ord a => [a] -> [a] then $(monomorphic 'f) has type [Integer] -> [Integer].

If you want to use monomorphic in the same file where you defined the property, the same scoping problems pop up as in quickCheckAll: see the note there about return [].

stdArgs :: Args

The default test arguments

data Args

Args specifies arguments to the QuickCheck driver

Constructors

Args

Fields

• replay :: Maybe (QCGen, Int)

  Should we replay a previous test? Note: saving a seed from one version of QuickCheck and replaying it in another is not supported. If you want to store a test case permanently you should save the test case itself.

• maxSuccess :: Int

  Maximum number of successful tests before succeeding. Testing stops at the first failure. If all tests are passing and you want to run more tests, increase this number.

• maxDiscardRatio :: Int

  Maximum number of discarded tests per successful test before giving up

• maxSize :: Int

  Size to use for the biggest test cases

• chatty :: Bool

  Whether to print anything

• maxShrinks :: Int

  Maximum number of shrinks to before giving up. Setting this to zero turns shrinking off.

Instances

Read Args

Defined in Test.QuickCheck.Test

Methods

readsPrec :: Int -> ReadS Args

readList :: ReadS [Args]

readPrec :: ReadPrec Args

readListPrec :: ReadPrec [Args]

Show Args

Defined in Test.QuickCheck.Test

Methods

showsPrec :: Int -> Args -> ShowS

show :: Args -> String

showList :: [Args] -> ShowS

data Result

Result represents the test result

Constructors

Success

A successful test run

Fields

• numTests :: Int

  Number of tests performed

• numDiscarded :: Int

  Number of tests skipped

• labels :: !(Map [String] Int)

  The number of test cases having each combination of labels (see label)

• classes :: !(Map String Int)

  The number of test cases having each class (see classify)

• tables :: !(Map String (Map String Int))

  Data collected by tabulate

• output :: String

  Printed output

GaveUp

Given up

Fields

• numTests :: Int

  Number of tests performed

• numDiscarded :: Int

  Number of tests skipped

• labels :: !(Map [String] Int)

  The number of test cases having each combination of labels (see label)

• classes :: !(Map String Int)

  The number of test cases having each class (see classify)

• tables :: !(Map String (Map String Int))

  Data collected by tabulate

• output :: String

  Printed output

Failure

A failed test run

Fields

• numTests :: Int

  Number of tests performed

• numDiscarded :: Int

  Number of tests skipped

• numShrinks :: Int

  Number of successful shrinking steps performed

• numShrinkTries :: Int

  Number of unsuccessful shrinking steps performed

• numShrinkFinal :: Int

  Number of unsuccessful shrinking steps performed since last successful shrink

• usedSeed :: QCGen

  What seed was used

• usedSize :: Int

  What was the test size

• reason :: String

  Why did the property fail

• theException :: Maybe AnException

  The exception the property threw, if any

• output :: String

  Printed output

• failingTestCase :: [String]

  The test case which provoked the failure

• failingLabels :: [String]

  The test case's labels (see label)

• failingClasses :: Set String

  The test case's classes (see classify)

NoExpectedFailure

A property that should have failed did not

Fields

• numTests :: Int

  Number of tests performed

• numDiscarded :: Int

  Number of tests skipped

• labels :: !(Map [String] Int)

  The number of test cases having each combination of labels (see label)

• classes :: !(Map String Int)

  The number of test cases having each class (see classify)

• tables :: !(Map String (Map String Int))

  Data collected by tabulate

• output :: String

  Printed output

Instances

Show Result

Defined in Test.QuickCheck.Test

Methods

showsPrec :: Int -> Result -> ShowS

show :: Result -> String

showList :: [Result] -> ShowS

total :: NFData a => a -> Property

Checks that a value is total, i.e., doesn't crash when evaluated.

stdConfidence :: Confidence

The standard parameters used by checkCoverage: certainty = 10^9, tolerance = 0.9. See Confidence for the meaning of the parameters.

withMaxSuccess :: Testable prop => Int -> prop -> Property

Configures how many times a property will be tested.

For example,

quickCheck (withMaxSuccess 1000 p)

will test p up to 1000 times.

data Discard

If a property returns Discard, the current test case is discarded, the same as if a precondition was false.

An example is the definition of ==>:

(==>) :: Testable prop => Bool -> prop -> Property
False ==> _ = property Discard
True  ==> p = property p

Constructors

Discard

Instances

Testable Discard

Defined in Test.QuickCheck.Property

Methods

property :: Discard -> Property

Testable Discard

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample Discard :: *

Methods

property :: Discard -> PropertyFrom Discard

type Counterexample Discard

Defined in Test.QuickCheck.Counterexamples

type Counterexample Discard = ()

data Confidence

The statistical parameters used by checkCoverage.

Constructors

Confidence

Fields

• certainty :: Integer

  How certain checkCoverage must be before the property fails. If the coverage requirement is met, and the certainty parameter is n, then you should get a false positive at most one in n runs of QuickCheck. The default value is 10^9.

  Lower values will speed up checkCoverage at the cost of false positives.

  If you are using checkCoverage as part of a test suite, you should be careful not to set certainty too low. If you want, say, a 1% chance of a false positive during a project's lifetime, then certainty should be set to at least 100 * m * n, where m is the number of uses of cover in the test suite, and n is the number of times you expect the test suite to be run during the project's lifetime. The default value is chosen to be big enough for most projects.

• tolerance :: Double

  For statistical reasons, checkCoverage will not reject coverage levels that are only slightly below the required levels. If the required level is p then an actual level of tolerance * p will be accepted. The default value is 0.9.

  Lower values will speed up checkCoverage at the cost of not detecting minor coverage violations.

Instances

Show Confidence

Defined in Test.QuickCheck.State

Methods

showsPrec :: Int -> Confidence -> ShowS

show :: Confidence -> String

showList :: [Confidence] -> ShowS

applyFun3 :: Fun (a, b, c) d -> a -> b -> c -> d

Extracts the value of a ternary function. Fn3 is the pattern equivalent of this function.

applyFun2 :: Fun (a, b) c -> a -> b -> c

Extracts the value of a binary function.

Fn2 is the pattern equivalent of this function.

prop_zipWith :: Fun (Int, Bool) Char -> [Int] -> [Bool] -> Bool
prop_zipWith f xs ys = zipWith (applyFun2 f) xs ys == [ applyFun2 f x y | (x, y) <- zip xs ys]

applyFun :: Fun a b -> a -> b

Extracts the value of a function.

Fn is the pattern equivalent of this function.

prop :: Fun String Integer -> Bool
prop f = applyFun f "banana" == applyFun f "monkey"
      || applyFun f "banana" == applyFun f "elephant"

functionMap :: Function b => (a -> b) -> (b -> a) -> (a -> c) -> a :-> c

The basic building block for Function instances. Provides a Function instance by mapping to and from a type that already has a Function instance.

functionShow :: (Show a, Read a) => (a -> c) -> a :-> c

Provides a Function instance for types with Show and Read.

functionIntegral :: Integral a => (a -> b) -> a :-> b

Provides a Function instance for types with Integral.

functionRealFrac :: RealFrac a => (a -> b) -> a :-> b

Provides a Function instance for types with RealFrac.

functionBoundedEnum :: (Eq a, Bounded a, Enum a) => (a -> b) -> a :-> b

Provides a Function instance for types with Bounded and Enum. Use only for small types (i.e. not integers): creates the list ['minBound'..'maxBound']!

pattern Fn :: forall a b. (a -> b) -> Fun a b

A modifier for testing functions.

prop :: Fun String Integer -> Bool
prop (Fn f) = f "banana" == f "monkey"
           || f "banana" == f "elephant"

pattern Fn2 :: forall a b c. (a -> b -> c) -> Fun (a, b) c

A modifier for testing binary functions.

prop_zipWith :: Fun (Int, Bool) Char -> [Int] -> [Bool] -> Bool
prop_zipWith (Fn2 f) xs ys = zipWith f xs ys == [ f x y | (x, y) <- zip xs ys]

pattern Fn3 :: forall a b c d. (a -> b -> c -> d) -> Fun (a, b, c) d

A modifier for testing ternary functions.

class Function a where

The class Function a is used for random generation of showable functions of type a -> b.

There is a default implementation for function, which you can use if your type has structural equality. Otherwise, you can normally use functionMap or functionShow.

Methods

function :: (a -> b) -> a :-> b

Instances

Function Bool

Defined in Test.QuickCheck.Function

Methods

function :: (Bool -> b) -> Bool :-> b

Function Char

Defined in Test.QuickCheck.Function

Methods

function :: (Char -> b) -> Char :-> b

Function Double

Defined in Test.QuickCheck.Function

Methods

function :: (Double -> b) -> Double :-> b

Function Float

Defined in Test.QuickCheck.Function

Methods

function :: (Float -> b) -> Float :-> b

Function Int

Defined in Test.QuickCheck.Function

Methods

function :: (Int -> b) -> Int :-> b

Function Int8

Defined in Test.QuickCheck.Function

Methods

function :: (Int8 -> b) -> Int8 :-> b

Function Int16

Defined in Test.QuickCheck.Function

Methods

function :: (Int16 -> b) -> Int16 :-> b

Function Int32

Defined in Test.QuickCheck.Function

Methods

function :: (Int32 -> b) -> Int32 :-> b

Function Int64

Defined in Test.QuickCheck.Function

Methods

function :: (Int64 -> b) -> Int64 :-> b

Function Integer

Defined in Test.QuickCheck.Function

Methods

function :: (Integer -> b) -> Integer :-> b

Function Ordering

Defined in Test.QuickCheck.Function

Methods

function :: (Ordering -> b) -> Ordering :-> b

Function Word

Defined in Test.QuickCheck.Function

Methods

function :: (Word -> b) -> Word :-> b

Function Word8

Defined in Test.QuickCheck.Function

Methods

function :: (Word8 -> b) -> Word8 :-> b

Function Word16

Defined in Test.QuickCheck.Function

Methods

function :: (Word16 -> b) -> Word16 :-> b

Function Word32

Defined in Test.QuickCheck.Function

Methods

function :: (Word32 -> b) -> Word32 :-> b

Function Word64

Defined in Test.QuickCheck.Function

Methods

function :: (Word64 -> b) -> Word64 :-> b

Function ()

Defined in Test.QuickCheck.Function

Methods

function :: (() -> b) -> () :-> b

Function A

Defined in Test.QuickCheck.Function

Methods

function :: (A -> b) -> A :-> b

Function B

Defined in Test.QuickCheck.Function

Methods

function :: (B -> b) -> B :-> b

Function C

Defined in Test.QuickCheck.Function

Methods

function :: (C -> b) -> C :-> b

Function OrdA

Defined in Test.QuickCheck.Function

Methods

function :: (OrdA -> b) -> OrdA :-> b

Function OrdB

Defined in Test.QuickCheck.Function

Methods

function :: (OrdB -> b) -> OrdB :-> b

Function OrdC

Defined in Test.QuickCheck.Function

Methods

function :: (OrdC -> b) -> OrdC :-> b

Function All

Defined in Test.QuickCheck.Function

Methods

function :: (All -> b) -> All :-> b

Function Any

Defined in Test.QuickCheck.Function

Methods

function :: (Any -> b) -> Any :-> b

Function IntSet

Defined in Test.QuickCheck.Function

Methods

function :: (IntSet -> b) -> IntSet :-> b

Function a => Function [a]

Defined in Test.QuickCheck.Function

Methods

function :: ([a] -> b) -> [a] :-> b

Function a => Function (Maybe a)

Defined in Test.QuickCheck.Function

Methods

function :: (Maybe a -> b) -> Maybe a :-> b

(Integral a, Function a) => Function (Ratio a)

Defined in Test.QuickCheck.Function

Methods

function :: (Ratio a -> b) -> Ratio a :-> b

(RealFloat a, Function a) => Function (Complex a)

Defined in Test.QuickCheck.Function

Methods

function :: (Complex a -> b) -> Complex a :-> b

HasResolution a => Function (Fixed a)

Defined in Test.QuickCheck.Function

Methods

function :: (Fixed a -> b) -> Fixed a :-> b

Function a => Function (Identity a)

Defined in Test.QuickCheck.Function

Methods

function :: (Identity a -> b) -> Identity a :-> b

Function a => Function (First a)

Defined in Test.QuickCheck.Function

Methods

function :: (First a -> b) -> First a :-> b

Function a => Function (Last a)

Defined in Test.QuickCheck.Function

Methods

function :: (Last a -> b) -> Last a :-> b

Function a => Function (Dual a)

Defined in Test.QuickCheck.Function

Methods

function :: (Dual a -> b) -> Dual a :-> b

Function a => Function (Sum a)

Defined in Test.QuickCheck.Function

Methods

function :: (Sum a -> b) -> Sum a :-> b

Function a => Function (Product a)

Defined in Test.QuickCheck.Function

Methods

function :: (Product a -> b) -> Product a :-> b

Function a => Function (IntMap a)

Defined in Test.QuickCheck.Function

Methods

function :: (IntMap a -> b) -> IntMap a :-> b

Function a => Function (Seq a)

Defined in Test.QuickCheck.Function

Methods

function :: (Seq a -> b) -> Seq a :-> b

(Ord a, Function a) => Function (Set a)

Defined in Test.QuickCheck.Function

Methods

function :: (Set a -> b) -> Set a :-> b

(Function a, Function b) => Function (Either a b)

Defined in Test.QuickCheck.Function

Methods

function :: (Either a b -> b0) -> Either a b :-> b0

(Function a, Function b) => Function (a, b)

Defined in Test.QuickCheck.Function

Methods

function :: ((a, b) -> b0) -> (a, b) :-> b0

(Ord a, Function a, Function b) => Function (Map a b)

Defined in Test.QuickCheck.Function

Methods

function :: (Map a b -> b0) -> Map a b :-> b0

(Function a, Function b, Function c) => Function (a, b, c)

Defined in Test.QuickCheck.Function

Methods

function :: ((a, b, c) -> b0) -> (a, b, c) :-> b0

Function a => Function (Const a b)

Defined in Test.QuickCheck.Function

Methods

function :: (Const a b -> b0) -> Const a b :-> b0

Function (f a) => Function (Alt f a)

Defined in Test.QuickCheck.Function

Methods

function :: (Alt f a -> b) -> Alt f a :-> b

(Function a, Function b, Function c, Function d) => Function (a, b, c, d)

Defined in Test.QuickCheck.Function

Methods

function :: ((a, b, c, d) -> b0) -> (a, b, c, d) :-> b0

(Function a, Function b, Function c, Function d, Function e) => Function (a, b, c, d, e)

Defined in Test.QuickCheck.Function

Methods

function :: ((a, b, c, d, e) -> b0) -> (a, b, c, d, e) :-> b0

(Function a, Function b, Function c, Function d, Function e, Function f) => Function (a, b, c, d, e, f)

Defined in Test.QuickCheck.Function

Methods

function :: ((a, b, c, d, e, f) -> b0) -> (a, b, c, d, e, f) :-> b0

(Function a, Function b, Function c, Function d, Function e, Function f, Function g) => Function (a, b, c, d, e, f, g)

Defined in Test.QuickCheck.Function

Methods

function :: ((a, b, c, d, e, f, g) -> b0) -> (a, b, c, d, e, f, g) :-> b0

data Fun a b

Generation of random shrinkable, showable functions.

To generate random values of type Fun a b, you must have an instance Function a.

See also applyFun, and Fn with GHC >= 7.8.

Constructors

Fun (a :-> b, b, Shrunk) (a -> b)

Instances

Functor (Fun a)

Defined in Test.QuickCheck.Function

Methods

fmap :: (a0 -> b) -> Fun a a0 -> Fun a b

(<$) :: a0 -> Fun a b -> Fun a a0

(Show a, Show b) => Show (Fun a b)

Defined in Test.QuickCheck.Function

Methods

showsPrec :: Int -> Fun a b -> ShowS

show :: Fun a b -> String

showList :: [Fun a b] -> ShowS

(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b)

Defined in Test.QuickCheck.Function

Methods

arbitrary :: Gen (Fun a b)

shrink :: Fun a b -> [Fun a b]

newtype Blind a

Blind x: as x, but x does not have to be in the Show class.

Constructors

Blind

Fields

• getBlind :: a

Instances

Functor Blind

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Blind a -> Blind b

(<$) :: a -> Blind b -> Blind a

Enum a => Enum (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Blind a -> Blind a

pred :: Blind a -> Blind a

toEnum :: Int -> Blind a

fromEnum :: Blind a -> Int

enumFrom :: Blind a -> [Blind a]

enumFromThen :: Blind a -> Blind a -> [Blind a]

enumFromTo :: Blind a -> Blind a -> [Blind a]

enumFromThenTo :: Blind a -> Blind a -> Blind a -> [Blind a]

Eq a => Eq (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: Blind a -> Blind a -> Bool

(/=) :: Blind a -> Blind a -> Bool

Integral a => Integral (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Blind a -> Blind a -> Blind a

rem :: Blind a -> Blind a -> Blind a

div :: Blind a -> Blind a -> Blind a

mod :: Blind a -> Blind a -> Blind a

quotRem :: Blind a -> Blind a -> (Blind a, Blind a)

divMod :: Blind a -> Blind a -> (Blind a, Blind a)

toInteger :: Blind a -> Integer

Num a => Num (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

(+) :: Blind a -> Blind a -> Blind a

(-) :: Blind a -> Blind a -> Blind a

(*) :: Blind a -> Blind a -> Blind a

negate :: Blind a -> Blind a

abs :: Blind a -> Blind a

signum :: Blind a -> Blind a

fromInteger :: Integer -> Blind a

Ord a => Ord (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Blind a -> Blind a -> Ordering

(<) :: Blind a -> Blind a -> Bool

(<=) :: Blind a -> Blind a -> Bool

(>) :: Blind a -> Blind a -> Bool

(>=) :: Blind a -> Blind a -> Bool

max :: Blind a -> Blind a -> Blind a

min :: Blind a -> Blind a -> Blind a

Real a => Real (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

toRational :: Blind a -> Rational

Show (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Blind a -> ShowS

show :: Blind a -> String

showList :: [Blind a] -> ShowS

Arbitrary a => Arbitrary (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Blind a)

shrink :: Blind a -> [Blind a]

newtype Fixed a

Fixed x: as x, but will not be shrunk.

Constructors

Fixed

Fields

• getFixed :: a

Instances

Functor Fixed

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Fixed a -> Fixed b

(<$) :: a -> Fixed b -> Fixed a

Enum a => Enum (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Fixed a -> Fixed a

pred :: Fixed a -> Fixed a

toEnum :: Int -> Fixed a

fromEnum :: Fixed a -> Int

enumFrom :: Fixed a -> [Fixed a]

enumFromThen :: Fixed a -> Fixed a -> [Fixed a]

enumFromTo :: Fixed a -> Fixed a -> [Fixed a]

enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a]

Eq a => Eq (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: Fixed a -> Fixed a -> Bool

(/=) :: Fixed a -> Fixed a -> Bool

Integral a => Integral (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Fixed a -> Fixed a -> Fixed a

rem :: Fixed a -> Fixed a -> Fixed a

div :: Fixed a -> Fixed a -> Fixed a

mod :: Fixed a -> Fixed a -> Fixed a

quotRem :: Fixed a -> Fixed a -> (Fixed a, Fixed a)

divMod :: Fixed a -> Fixed a -> (Fixed a, Fixed a)

toInteger :: Fixed a -> Integer

Num a => Num (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

(+) :: Fixed a -> Fixed a -> Fixed a

(-) :: Fixed a -> Fixed a -> Fixed a

(*) :: Fixed a -> Fixed a -> Fixed a

negate :: Fixed a -> Fixed a

abs :: Fixed a -> Fixed a

signum :: Fixed a -> Fixed a

fromInteger :: Integer -> Fixed a

Ord a => Ord (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Fixed a -> Fixed a -> Ordering

(<) :: Fixed a -> Fixed a -> Bool

(<=) :: Fixed a -> Fixed a -> Bool

(>) :: Fixed a -> Fixed a -> Bool

(>=) :: Fixed a -> Fixed a -> Bool

max :: Fixed a -> Fixed a -> Fixed a

min :: Fixed a -> Fixed a -> Fixed a

Read a => Read (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (Fixed a)

readList :: ReadS [Fixed a]

readPrec :: ReadPrec (Fixed a)

readListPrec :: ReadPrec [Fixed a]

Real a => Real (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

toRational :: Fixed a -> Rational

Show a => Show (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Fixed a -> ShowS

show :: Fixed a -> String

showList :: [Fixed a] -> ShowS

Arbitrary a => Arbitrary (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Fixed a)

shrink :: Fixed a -> [Fixed a]

newtype OrderedList a

Ordered xs: guarantees that xs is ordered.

Constructors

Ordered

Fields

• getOrdered :: [a]

Instances

Functor OrderedList

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> OrderedList a -> OrderedList b

(<$) :: a -> OrderedList b -> OrderedList a

Eq a => Eq (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: OrderedList a -> OrderedList a -> Bool

(/=) :: OrderedList a -> OrderedList a -> Bool

Ord a => Ord (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: OrderedList a -> OrderedList a -> Ordering

(<) :: OrderedList a -> OrderedList a -> Bool

(<=) :: OrderedList a -> OrderedList a -> Bool

(>) :: OrderedList a -> OrderedList a -> Bool

(>=) :: OrderedList a -> OrderedList a -> Bool

max :: OrderedList a -> OrderedList a -> OrderedList a

min :: OrderedList a -> OrderedList a -> OrderedList a

Read a => Read (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (OrderedList a)

readList :: ReadS [OrderedList a]

readPrec :: ReadPrec (OrderedList a)

readListPrec :: ReadPrec [OrderedList a]

Show a => Show (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> OrderedList a -> ShowS

show :: OrderedList a -> String

showList :: [OrderedList a] -> ShowS

(Ord a, Arbitrary a) => Arbitrary (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (OrderedList a)

shrink :: OrderedList a -> [OrderedList a]

newtype NonEmptyList a

NonEmpty xs: guarantees that xs is non-empty.

Constructors

NonEmpty

Fields

• getNonEmpty :: [a]

Instances

Functor NonEmptyList

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> NonEmptyList a -> NonEmptyList b

(<$) :: a -> NonEmptyList b -> NonEmptyList a

Eq a => Eq (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: NonEmptyList a -> NonEmptyList a -> Bool

(/=) :: NonEmptyList a -> NonEmptyList a -> Bool

Ord a => Ord (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: NonEmptyList a -> NonEmptyList a -> Ordering

(<) :: NonEmptyList a -> NonEmptyList a -> Bool

(<=) :: NonEmptyList a -> NonEmptyList a -> Bool

(>) :: NonEmptyList a -> NonEmptyList a -> Bool

(>=) :: NonEmptyList a -> NonEmptyList a -> Bool

max :: NonEmptyList a -> NonEmptyList a -> NonEmptyList a

min :: NonEmptyList a -> NonEmptyList a -> NonEmptyList a

Read a => Read (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (NonEmptyList a)

readList :: ReadS [NonEmptyList a]

readPrec :: ReadPrec (NonEmptyList a)

readListPrec :: ReadPrec [NonEmptyList a]

Show a => Show (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> NonEmptyList a -> ShowS

show :: NonEmptyList a -> String

showList :: [NonEmptyList a] -> ShowS

Arbitrary a => Arbitrary (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonEmptyList a)

shrink :: NonEmptyList a -> [NonEmptyList a]

data InfiniteList a

InfiniteList xs _: guarantees that xs is an infinite list. When a counterexample is found, only prints the prefix of xs that was used by the program.

Here is a contrived example property:

prop_take_10 :: InfiniteList Char -> Bool
prop_take_10 (InfiniteList xs _) =
  or [ x == 'a' | x <- take 10 xs ]

In the following counterexample, the list must start with "bbbbbbbbbb" but the remaining (infinite) part can contain anything:

>>> quickCheck prop_take_10
*** Failed! Falsifiable (after 1 test and 14 shrinks):
"bbbbbbbbbb" ++ ...

Constructors

InfiniteList

Fields

• getInfiniteList :: [a]
• infiniteListInternalData :: InfiniteListInternalData a

Instances

Show a => Show (InfiniteList a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> InfiniteList a -> ShowS

show :: InfiniteList a -> String

showList :: [InfiniteList a] -> ShowS

Arbitrary a => Arbitrary (InfiniteList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (InfiniteList a)

shrink :: InfiniteList a -> [InfiniteList a]

newtype Positive a

Positive x: guarantees that x > 0.

Constructors

Positive

Fields

• getPositive :: a

Instances

Functor Positive

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Positive a -> Positive b

(<$) :: a -> Positive b -> Positive a

Enum a => Enum (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Positive a -> Positive a

pred :: Positive a -> Positive a

toEnum :: Int -> Positive a

fromEnum :: Positive a -> Int

enumFrom :: Positive a -> [Positive a]

enumFromThen :: Positive a -> Positive a -> [Positive a]

enumFromTo :: Positive a -> Positive a -> [Positive a]

enumFromThenTo :: Positive a -> Positive a -> Positive a -> [Positive a]

Eq a => Eq (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: Positive a -> Positive a -> Bool

(/=) :: Positive a -> Positive a -> Bool

Ord a => Ord (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Positive a -> Positive a -> Ordering

(<) :: Positive a -> Positive a -> Bool

(<=) :: Positive a -> Positive a -> Bool

(>) :: Positive a -> Positive a -> Bool

(>=) :: Positive a -> Positive a -> Bool

max :: Positive a -> Positive a -> Positive a

min :: Positive a -> Positive a -> Positive a

Read a => Read (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (Positive a)

readList :: ReadS [Positive a]

readPrec :: ReadPrec (Positive a)

readListPrec :: ReadPrec [Positive a]

Show a => Show (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Positive a -> ShowS

show :: Positive a -> String

showList :: [Positive a] -> ShowS

(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Positive a)

shrink :: Positive a -> [Positive a]

newtype NonZero a

NonZero x: guarantees that x /= 0.

Constructors

NonZero

Fields

• getNonZero :: a

Instances

Functor NonZero

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> NonZero a -> NonZero b

(<$) :: a -> NonZero b -> NonZero a

Enum a => Enum (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: NonZero a -> NonZero a

pred :: NonZero a -> NonZero a

toEnum :: Int -> NonZero a

fromEnum :: NonZero a -> Int

enumFrom :: NonZero a -> [NonZero a]

enumFromThen :: NonZero a -> NonZero a -> [NonZero a]

enumFromTo :: NonZero a -> NonZero a -> [NonZero a]

enumFromThenTo :: NonZero a -> NonZero a -> NonZero a -> [NonZero a]

Eq a => Eq (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: NonZero a -> NonZero a -> Bool

(/=) :: NonZero a -> NonZero a -> Bool

Ord a => Ord (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: NonZero a -> NonZero a -> Ordering

(<) :: NonZero a -> NonZero a -> Bool

(<=) :: NonZero a -> NonZero a -> Bool

(>) :: NonZero a -> NonZero a -> Bool

(>=) :: NonZero a -> NonZero a -> Bool

max :: NonZero a -> NonZero a -> NonZero a

min :: NonZero a -> NonZero a -> NonZero a

Read a => Read (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (NonZero a)

readList :: ReadS [NonZero a]

readPrec :: ReadPrec (NonZero a)

readListPrec :: ReadPrec [NonZero a]

Show a => Show (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> NonZero a -> ShowS

show :: NonZero a -> String

showList :: [NonZero a] -> ShowS

(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonZero a)

shrink :: NonZero a -> [NonZero a]

newtype NonNegative a

NonNegative x: guarantees that x >= 0.

Constructors

NonNegative

Fields

• getNonNegative :: a

Instances

Functor NonNegative

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> NonNegative a -> NonNegative b

(<$) :: a -> NonNegative b -> NonNegative a

Enum a => Enum (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: NonNegative a -> NonNegative a

pred :: NonNegative a -> NonNegative a

toEnum :: Int -> NonNegative a

fromEnum :: NonNegative a -> Int

enumFrom :: NonNegative a -> [NonNegative a]

enumFromThen :: NonNegative a -> NonNegative a -> [NonNegative a]

enumFromTo :: NonNegative a -> NonNegative a -> [NonNegative a]

enumFromThenTo :: NonNegative a -> NonNegative a -> NonNegative a -> [NonNegative a]

Eq a => Eq (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: NonNegative a -> NonNegative a -> Bool

(/=) :: NonNegative a -> NonNegative a -> Bool

Ord a => Ord (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: NonNegative a -> NonNegative a -> Ordering

(<) :: NonNegative a -> NonNegative a -> Bool

(<=) :: NonNegative a -> NonNegative a -> Bool

(>) :: NonNegative a -> NonNegative a -> Bool

(>=) :: NonNegative a -> NonNegative a -> Bool

max :: NonNegative a -> NonNegative a -> NonNegative a

min :: NonNegative a -> NonNegative a -> NonNegative a

Read a => Read (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (NonNegative a)

readList :: ReadS [NonNegative a]

readPrec :: ReadPrec (NonNegative a)

readListPrec :: ReadPrec [NonNegative a]

Show a => Show (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> NonNegative a -> ShowS

show :: NonNegative a -> String

showList :: [NonNegative a] -> ShowS

(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonNegative a)

shrink :: NonNegative a -> [NonNegative a]

newtype Large a

Large x: by default, QuickCheck generates Ints drawn from a small range. Large Int gives you values drawn from the entire range instead.

Constructors

Large

Fields

• getLarge :: a

Instances

Functor Large

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Large a -> Large b

(<$) :: a -> Large b -> Large a

Enum a => Enum (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Large a -> Large a

pred :: Large a -> Large a

toEnum :: Int -> Large a

fromEnum :: Large a -> Int

enumFrom :: Large a -> [Large a]

enumFromThen :: Large a -> Large a -> [Large a]

enumFromTo :: Large a -> Large a -> [Large a]

enumFromThenTo :: Large a -> Large a -> Large a -> [Large a]

Eq a => Eq (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: Large a -> Large a -> Bool

(/=) :: Large a -> Large a -> Bool

Integral a => Integral (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Large a -> Large a -> Large a

rem :: Large a -> Large a -> Large a

div :: Large a -> Large a -> Large a

mod :: Large a -> Large a -> Large a

quotRem :: Large a -> Large a -> (Large a, Large a)

divMod :: Large a -> Large a -> (Large a, Large a)

toInteger :: Large a -> Integer

Num a => Num (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

(+) :: Large a -> Large a -> Large a

(-) :: Large a -> Large a -> Large a

(*) :: Large a -> Large a -> Large a

negate :: Large a -> Large a

abs :: Large a -> Large a

signum :: Large a -> Large a

fromInteger :: Integer -> Large a

Ord a => Ord (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Large a -> Large a -> Ordering

(<) :: Large a -> Large a -> Bool

(<=) :: Large a -> Large a -> Bool

(>) :: Large a -> Large a -> Bool

(>=) :: Large a -> Large a -> Bool

max :: Large a -> Large a -> Large a

min :: Large a -> Large a -> Large a

Read a => Read (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (Large a)

readList :: ReadS [Large a]

readPrec :: ReadPrec (Large a)

readListPrec :: ReadPrec [Large a]

Real a => Real (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

toRational :: Large a -> Rational

Show a => Show (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Large a -> ShowS

show :: Large a -> String

showList :: [Large a] -> ShowS

Ix a => Ix (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

range :: (Large a, Large a) -> [Large a]

index :: (Large a, Large a) -> Large a -> Int

unsafeIndex :: (Large a, Large a) -> Large a -> Int

inRange :: (Large a, Large a) -> Large a -> Bool

rangeSize :: (Large a, Large a) -> Int

unsafeRangeSize :: (Large a, Large a) -> Int

(Integral a, Bounded a) => Arbitrary (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Large a)

shrink :: Large a -> [Large a]

newtype Small a

Small x: generates values of x drawn from a small range. The opposite of Large.

Constructors

Small

Fields

• getSmall :: a

Instances

Functor Small

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Small a -> Small b

(<$) :: a -> Small b -> Small a

Enum a => Enum (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Small a -> Small a

pred :: Small a -> Small a

toEnum :: Int -> Small a

fromEnum :: Small a -> Int

enumFrom :: Small a -> [Small a]

enumFromThen :: Small a -> Small a -> [Small a]

enumFromTo :: Small a -> Small a -> [Small a]

enumFromThenTo :: Small a -> Small a -> Small a -> [Small a]

Eq a => Eq (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: Small a -> Small a -> Bool

(/=) :: Small a -> Small a -> Bool

Integral a => Integral (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Small a -> Small a -> Small a

rem :: Small a -> Small a -> Small a

div :: Small a -> Small a -> Small a

mod :: Small a -> Small a -> Small a

quotRem :: Small a -> Small a -> (Small a, Small a)

divMod :: Small a -> Small a -> (Small a, Small a)

toInteger :: Small a -> Integer

Num a => Num (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

(+) :: Small a -> Small a -> Small a

(-) :: Small a -> Small a -> Small a

(*) :: Small a -> Small a -> Small a

negate :: Small a -> Small a

abs :: Small a -> Small a

signum :: Small a -> Small a

fromInteger :: Integer -> Small a

Ord a => Ord (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Small a -> Small a -> Ordering

(<) :: Small a -> Small a -> Bool

(<=) :: Small a -> Small a -> Bool

(>) :: Small a -> Small a -> Bool

(>=) :: Small a -> Small a -> Bool

max :: Small a -> Small a -> Small a

min :: Small a -> Small a -> Small a

Read a => Read (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (Small a)

readList :: ReadS [Small a]

readPrec :: ReadPrec (Small a)

readListPrec :: ReadPrec [Small a]

Real a => Real (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

toRational :: Small a -> Rational

Show a => Show (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Small a -> ShowS

show :: Small a -> String

showList :: [Small a] -> ShowS

Ix a => Ix (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

range :: (Small a, Small a) -> [Small a]

index :: (Small a, Small a) -> Small a -> Int

unsafeIndex :: (Small a, Small a) -> Small a -> Int

inRange :: (Small a, Small a) -> Small a -> Bool

rangeSize :: (Small a, Small a) -> Int

unsafeRangeSize :: (Small a, Small a) -> Int

Integral a => Arbitrary (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Small a)

shrink :: Small a -> [Small a]

newtype Shrink2 a

Shrink2 x: allows 2 shrinking steps at the same time when shrinking x

Constructors

Shrink2

Fields

• getShrink2 :: a

Instances

Functor Shrink2

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Shrink2 a -> Shrink2 b

(<$) :: a -> Shrink2 b -> Shrink2 a

Enum a => Enum (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Shrink2 a -> Shrink2 a

pred :: Shrink2 a -> Shrink2 a

toEnum :: Int -> Shrink2 a

fromEnum :: Shrink2 a -> Int

enumFrom :: Shrink2 a -> [Shrink2 a]

enumFromThen :: Shrink2 a -> Shrink2 a -> [Shrink2 a]

enumFromTo :: Shrink2 a -> Shrink2 a -> [Shrink2 a]

enumFromThenTo :: Shrink2 a -> Shrink2 a -> Shrink2 a -> [Shrink2 a]

Eq a => Eq (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: Shrink2 a -> Shrink2 a -> Bool

(/=) :: Shrink2 a -> Shrink2 a -> Bool

Integral a => Integral (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Shrink2 a -> Shrink2 a -> Shrink2 a

rem :: Shrink2 a -> Shrink2 a -> Shrink2 a

div :: Shrink2 a -> Shrink2 a -> Shrink2 a

mod :: Shrink2 a -> Shrink2 a -> Shrink2 a

quotRem :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a)

divMod :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a)

toInteger :: Shrink2 a -> Integer

Num a => Num (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

(+) :: Shrink2 a -> Shrink2 a -> Shrink2 a

(-) :: Shrink2 a -> Shrink2 a -> Shrink2 a

(*) :: Shrink2 a -> Shrink2 a -> Shrink2 a

negate :: Shrink2 a -> Shrink2 a

abs :: Shrink2 a -> Shrink2 a

signum :: Shrink2 a -> Shrink2 a

fromInteger :: Integer -> Shrink2 a

Ord a => Ord (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Shrink2 a -> Shrink2 a -> Ordering

(<) :: Shrink2 a -> Shrink2 a -> Bool

(<=) :: Shrink2 a -> Shrink2 a -> Bool

(>) :: Shrink2 a -> Shrink2 a -> Bool

(>=) :: Shrink2 a -> Shrink2 a -> Bool

max :: Shrink2 a -> Shrink2 a -> Shrink2 a

min :: Shrink2 a -> Shrink2 a -> Shrink2 a

Read a => Read (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS (Shrink2 a)

readList :: ReadS [Shrink2 a]

readPrec :: ReadPrec (Shrink2 a)

readListPrec :: ReadPrec [Shrink2 a]

Real a => Real (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

toRational :: Shrink2 a -> Rational

Show a => Show (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Shrink2 a -> ShowS

show :: Shrink2 a -> String

showList :: [Shrink2 a] -> ShowS

Arbitrary a => Arbitrary (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Shrink2 a)

shrink :: Shrink2 a -> [Shrink2 a]

data Smart a

Smart _ x: tries a different order when shrinking.

Constructors

Smart Int a

Instances

Functor Smart

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Smart a -> Smart b

(<$) :: a -> Smart b -> Smart a

Show a => Show (Smart a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Smart a -> ShowS

show :: Smart a -> String

showList :: [Smart a] -> ShowS

Arbitrary a => Arbitrary (Smart a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Smart a)

shrink :: Smart a -> [Smart a]

data Shrinking s a

Shrinking _ x: allows for maintaining a state during shrinking.

Constructors

Shrinking s a

Instances

Functor (Shrinking s)

Defined in Test.QuickCheck.Modifiers

Methods

fmap :: (a -> b) -> Shrinking s a -> Shrinking s b

(<$) :: a -> Shrinking s b -> Shrinking s a

Show a => Show (Shrinking s a)

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> Shrinking s a -> ShowS

show :: Shrinking s a -> String

showList :: [Shrinking s a] -> ShowS

(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Shrinking s a)

shrink :: Shrinking s a -> [Shrinking s a]

class ShrinkState s a where

Minimal complete definition

shrinkInit, shrinkState

Methods

shrinkInit :: a -> s

shrinkState :: a -> s -> [(a, s)]

newtype ASCIIString

ASCIIString: generates an ASCII string.

Constructors

ASCIIString

Fields

• getASCIIString :: String

Instances

Eq ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: ASCIIString -> ASCIIString -> Bool

(/=) :: ASCIIString -> ASCIIString -> Bool

Ord ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

compare :: ASCIIString -> ASCIIString -> Ordering

(<) :: ASCIIString -> ASCIIString -> Bool

(<=) :: ASCIIString -> ASCIIString -> Bool

(>) :: ASCIIString -> ASCIIString -> Bool

(>=) :: ASCIIString -> ASCIIString -> Bool

max :: ASCIIString -> ASCIIString -> ASCIIString

min :: ASCIIString -> ASCIIString -> ASCIIString

Read ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS ASCIIString

readList :: ReadS [ASCIIString]

readPrec :: ReadPrec ASCIIString

readListPrec :: ReadPrec [ASCIIString]

Show ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> ASCIIString -> ShowS

show :: ASCIIString -> String

showList :: [ASCIIString] -> ShowS

Arbitrary ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen ASCIIString

shrink :: ASCIIString -> [ASCIIString]

newtype UnicodeString

UnicodeString: generates a unicode String. The string will not contain surrogate pairs.

Constructors

UnicodeString

Fields

• getUnicodeString :: String

Instances

Eq UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: UnicodeString -> UnicodeString -> Bool

(/=) :: UnicodeString -> UnicodeString -> Bool

Ord UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

compare :: UnicodeString -> UnicodeString -> Ordering

(<) :: UnicodeString -> UnicodeString -> Bool

(<=) :: UnicodeString -> UnicodeString -> Bool

(>) :: UnicodeString -> UnicodeString -> Bool

(>=) :: UnicodeString -> UnicodeString -> Bool

max :: UnicodeString -> UnicodeString -> UnicodeString

min :: UnicodeString -> UnicodeString -> UnicodeString

Read UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS UnicodeString

readList :: ReadS [UnicodeString]

readPrec :: ReadPrec UnicodeString

readListPrec :: ReadPrec [UnicodeString]

Show UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> UnicodeString -> ShowS

show :: UnicodeString -> String

showList :: [UnicodeString] -> ShowS

Arbitrary UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen UnicodeString

shrink :: UnicodeString -> [UnicodeString]

newtype PrintableString

PrintableString: generates a printable unicode String. The string will not contain surrogate pairs.

Constructors

PrintableString

Fields

• getPrintableString :: String

Instances

Eq PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

(==) :: PrintableString -> PrintableString -> Bool

(/=) :: PrintableString -> PrintableString -> Bool

Ord PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

compare :: PrintableString -> PrintableString -> Ordering

(<) :: PrintableString -> PrintableString -> Bool

(<=) :: PrintableString -> PrintableString -> Bool

(>) :: PrintableString -> PrintableString -> Bool

(>=) :: PrintableString -> PrintableString -> Bool

max :: PrintableString -> PrintableString -> PrintableString

min :: PrintableString -> PrintableString -> PrintableString

Read PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

readsPrec :: Int -> ReadS PrintableString

readList :: ReadS [PrintableString]

readPrec :: ReadPrec PrintableString

readListPrec :: ReadPrec [PrintableString]

Show PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

showsPrec :: Int -> PrintableString -> ShowS

show :: PrintableString -> String

showList :: [PrintableString] -> ShowS

Arbitrary PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen PrintableString

shrink :: PrintableString -> [PrintableString]

infiniteList :: Arbitrary a => Gen [a]

Generates an infinite list.

orderedList :: (Ord a, Arbitrary a) => Gen [a]

Generates an ordered list.

vector :: Arbitrary a => Int -> Gen [a]

Generates a list of a given length.

coarbitraryEnum :: Enum a => a -> Gen b -> Gen b

A coarbitrary implementation for enums.

coarbitraryShow :: Show a => a -> Gen b -> Gen b

coarbitrary helper for lazy people :-).

coarbitraryReal :: Real a => a -> Gen b -> Gen b

A coarbitrary implementation for real numbers.

coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b

A coarbitrary implementation for integral numbers.

(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a

Combine two generator perturbing functions, for example the results of calls to variant or coarbitrary.

genericCoarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b

Generic CoArbitrary implementation.

shrinkRealFrac :: RealFrac a => a -> [a]

Shrink a fraction, via continued-fraction approximations.

shrinkIntegral :: Integral a => a -> [a]

Shrink an integral number.

shrinkMapBy :: (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]

Non-overloaded version of shrinkMap.

shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]

Map a shrink function to another domain. This is handy if your data type has special invariants, but is almost isomorphic to some other type.

shrinkOrderedList :: (Ord a, Arbitrary a) => [a] -> [[a]]
shrinkOrderedList = shrinkMap sort id

shrinkSet :: (Ord a, Arbitrary a) => Set a -> Set [a]
shrinkSet = shrinkMap fromList toList

shrinkNothing :: a -> [a]

Returns no shrinking alternatives.

arbitraryPrintableChar :: Gen Char

Generates a printable Unicode character.

arbitraryASCIIChar :: Gen Char

Generates a random ASCII character (0-127).

arbitraryUnicodeChar :: Gen Char

Generates any Unicode character (but not a surrogate)

arbitrarySizedBoundedIntegral :: (Bounded a, Integral a) => Gen a

Generates an integral number from a bounded domain. The number is chosen from the entire range of the type, but small numbers are generated more often than big numbers. Inspired by demands from Phil Wadler.

arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a

Generates an element of a bounded enumeration.

arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a

Generates an element of a bounded type. The element is chosen from the entire range of the type.

arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a

Generates an integral number. The number is chosen uniformly from the entire range of the type. You may want to use arbitrarySizedBoundedIntegral instead.

arbitrarySizedFractional :: Fractional a => Gen a

Generates a fractional number. The number can be positive or negative and its maximum absolute value depends on the size parameter.

arbitrarySizedNatural :: Integral a => Gen a

Generates a natural number. The number's maximum value depends on the size parameter.

arbitrarySizedIntegral :: Integral a => Gen a

Generates an integral number. The number can be positive or negative and its maximum absolute value depends on the size parameter.

applyArbitrary4 :: (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> Gen r

Apply a function of arity 4 to random arguments.

applyArbitrary3 :: (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> Gen r

Apply a ternary function to random arguments.

applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r

Apply a binary function to random arguments.

shrinkList :: (a -> [a]) -> [a] -> [[a]]

Shrink a list of values given a shrinking function for individual values.

subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a]

All immediate subterms of a term.

recursivelyShrink :: (Generic a, RecursivelyShrink (Rep a)) => a -> [a]

Recursively shrink all immediate subterms.

genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a]

Shrink a term to any of its immediate subterms, and also recursively shrink all subterms.

shrink2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => f a b -> [f a b]

arbitrary2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => Gen (f a b)

shrink1 :: (Arbitrary1 f, Arbitrary a) => f a -> [f a]

arbitrary1 :: (Arbitrary1 f, Arbitrary a) => Gen (f a)

class Arbitrary a where

Random generation and shrinking of values.

QuickCheck provides Arbitrary instances for most types in base, except those which incur extra dependencies. For a wider range of Arbitrary instances see the quickcheck-instances package.

Minimal complete definition

arbitrary

Methods

arbitrary :: Gen a

A generator for values of the given type.

It is worth spending time thinking about what sort of test data you want - good generators are often the difference between finding bugs and not finding them. You can use sample, label and classify to check the quality of your test data.

There is no generic arbitrary implementation included because we don't know how to make a high-quality one. If you want one, consider using the testing-feat or generic-random packages.

The QuickCheck manual goes into detail on how to write good generators. Make sure to look at it, especially if your type is recursive!

shrink :: a -> [a]

Produces a (possibly) empty list of all the possible immediate shrinks of the given value.

The default implementation returns the empty list, so will not try to shrink the value. If your data type has no special invariants, you can enable shrinking by defining shrink = genericShrink, but by customising the behaviour of shrink you can often get simpler counterexamples.

Most implementations of shrink should try at least three things:

1. Shrink a term to any of its immediate subterms. You can use subterms to do this.
2. Recursively apply shrink to all immediate subterms. You can use recursivelyShrink to do this.
3. Type-specific shrinkings such as replacing a constructor by a simpler constructor.

For example, suppose we have the following implementation of binary trees:

data Tree a = Nil | Branch a (Tree a) (Tree a)

We can then define shrink as follows:

shrink Nil = []
shrink (Branch x l r) =
  -- shrink Branch to Nil
  [Nil] ++
  -- shrink to subterms
  [l, r] ++
  -- recursively shrink subterms
  [Branch x' l' r' | (x', l', r') <- shrink (x, l, r)]

There are a couple of subtleties here:

• QuickCheck tries the shrinking candidates in the order they appear in the list, so we put more aggressive shrinking steps (such as replacing the whole tree by Nil) before smaller ones (such as recursively shrinking the subtrees).
• It is tempting to write the last line as [Branch x' l' r' | x' <- shrink x, l' <- shrink l, r' <- shrink r] but this is the wrong thing! It will force QuickCheck to shrink x, l and r in tandem, and shrinking will stop once one of the three is fully shrunk.

There is a fair bit of boilerplate in the code above. We can avoid it with the help of some generic functions. The function genericShrink tries shrinking a term to all of its subterms and, failing that, recursively shrinks the subterms. Using it, we can define shrink as:

shrink x = shrinkToNil x ++ genericShrink x
  where
    shrinkToNil Nil = []
    shrinkToNil (Branch _ l r) = [Nil]

genericShrink is a combination of subterms, which shrinks a term to any of its subterms, and recursivelyShrink, which shrinks all subterms of a term. These may be useful if you need a bit more control over shrinking than genericShrink gives you.

A final gotcha: we cannot define shrink as simply shrink x = Nil:genericShrink x as this shrinks Nil to Nil, and shrinking will go into an infinite loop.

If all this leaves you bewildered, you might try shrink = genericShrink to begin with, after deriving Generic for your type. However, if your data type has any special invariants, you will need to check that genericShrink can't break those invariants.

Instances

Arbitrary Bool

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Bool

shrink :: Bool -> [Bool]

Arbitrary Char

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Char

shrink :: Char -> [Char]

Arbitrary Double

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Double

shrink :: Double -> [Double]

Arbitrary Float

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Float

shrink :: Float -> [Float]

Arbitrary Int

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int

shrink :: Int -> [Int]

Arbitrary Int8

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int8

shrink :: Int8 -> [Int8]

Arbitrary Int16

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int16

shrink :: Int16 -> [Int16]

Arbitrary Int32

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int32

shrink :: Int32 -> [Int32]

Arbitrary Int64

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int64

shrink :: Int64 -> [Int64]

Arbitrary Integer

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Integer

shrink :: Integer -> [Integer]

Arbitrary Ordering

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Ordering

shrink :: Ordering -> [Ordering]

Arbitrary Word

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word

shrink :: Word -> [Word]

Arbitrary Word8

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word8

shrink :: Word8 -> [Word8]

Arbitrary Word16

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word16

shrink :: Word16 -> [Word16]

Arbitrary Word32

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word32

shrink :: Word32 -> [Word32]

Arbitrary Word64

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word64

shrink :: Word64 -> [Word64]

Arbitrary ()

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen ()

shrink :: () -> [()]

Arbitrary Version

Generates Version with non-empty non-negative versionBranch, and empty versionTags

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Version

shrink :: Version -> [Version]

Arbitrary QCGen

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen QCGen

shrink :: QCGen -> [QCGen]

Arbitrary ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen ASCIIString

shrink :: ASCIIString -> [ASCIIString]

Arbitrary UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen UnicodeString

shrink :: UnicodeString -> [UnicodeString]

Arbitrary PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen PrintableString

shrink :: PrintableString -> [PrintableString]

Arbitrary ExitCode

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen ExitCode

shrink :: ExitCode -> [ExitCode]

Arbitrary All

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen All

shrink :: All -> [All]

Arbitrary Any

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Any

shrink :: Any -> [Any]

Arbitrary CChar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CChar

shrink :: CChar -> [CChar]

Arbitrary CSChar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSChar

shrink :: CSChar -> [CSChar]

Arbitrary CUChar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUChar

shrink :: CUChar -> [CUChar]

Arbitrary CShort

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CShort

shrink :: CShort -> [CShort]

Arbitrary CUShort

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUShort

shrink :: CUShort -> [CUShort]

Arbitrary CInt

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CInt

shrink :: CInt -> [CInt]

Arbitrary CUInt

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUInt

shrink :: CUInt -> [CUInt]

Arbitrary CLong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CLong

shrink :: CLong -> [CLong]

Arbitrary CULong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CULong

shrink :: CULong -> [CULong]

Arbitrary CLLong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CLLong

shrink :: CLLong -> [CLLong]

Arbitrary CULLong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CULLong

shrink :: CULLong -> [CULLong]

Arbitrary CFloat

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CFloat

shrink :: CFloat -> [CFloat]

Arbitrary CDouble

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CDouble

shrink :: CDouble -> [CDouble]

Arbitrary CPtrdiff

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CPtrdiff

shrink :: CPtrdiff -> [CPtrdiff]

Arbitrary CSize

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSize

shrink :: CSize -> [CSize]

Arbitrary CWchar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CWchar

shrink :: CWchar -> [CWchar]

Arbitrary CSigAtomic

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSigAtomic

shrink :: CSigAtomic -> [CSigAtomic]

Arbitrary CClock

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CClock

shrink :: CClock -> [CClock]

Arbitrary CTime

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CTime

shrink :: CTime -> [CTime]

Arbitrary CUSeconds

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUSeconds

shrink :: CUSeconds -> [CUSeconds]

Arbitrary CSUSeconds

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSUSeconds

shrink :: CSUSeconds -> [CSUSeconds]

Arbitrary CIntPtr

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CIntPtr

shrink :: CIntPtr -> [CIntPtr]

Arbitrary CUIntPtr

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUIntPtr

shrink :: CUIntPtr -> [CUIntPtr]

Arbitrary CIntMax

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CIntMax

shrink :: CIntMax -> [CIntMax]

Arbitrary CUIntMax

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUIntMax

shrink :: CUIntMax -> [CUIntMax]

Arbitrary IntSet

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen IntSet

shrink :: IntSet -> [IntSet]

Arbitrary a => Arbitrary [a]

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen [a]

shrink :: [a] -> [[a]]

Arbitrary a => Arbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Maybe a)

shrink :: Maybe a -> [Maybe a]

Integral a => Arbitrary (Ratio a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Ratio a)

shrink :: Ratio a -> [Ratio a]

Arbitrary a => Arbitrary (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Blind a)

shrink :: Blind a -> [Blind a]

Arbitrary a => Arbitrary (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Fixed a)

shrink :: Fixed a -> [Fixed a]

(Ord a, Arbitrary a) => Arbitrary (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (OrderedList a)

shrink :: OrderedList a -> [OrderedList a]

Arbitrary a => Arbitrary (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonEmptyList a)

shrink :: NonEmptyList a -> [NonEmptyList a]

Arbitrary a => Arbitrary (InfiniteList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (InfiniteList a)

shrink :: InfiniteList a -> [InfiniteList a]

(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Positive a)

shrink :: Positive a -> [Positive a]

(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonZero a)

shrink :: NonZero a -> [NonZero a]

(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonNegative a)

shrink :: NonNegative a -> [NonNegative a]

(Integral a, Bounded a) => Arbitrary (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Large a)

shrink :: Large a -> [Large a]

Integral a => Arbitrary (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Small a)

shrink :: Small a -> [Small a]

Arbitrary a => Arbitrary (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Shrink2 a)

shrink :: Shrink2 a -> [Shrink2 a]

Arbitrary a => Arbitrary (Smart a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Smart a)

shrink :: Smart a -> [Smart a]

(RealFloat a, Arbitrary a) => Arbitrary (Complex a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Complex a)

shrink :: Complex a -> [Complex a]

HasResolution a => Arbitrary (Fixed a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Fixed a)

shrink :: Fixed a -> [Fixed a]

Arbitrary a => Arbitrary (ZipList a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (ZipList a)

shrink :: ZipList a -> [ZipList a]

Arbitrary a => Arbitrary (Identity a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Identity a)

shrink :: Identity a -> [Identity a]

Arbitrary a => Arbitrary (First a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (First a)

shrink :: First a -> [First a]

Arbitrary a => Arbitrary (Last a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Last a)

shrink :: Last a -> [Last a]

Arbitrary a => Arbitrary (Dual a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Dual a)

shrink :: Dual a -> [Dual a]

(Arbitrary a, CoArbitrary a) => Arbitrary (Endo a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Endo a)

shrink :: Endo a -> [Endo a]

Arbitrary a => Arbitrary (Sum a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Sum a)

shrink :: Sum a -> [Sum a]

Arbitrary a => Arbitrary (Product a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Product a)

shrink :: Product a -> [Product a]

Arbitrary a => Arbitrary (IntMap a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (IntMap a)

shrink :: IntMap a -> [IntMap a]

Arbitrary a => Arbitrary (Seq a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Seq a)

shrink :: Seq a -> [Seq a]

(Ord a, Arbitrary a) => Arbitrary (Set a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Set a)

shrink :: Set a -> [Set a]

Arbitrary a => Arbitrary (InfiniteListInternalData a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (InfiniteListInternalData a)

shrink :: InfiniteListInternalData a -> [InfiniteListInternalData a]

(CoArbitrary a, Arbitrary b) => Arbitrary (a -> b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a -> b)

shrink :: (a -> b) -> [a -> b]

(Arbitrary a, Arbitrary b) => Arbitrary (Either a b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Either a b)

shrink :: Either a b -> [Either a b]

(Arbitrary a, Arbitrary b) => Arbitrary (a, b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b)

shrink :: (a, b) -> [(a, b)]

(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (a :-> b)

Defined in Test.QuickCheck.Function

Methods

arbitrary :: Gen (a :-> b)

shrink :: (a :-> b) -> [a :-> b]

(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b)

Defined in Test.QuickCheck.Function

Methods

arbitrary :: Gen (Fun a b)

shrink :: Fun a b -> [Fun a b]

(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Shrinking s a)

shrink :: Shrinking s a -> [Shrinking s a]

Arbitrary (m a) => Arbitrary (WrappedMonad m a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (WrappedMonad m a)

shrink :: WrappedMonad m a -> [WrappedMonad m a]

(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Map k v)

shrink :: Map k v -> [Map k v]

(Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a, b, c)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c)

shrink :: (a, b, c) -> [(a, b, c)]

Arbitrary (a b c) => Arbitrary (WrappedArrow a b c)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (WrappedArrow a b c)

shrink :: WrappedArrow a b c -> [WrappedArrow a b c]

Arbitrary a => Arbitrary (Const a b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Const a b)

shrink :: Const a b -> [Const a b]

Arbitrary (f a) => Arbitrary (Alt f a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Alt f a)

shrink :: Alt f a -> [Alt f a]

Arbitrary a => Arbitrary (Constant a b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Constant a b)

shrink :: Constant a b -> [Constant a b]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a, b, c, d)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d)

shrink :: (a, b, c, d) -> [(a, b, c, d)]

(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Product f g a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Product f g a)

shrink :: Product f g a -> [Product f g a]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a, b, c, d, e)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e)

shrink :: (a, b, c, d, e) -> [(a, b, c, d, e)]

(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Compose f g a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Compose f g a)

shrink :: Compose f g a -> [Compose f g a]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f) => Arbitrary (a, b, c, d, e, f)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f)

shrink :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g) => Arbitrary (a, b, c, d, e, f, g)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g)

shrink :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h) => Arbitrary (a, b, c, d, e, f, g, h)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g, h)

shrink :: (a, b, c, d, e, f, g, h) -> [(a, b, c, d, e, f, g, h)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i) => Arbitrary (a, b, c, d, e, f, g, h, i)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g, h, i)

shrink :: (a, b, c, d, e, f, g, h, i) -> [(a, b, c, d, e, f, g, h, i)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i, Arbitrary j) => Arbitrary (a, b, c, d, e, f, g, h, i, j)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g, h, i, j)

shrink :: (a, b, c, d, e, f, g, h, i, j) -> [(a, b, c, d, e, f, g, h, i, j)]

class Arbitrary1 (f :: * -> *) where

Lifting of the Arbitrary class to unary type constructors.

Minimal complete definition

liftArbitrary

Methods

liftArbitrary :: Gen a -> Gen (f a)

liftShrink :: (a -> [a]) -> f a -> [f a]

Instances

Arbitrary1 []

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen [a]

liftShrink :: (a -> [a]) -> [a] -> [[a]]

Arbitrary1 Maybe

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Maybe a)

liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a]

Arbitrary1 ZipList

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (ZipList a)

liftShrink :: (a -> [a]) -> ZipList a -> [ZipList a]

Arbitrary1 Identity

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Identity a)

liftShrink :: (a -> [a]) -> Identity a -> [Identity a]

Arbitrary1 IntMap

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (IntMap a)

liftShrink :: (a -> [a]) -> IntMap a -> [IntMap a]

Arbitrary1 Seq

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Seq a)

liftShrink :: (a -> [a]) -> Seq a -> [Seq a]

Arbitrary a => Arbitrary1 (Either a)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a0 -> Gen (Either a a0)

liftShrink :: (a0 -> [a0]) -> Either a a0 -> [Either a a0]

Arbitrary a => Arbitrary1 ((,) a)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a0 -> Gen (a, a0)

liftShrink :: (a0 -> [a0]) -> (a, a0) -> [(a, a0)]

(Ord k, Arbitrary k) => Arbitrary1 (Map k)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Map k a)

liftShrink :: (a -> [a]) -> Map k a -> [Map k a]

Arbitrary a => Arbitrary1 (Const a :: * -> *)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a0 -> Gen (Const a a0)

liftShrink :: (a0 -> [a0]) -> Const a a0 -> [Const a a0]

Arbitrary a => Arbitrary1 (Constant a :: * -> *)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a0 -> Gen (Constant a a0)

liftShrink :: (a0 -> [a0]) -> Constant a a0 -> [Constant a a0]

CoArbitrary a => Arbitrary1 ((->) a :: * -> *)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a0 -> Gen (a -> a0)

liftShrink :: (a0 -> [a0]) -> (a -> a0) -> [a -> a0]

(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Product f g)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Product f g a)

liftShrink :: (a -> [a]) -> Product f g a -> [Product f g a]

(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Compose f g)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Compose f g a)

liftShrink :: (a -> [a]) -> Compose f g a -> [Compose f g a]

class Arbitrary2 (f :: * -> * -> *) where

Lifting of the Arbitrary class to binary type constructors.

Minimal complete definition

liftArbitrary2

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (f a b)

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]

Instances

Arbitrary2 Either

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b)

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b]

Arbitrary2 (,)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (a, b)

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)]

Arbitrary2 (Const :: * -> * -> *)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (Const a b)

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Const a b -> [Const a b]

Arbitrary2 (Constant :: * -> * -> *)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (Constant a b)

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Constant a b -> [Constant a b]

class CoArbitrary a where

Used for random generation of functions. You should consider using Fun instead, which can show the generated functions as strings.

If you are using a recent GHC, there is a default definition of coarbitrary using genericCoarbitrary, so if your type has a Generic instance it's enough to say

instance CoArbitrary MyType

You should only use genericCoarbitrary for data types where equality is structural, i.e. if you can't have two different representations of the same value. An example where it's not safe is sets implemented using binary search trees: the same set can be represented as several different trees. Here you would have to explicitly define coarbitrary s = coarbitrary (toList s).

Methods

coarbitrary :: a -> Gen b -> Gen b

Used to generate a function of type a -> b. The first argument is a value, the second a generator. You should use variant to perturb the random generator; the goal is that different values for the first argument will lead to different calls to variant. An example will help:

instance CoArbitrary a => CoArbitrary [a] where
  coarbitrary []     = variant 0
  coarbitrary (x:xs) = variant 1 . coarbitrary (x,xs)

Instances

CoArbitrary Bool

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Bool -> Gen b -> Gen b

CoArbitrary Char

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Char -> Gen b -> Gen b

CoArbitrary Double

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Double -> Gen b -> Gen b

CoArbitrary Float

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Float -> Gen b -> Gen b

CoArbitrary Int

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Int -> Gen b -> Gen b

CoArbitrary Int8

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Int8 -> Gen b -> Gen b

CoArbitrary Int16

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Int16 -> Gen b -> Gen b

CoArbitrary Int32

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Int32 -> Gen b -> Gen b

CoArbitrary Int64

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Int64 -> Gen b -> Gen b

CoArbitrary Integer

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Integer -> Gen b -> Gen b

CoArbitrary Ordering

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Ordering -> Gen b -> Gen b

CoArbitrary Word

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Word -> Gen b -> Gen b

CoArbitrary Word8

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Word8 -> Gen b -> Gen b

CoArbitrary Word16

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Word16 -> Gen b -> Gen b

CoArbitrary Word32

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Word32 -> Gen b -> Gen b

CoArbitrary Word64

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Word64 -> Gen b -> Gen b

CoArbitrary ()

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: () -> Gen b -> Gen b

CoArbitrary Version

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Version -> Gen b -> Gen b

CoArbitrary All

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: All -> Gen b -> Gen b

CoArbitrary Any

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Any -> Gen b -> Gen b

CoArbitrary IntSet

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: IntSet -> Gen b -> Gen b

CoArbitrary a => CoArbitrary [a]

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: [a] -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Maybe a -> Gen b -> Gen b

(Integral a, CoArbitrary a) => CoArbitrary (Ratio a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Ratio a -> Gen b -> Gen b

(RealFloat a, CoArbitrary a) => CoArbitrary (Complex a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Complex a -> Gen b -> Gen b

HasResolution a => CoArbitrary (Fixed a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Fixed a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (ZipList a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: ZipList a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Identity a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Identity a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (First a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: First a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Last a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Last a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Dual a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Dual a -> Gen b -> Gen b

(Arbitrary a, CoArbitrary a) => CoArbitrary (Endo a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Endo a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Sum a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Sum a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Product a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Product a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (IntMap a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: IntMap a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Seq a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Seq a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Set a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Set a -> Gen b -> Gen b

(Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: (a -> b) -> Gen b0 -> Gen b0

(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Either a b -> Gen b0 -> Gen b0

(CoArbitrary a, CoArbitrary b) => CoArbitrary (a, b)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: (a, b) -> Gen b0 -> Gen b0

(CoArbitrary k, CoArbitrary v) => CoArbitrary (Map k v)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Map k v -> Gen b -> Gen b

(CoArbitrary a, CoArbitrary b, CoArbitrary c) => CoArbitrary (a, b, c)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: (a, b, c) -> Gen b0 -> Gen b0

CoArbitrary a => CoArbitrary (Const a b)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Const a b -> Gen b0 -> Gen b0

CoArbitrary (f a) => CoArbitrary (Alt f a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Alt f a -> Gen b -> Gen b

CoArbitrary a => CoArbitrary (Constant a b)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Constant a b -> Gen b0 -> Gen b0

(CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d) => CoArbitrary (a, b, c, d)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: (a, b, c, d) -> Gen b0 -> Gen b0

(CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e) => CoArbitrary (a, b, c, d, e)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: (a, b, c, d, e) -> Gen b0 -> Gen b0

infiniteListOf :: Gen a -> Gen [a]

Generates an infinite list.

vectorOf :: Int -> Gen a -> Gen [a]

Generates a list of the given length.

listOf1 :: Gen a -> Gen [a]

Generates a non-empty list of random length. The maximum length depends on the size parameter.

listOf :: Gen a -> Gen [a]

Generates a list of random length. The maximum length depends on the size parameter.

growingElements :: [a] -> Gen a

Takes a list of elements of increasing size, and chooses among an initial segment of the list. The size of this initial segment increases with the size parameter. The input list must be non-empty.

shuffle :: [a] -> Gen [a]

Generates a random permutation of the given list.

sublistOf :: [a] -> Gen [a]

Generates a random subsequence of the given list.

elements :: [a] -> Gen a

Generates one of the given values. The input list must be non-empty.

frequency :: [(Int, Gen a)] -> Gen a

Chooses one of the given generators, with a weighted random distribution. The input list must be non-empty.

oneof :: [Gen a] -> Gen a

Randomly uses one of the given generators. The input list must be non-empty.

suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)

Tries to generate a value that satisfies a predicate. If it fails to do so after enough attempts, returns Nothing.

suchThatMap :: Gen a -> (a -> Maybe b) -> Gen b

Generates a value for which the given function returns a Just, and then applies the function.

suchThat :: Gen a -> (a -> Bool) -> Gen a

Generates a value that satisfies a predicate.

sample :: Show a => Gen a -> IO ()

Generates some example values and prints them to stdout.

sample' :: Gen a -> IO [a]

Generates some example values.

generate :: Gen a -> IO a

Run a generator. The size passed to the generator is always 30; if you want another size then you should explicitly use resize.

choose :: Random a => (a, a) -> Gen a

Generates a random element in the given inclusive range.

scale :: (Int -> Int) -> Gen a -> Gen a

Adjust the size parameter, by transforming it with the given function.

resize :: Int -> Gen a -> Gen a

Overrides the size parameter. Returns a generator which uses the given size instead of the runtime-size parameter.

getSize :: Gen Int

Returns the size parameter. Used to construct generators that depend on the size parameter.

For example, listOf, which uses the size parameter as an upper bound on length of lists it generates, can be defined like this:

listOf :: Gen a -> Gen [a]
listOf gen = do
  n <- getSize
  k <- choose (0,n)
  vectorOf k gen

You can also do this using sized.

sized :: (Int -> Gen a) -> Gen a

Used to construct generators that depend on the size parameter.

For example, listOf, which uses the size parameter as an upper bound on length of lists it generates, can be defined like this:

listOf :: Gen a -> Gen [a]
listOf gen = sized $ \n ->
  do k <- choose (0,n)
     vectorOf k gen

You can also do this using getSize.

variant :: Integral n => n -> Gen a -> Gen a

Modifies a generator using an integer seed.

data Gen a

A generator for values of type a.

The third-party package QuickCheck-GenT provides a monad transformer version of GenT.

Instances

Monad Gen

Defined in Test.QuickCheck.Gen

Methods

(>>=) :: Gen a -> (a -> Gen b) -> Gen b

(>>) :: Gen a -> Gen b -> Gen b

return :: a -> Gen a

fail :: String -> Gen a

Functor Gen

Defined in Test.QuickCheck.Gen

Methods

fmap :: (a -> b) -> Gen a -> Gen b

(<$) :: a -> Gen b -> Gen a

MonadFix Gen

Defined in Test.QuickCheck.Gen

Methods

mfix :: (a -> Gen a) -> Gen a

Applicative Gen

Defined in Test.QuickCheck.Gen

Methods

pure :: a -> Gen a

(<*>) :: Gen (a -> b) -> Gen a -> Gen b

liftA2 :: (a -> b -> c) -> Gen a -> Gen b -> Gen c

(*>) :: Gen a -> Gen b -> Gen b

(<*) :: Gen a -> Gen b -> Gen a

Testable prop => Testable (Gen prop)

Defined in Test.QuickCheck.Property

Methods

property :: Gen prop -> Property

Testable prop => Testable (Gen prop)

Defined in Test.QuickCheck.Counterexamples

Associated Types

type Counterexample (Gen prop) :: *

Methods

property :: Gen prop -> PropertyFrom (Gen prop)

type Counterexample (Gen prop)

Defined in Test.QuickCheck.Counterexamples

type Counterexample (Gen prop) = Counterexample prop

discard :: a

A special error value. If a property evaluates discard, it causes QuickCheck to discard the current test case. This can be useful if you want to discard the current test case, but are somewhere you can't use ==>, such as inside a generator.