QuickCheck-2.3.0.2: Automatic testing of Haskell programs

Test.QuickCheck.Modifiers

Contents

Synopsis

Type-level modifiers for changing generator behavior

newtype Blind a Source

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

Constructors

Blind a 

Instances

Enum a => Enum (Blind a) 
Eq a => Eq (Blind a) 
Integral a => Integral (Blind a) 
Num a => Num (Blind a) 
Ord a => Ord (Blind a) 
Real a => Real (Blind a) 
Show (Blind a) 
Arbitrary a => Arbitrary (Blind a) 

newtype Fixed a Source

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

Constructors

Fixed a 

Instances

Enum a => Enum (Fixed a) 
Eq a => Eq (Fixed a) 
Integral a => Integral (Fixed a) 
Num a => Num (Fixed a) 
Ord a => Ord (Fixed a) 
Read a => Read (Fixed a) 
Real a => Real (Fixed a) 
Show a => Show (Fixed a) 
Arbitrary a => Arbitrary (Fixed a) 

newtype OrderedList a Source

Ordered xs: guarantees that xs is ordered.

Constructors

Ordered [a] 

Instances

Eq a => Eq (OrderedList a) 
Ord a => Ord (OrderedList a) 
Read a => Read (OrderedList a) 
Show a => Show (OrderedList a) 
(Ord a, Arbitrary a) => Arbitrary (OrderedList a) 

newtype NonEmptyList a Source

NonEmpty xs: guarantees that xs is non-empty.

Constructors

NonEmpty [a] 

Instances

newtype Positive a Source

Positive x: guarantees that x > 0.

Constructors

Positive a 

Instances

Enum a => Enum (Positive a) 
Eq a => Eq (Positive a) 
Integral a => Integral (Positive a) 
Num a => Num (Positive a) 
Ord a => Ord (Positive a) 
Read a => Read (Positive a) 
Real a => Real (Positive a) 
Show a => Show (Positive a) 
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a) 

newtype NonZero a Source

NonZero x: guarantees that x /= 0.

Constructors

NonZero a 

Instances

Enum a => Enum (NonZero a) 
Eq a => Eq (NonZero a) 
Integral a => Integral (NonZero a) 
Num a => Num (NonZero a) 
Ord a => Ord (NonZero a) 
Read a => Read (NonZero a) 
Real a => Real (NonZero a) 
Show a => Show (NonZero a) 
(Num a, Ord a, Arbitrary a) => Arbitrary (NonZero a) 

newtype NonNegative a Source

NonNegative x: guarantees that x >= 0.

Constructors

NonNegative a 

Instances

Enum a => Enum (NonNegative a) 
Eq a => Eq (NonNegative a) 
Integral a => Integral (NonNegative a) 
Num a => Num (NonNegative a) 
Ord a => Ord (NonNegative a) 
Read a => Read (NonNegative a) 
Real a => Real (NonNegative a) 
Show a => Show (NonNegative a) 
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a) 

data Smart a Source

Smart _ x: tries a different order when shrinking.

Constructors

Smart Int a 

Instances

Show a => Show (Smart a) 
Arbitrary a => Arbitrary (Smart a) 

newtype Shrink2 a Source

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

Constructors

Shrink2 a 

Instances

Enum a => Enum (Shrink2 a) 
Eq a => Eq (Shrink2 a) 
Integral a => Integral (Shrink2 a) 
Num a => Num (Shrink2 a) 
Ord a => Ord (Shrink2 a) 
Read a => Read (Shrink2 a) 
Real a => Real (Shrink2 a) 
Show a => Show (Shrink2 a) 
Arbitrary a => Arbitrary (Shrink2 a) 

data Shrinking s a Source

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

Constructors

Shrinking s a 

Instances

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

class ShrinkState s a whereSource

Methods

shrinkInit :: a -> sSource

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