Test.QuickCheck.Modifiers

Contents

Type-level modifiers for changing generator behavior

Synopsis

newtype Blind a = Blind a
newtype Fixed a = Fixed a
newtype OrderedList a = Ordered [a]
newtype NonEmptyList a = NonEmpty [a]
newtype Positive a = Positive a
newtype NonZero a = NonZero a
newtype NonNegative a = NonNegative a
data Smart a = Smart Int a
newtype Shrink2 a = Shrink2 a
data Shrinking s a = Shrinking s a
class ShrinkState s a where
- shrinkInit :: a -> s
- shrinkState :: a -> s -> [(a, s)]

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

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

Eq a => Eq (NonEmptyList a)

Ord a => Ord (NonEmptyList a)

Read a => Read (NonEmptyList a)

Show a => Show (NonEmptyList a)

Arbitrary a => Arbitrary (NonEmptyList a)

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