Test.QuickCheck.HigherOrder

QuickCheck extension for properties of higher-order values.

See the README for an introduction.

Constructible values

class (Arbitrary (Repr a), Show (Repr a)) => Constructible a where

A Constructible type is associated with a type of "finite descriptions" that can be generated, shown (e.g., as counterexamples in QuickCheck), and interpreted as values. This enhances Arbitrary and Show used by vanilla QuickCheck.

The main motivating example is the type of functions, which can be finitely represented by the type (:->) (see also Test.Fun).

It turns out we can define Constructible for just about anything except IO (for now...).

Associated Types

type Repr a

The observable representation of a value.

type Repr a = a

Methods

fromRepr :: Repr a -> a

Interpret a representation as a value.

Instances

Constructible Bool

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Bool

Methods

fromRepr :: Repr Bool -> Bool

Constructible Char

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Char

Methods

fromRepr :: Repr Char -> Char

Constructible Double

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Double

Methods

fromRepr :: Repr Double -> Double

Constructible Int

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Int

Methods

fromRepr :: Repr Int -> Int

Constructible Integer

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Integer

Methods

fromRepr :: Repr Integer -> Integer

Constructible Ordering

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Ordering

Methods

fromRepr :: Repr Ordering -> Ordering

Constructible Word

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr Word

Methods

fromRepr :: Repr Word -> Word

Constructible ()

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr ()

Methods

fromRepr :: Repr () -> ()

Constructible a => Constructible [a]

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr [a]

Methods

fromRepr :: Repr [a] -> [a]

Constructible a => Constructible (Maybe a)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr (Maybe a)

Methods

fromRepr :: Repr (Maybe a) -> Maybe a

Constructible a => Constructible (Identity a)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr (Identity a)

Methods

fromRepr :: Repr (Identity a) -> Identity a

Constructible a => Constructible (Sum a)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr (Sum a)

Methods

fromRepr :: Repr (Sum a) -> Sum a

(CoArbitrary Gen a, Constructible b) => Constructible (a -> b)

Defined in Test.QuickCheck.HigherOrder.Internal.Function

Associated Types

type Repr (a -> b)

Methods

fromRepr :: Repr (a -> b) -> a -> b

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

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr (Either a b)

Methods

fromRepr :: Repr (Either a b) -> Either a b

(Constructible a, Constructible b) => Constructible (a, b)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr (a, b)

Methods

fromRepr :: Repr (a, b) -> (a, b)

(CoArbitrary a, Function a, Show a, Constructible b) => Constructible (Fun a b)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Associated Types

type Repr (Fun a b)

Methods

fromRepr :: Repr (Fun a b) -> Fun a b

Runners

quickCheck' :: Testable' prop => prop -> IO ()

Variant of quickCheck using the alternative Testable'.

quickCheckWith' :: Testable' prop => Args -> prop -> IO ()

Variant of quickCheckWith using the alternative Testable'.

Testable properties

class Testable' prop where

Types that represent testable properties.

This is a clone of the Testable class with an improved function instance.

Methods

property' :: prop -> Property

Instances

Testable' Bool

Defined in Test.QuickCheck.HigherOrder.Internal.Testable.Class

Methods

property' :: Bool -> Property

Testable' Property

A Property is the canonical type of testable properties.

property' @Property = property @Property = id

Defined in Test.QuickCheck.HigherOrder.Internal.Testable.Class

Methods

property' :: Property -> Property

Testable' a => Testable' (Gen a)

A generator represents a universally quantified property.

Defined in Test.QuickCheck.HigherOrder.Internal.Testable.Class

Methods

property' :: Gen a -> Property

TestEq a => Testable' (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

property' :: Equation a -> Property

