Test.QuickCheck.Function

Generation of random shrinkable, showable functions. See the paper "Shrinking and showing functions" by Koen Claessen.

Note: most of the contents of this module are re-exported by Test.QuickCheck. You probably do not need to import it directly.

Example of use:

>>> :{
>>> let prop :: Fun String Integer -> Bool
>>> prop (Fun _ f) = f "monkey" == f "banana" || f "banana" == f "elephant"
>>> :}
>>> quickCheck prop
*** Failed! Falsified (after 3 tests and 134 shrinks):
{"elephant"->1, "monkey"->1, _->0}

To generate random values of type Fun a b, you must have an instance Function a. If your type has a Show instance, you can use functionShow to write the instance; otherwise, use functionMap to give a bijection between your type and a type that is already an instance of Function. See the Function [a] instance for an example of the latter.

Documentation

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]

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"

apply :: Fun a b -> a -> b

Alias to applyFun.

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]

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.

data a :-> c

The type of possibly partial concrete functions

Instances

Functor ((:->) a)

Defined in Test.QuickCheck.Function

Methods

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

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

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

Defined in Test.QuickCheck.Function

Methods

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

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

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

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

Defined in Test.QuickCheck.Function

Methods

arbitrary :: Gen (a :-> b)

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

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.

Minimal complete definition

Nothing

Methods

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

function :: (Generic a, GFunction (Rep a)) => (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 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 OrdC

Defined in Test.QuickCheck.Function

Methods

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

Function OrdB

Defined in Test.QuickCheck.Function

Methods

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

Function OrdA

Defined in Test.QuickCheck.Function

Methods

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

Function C

Defined in Test.QuickCheck.Function

Methods

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

Function B

Defined in Test.QuickCheck.Function

Methods

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

Function A

Defined in Test.QuickCheck.Function

Methods

function :: (A -> b) -> A :-> 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

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 :: (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 :: (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 :: (a -> b -> c -> d) -> Fun (a, b, c) d

A modifier for testing ternary functions.