(Constructible a, Testable' b) => Testable' (a -> b)

A function represents a universally quantified property.

Defined in Test.QuickCheck.HigherOrder.Internal.Testable.Class

Methods

property' :: (a -> b) -> Property

(Decidable a, Testable' b) => Testable' (Implication a b)

Just use (==>).

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

property' :: Implication a b -> Property

Types of testable properties

data Equation a

Equation: an equals sign between two values.

Constructors

(:=:) a a infix 5

Instances

Eq a => Eq (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

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

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

Ord a => Ord (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

compare :: Equation a -> Equation a -> Ordering

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

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

(>) :: Equation a -> Equation a -> Bool

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

max :: Equation a -> Equation a -> Equation a

min :: Equation a -> Equation a -> Equation a

Show a => Show (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

showsPrec :: Int -> Equation a -> ShowS

show :: Equation a -> String

showList :: [Equation a] -> ShowS

TestEq a => Testable (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

property :: Equation a -> Property

propertyForAllShrinkShow :: Gen a0 -> (a0 -> [a0]) -> (a0 -> [String]) -> (a0 -> Equation a) -> Property

TestEq a => Testable' (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

property' :: Equation a -> Property

Eq a => Decidable (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

decide :: Equation a -> Bool

data Implication a b

Expressions denoting a logical implication.

Constructors

(:==>) a b infixr 2

Instances

(Decidable a, Testable b) => Testable (Implication a b)

Just use (==>).

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

property :: Implication a b -> Property

propertyForAllShrinkShow :: Gen a0 -> (a0 -> [a0]) -> (a0 -> [String]) -> (a0 -> Implication a b) -> Property

(Decidable a, Testable' b) => Testable' (Implication a b)

Just use (==>).

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

property' :: Implication a b -> Property

type EqImpl a b = Implication (Equation a) (Equation b)

Implication between two equations.

Decidable properties

class Decidable a where

Decidable property.

Methods

decide :: a -> Bool

The definition of decidability: we can compute whether a property is true.

Instances

Decidable Bool

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

decide :: Bool -> Bool

Eq a => Decidable (Equation a)

Defined in Test.QuickCheck.HigherOrder.Internal.Testable

Methods

decide :: Equation a -> Bool

Testable equality

class TestEq a where

Testable equality

Methods

(=?) :: a -> a -> Property infix 4

A property that probably fails if the two values are not equal.

(a =? a)  =  property True

Instances

TestEq Bool

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Bool -> Bool -> Property

TestEq Char

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Char -> Char -> Property

TestEq Double

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Double -> Double -> Property

TestEq Int

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Int -> Int -> Property

TestEq Integer

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Integer -> Integer -> Property

TestEq Ordering

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Ordering -> Ordering -> Property

TestEq Word

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Word -> Word -> Property

TestEq ()

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: () -> () -> Property

TestEq a => TestEq [a]

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: [a] -> [a] -> Property

TestEq a => TestEq (Maybe a)

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Maybe a -> Maybe a -> Property

TestEq a => TestEq (Identity a)

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Identity a -> Identity a -> Property

TestEq a => TestEq (Sum a)

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Sum a -> Sum a -> Property

(Constructible a, TestEq b) => TestEq (a -> b)

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: (a -> b) -> (a -> b) -> Property

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

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: Either a b -> Either a b -> Property

(TestEq a, TestEq b) => TestEq (a, b)

Defined in Test.QuickCheck.HigherOrder.Internal.TestEq

Methods

(=?) :: (a, b) -> (a, b) -> Property

decEq :: (Eq a, Show a) => a -> a -> Property

Default method to convert Eq (decidable equality) into TestEq.

Helpers

ok :: Testable' prop => String -> prop -> (String, Property)

A named property that should pass.

Use ok and ko to construct lists of named properties [(String, Property)], which can be run using quickChecks, or testProperties from tasty-quickcheck.

ko :: Testable' prop => String -> prop -> (String, Property)

A named property that should fail.

See also ok.

quickChecks :: [(String, Property)] -> IO Bool

Execute a list of named properties.

Constructible wrappers

forAll_ :: forall a prop. (Constructible a, Testable' prop) => (a -> prop) -> Property

Equivalent to property' specialized to functions: convert a function to a Property.

data Constructed a

Constructible wrapper with Show and Arbitrary instances that operate on the representation of the argument type.

Deconstruct with the Construct pattern.

This is only useful for property combinators from vanilla QuickCheck, that use the original Testable class instead of Testable' from this library.

Instances

Constructible a => Show (Constructed a)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Methods

showsPrec :: Int -> Constructed a -> ShowS

show :: Constructed a -> String

showList :: [Constructed a] -> ShowS

Constructible a => Arbitrary (Constructed a)

Defined in Test.QuickCheck.HigherOrder.Internal.Constructible

Methods

arbitrary :: Gen (Constructed a)

shrink :: Constructed a -> [Constructed a]

pattern Construct :: a -> Constructed a

A unidirectional pattern to deconstruct Constructed values.

CoArbitrary

See also the documentation of Test.Fun.

data a :-> r infixr 1

Testable representation of functions (a -> r).

This representation supports random generation, shrinking, and printing, for property testing with QuickCheck or Hedgehog.

Higher-order functions can be represented.

Instances

Functor ((:->) a)

Defined in Test.Fun.Internal.Types

Methods

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

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

Foldable ((:->) a)

Defined in Test.Fun.Internal.Types

Methods

fold :: Monoid m => (a :-> m) -> m

foldMap :: Monoid m => (a0 -> m) -> (a :-> a0) -> m

foldMap' :: Monoid m => (a0 -> m) -> (a :-> a0) -> m

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

foldr' :: (a0 -> b -> b) -> b -> (a :-> a0) -> b

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

foldl' :: (b -> a0 -> b) -> b -> (a :-> a0) -> b

foldr1 :: (a0 -> a0 -> a0) -> (a :-> a0) -> a0

foldl1 :: (a0 -> a0 -> a0) -> (a :-> a0) -> a0

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

null :: (a :-> a0) -> Bool

length :: (a :-> a0) -> Int

elem :: Eq a0 => a0 -> (a :-> a0) -> Bool

maximum :: Ord a0 => (a :-> a0) -> a0

minimum :: Ord a0 => (a :-> a0) -> a0

sum :: Num a0 => (a :-> a0) -> a0

product :: Num a0 => (a :-> a0) -> a0

Traversable ((:->) a)

Defined in Test.Fun.Internal.Types

Methods

traverse :: Applicative f => (a0 -> f b) -> (a :-> a0) -> f (a :-> b)

sequenceA :: Applicative f => (a :-> f a0) -> f (a :-> a0)

mapM :: Monad m => (a0 -> m b) -> (a :-> a0) -> m (a :-> b)

sequence :: Monad m => (a :-> m a0) -> m (a :-> a0)

(CoArbitrary Gen a, Arbitrary r) => Arbitrary (a :-> r)

Defined in Test.QuickCheck.HigherOrder.Internal.Function

Methods

arbitrary :: Gen (a :-> r)

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

applyFun :: (a :-> r) -> a -> r

Evaluate a representation into the function it represents.

class Applicative gen => CoArbitrary (gen :: Type -> Type) a where

Implicit, default cogenerator.

Methods

coarbitrary :: Co gen a r

Instances

Applicative gen => CoArbitrary gen Word

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen Word r

Applicative gen => CoArbitrary gen Void

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen Void r

Applicative gen => CoArbitrary gen Ordering

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen Ordering r

Applicative gen => CoArbitrary gen Integer

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen Integer r

Applicative gen => CoArbitrary gen Int

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen Int r

Applicative gen => CoArbitrary gen Bool

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen Bool r

Applicative gen => CoArbitrary gen ()

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen () r

CoArbitrary gen a => CoArbitrary gen [a]

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen [a] r

CoArbitrary gen a => CoArbitrary gen (Sum a)

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen (Sum a) r

CoArbitrary gen a => CoArbitrary gen (Maybe a)

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen (Maybe a) r

CoArbitrary gen a => CoArbitrary gen (Identity a)

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen (Identity a) r

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

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen (Either a b) r

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

Defined in Test.Fun.Internal.Generic

Methods

coarbitrary :: Co gen (a, b) r

(Constructible a, CoArbitrary Gen b) => CoArbitrary Gen (a -> b)

Defined in Test.QuickCheck.HigherOrder.Internal.Function

Methods

coarbitrary :: Co Gen (a -> b) r

cogenEmbed :: Functor gen => FunName -> (a -> b) -> Co gen b r -> Co gen a r

Cogenerator for a type a from a cogenerator for b, given an embedding function (a -> b), and a name for that function (used for pretty-printing).

Example

The common usage is to construct cogenerators for newtypes.

-- Given some cogenerator of Fruit
cogenFruit :: Co Gen Fruit r

-- Wrap Fruit in a newtype
newtype Apple = Apple { unApple :: Fruit }

cogenApple :: Co Gen Apple r
cogenApple = cogenEmbed "unApple" cogenFruit

If cogenFruit generates a function that looks like:

\y -> case y :: Fruit of { ... }

then cogenApple will look like this, where y is replaced with unApple x:

\x -> case unApple x :: Fruit of { ... }

cogenIntegral :: (Applicative gen, Integral a) => TypeName -> Co gen a r

Cogenerator for an integral type. The name of the type is used for pretty-printing.

Example

cogenInteger :: Co Gen Integer r
cogenInteger = cogenIntegral "Integer"

cogenInt :: Co Gen Int r
cogenInt = cogenIntegral "Int"

cogenWord :: Co Gen Word r
cogenWord = cogenIntegral "Word"

coarbitraryGeneric :: forall a r gen. (Generic a, GCoArbitrary gen a) => Co gen a r

Generic implementation of coarbitrary.

-- Assuming MyData is a data type whose fields are all instances of CoArbitrary.

instance CoArbitrary MyData where
  coarbitrary = coarbitraryGeneric