Test.QuickCheck.Modifiers

Modifiers for test data.

These types do things such as restricting the kind of test data that can be generated. They can be pattern-matched on in properties as a stylistic alternative to using explicit quantification.

Examples:

-- Functions cannot be shown (but see Test.QuickCheck.Function)
prop_TakeDropWhile (Blind p) (xs :: [A]) =
  takeWhile p xs ++ dropWhile p xs == xs

prop_TakeDrop (NonNegative n) (xs :: [A]) =
  take n xs ++ drop n xs == xs

-- cycle does not work for empty lists
prop_Cycle (NonNegative n) (NonEmpty (xs :: [A])) =
  take n (cycle xs) == take n (xs ++ cycle xs)

-- Instead of forAll orderedList
prop_Sort (Ordered (xs :: [OrdA])) =
  sort xs == xs

Type-level modifiers for changing generator behavior

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

Methods

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

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

Enum a => Enum (Blind a)

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)

Methods

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

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

Integral a => Integral (Blind a)

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)

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)

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)

Methods

toRational :: Blind a -> Rational

Show (Blind a)

Methods

showsPrec :: Int -> Blind a -> ShowS

show :: Blind a -> String

showList :: [Blind a] -> ShowS

Arbitrary a => Arbitrary (Blind a)

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

Methods

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

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

Enum a => Enum (Fixed a)

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)

Methods

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

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

Integral a => Integral (Fixed a)

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)

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)

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)

Methods

readsPrec :: Int -> ReadS (Fixed a)

readList :: ReadS [Fixed a]

readPrec :: ReadPrec (Fixed a)

readListPrec :: ReadPrec [Fixed a]

Real a => Real (Fixed a)

Methods

toRational :: Fixed a -> Rational

Show a => Show (Fixed a)

Methods

showsPrec :: Int -> Fixed a -> ShowS

show :: Fixed a -> String

showList :: [Fixed a] -> ShowS

Arbitrary a => Arbitrary (Fixed a)

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

Methods

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

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

Eq a => Eq (OrderedList a)

Methods

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

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

Ord a => Ord (OrderedList a)

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)

Methods

readsPrec :: Int -> ReadS (OrderedList a)

readList :: ReadS [OrderedList a]

readPrec :: ReadPrec (OrderedList a)

readListPrec :: ReadPrec [OrderedList a]

Show a => Show (OrderedList a)

Methods

showsPrec :: Int -> OrderedList a -> ShowS

show :: OrderedList a -> String

showList :: [OrderedList a] -> ShowS

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

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

Methods

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

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

Eq a => Eq (NonEmptyList a)

Methods

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

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

Ord a => Ord (NonEmptyList a)

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)

Methods

readsPrec :: Int -> ReadS (NonEmptyList a)

readList :: ReadS [NonEmptyList a]

readPrec :: ReadPrec (NonEmptyList a)

readListPrec :: ReadPrec [NonEmptyList a]

Show a => Show (NonEmptyList a)

Methods

showsPrec :: Int -> NonEmptyList a -> ShowS

show :: NonEmptyList a -> String

showList :: [NonEmptyList a] -> ShowS

Arbitrary a => Arbitrary (NonEmptyList a)

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)

Methods

showsPrec :: Int -> InfiniteList a -> ShowS

show :: InfiniteList a -> String

showList :: [InfiniteList a] -> ShowS

Arbitrary a => Arbitrary (InfiniteList a)

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

Methods

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

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

Enum a => Enum (Positive a)

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)

Methods

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

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

Ord a => Ord (Positive a)

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)

Methods

readsPrec :: Int -> ReadS (Positive a)

readList :: ReadS [Positive a]

readPrec :: ReadPrec (Positive a)

readListPrec :: ReadPrec [Positive a]

Show a => Show (Positive a)

Methods

showsPrec :: Int -> Positive a -> ShowS

show :: Positive a -> String

showList :: [Positive a] -> ShowS

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

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

Methods

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

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

Enum a => Enum (NonZero a)

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)

Methods

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

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

Ord a => Ord (NonZero a)

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)

Methods

readsPrec :: Int -> ReadS (NonZero a)

readList :: ReadS [NonZero a]

readPrec :: ReadPrec (NonZero a)

readListPrec :: ReadPrec [NonZero a]

Show a => Show (NonZero a)

Methods

showsPrec :: Int -> NonZero a -> ShowS

show :: NonZero a -> String

showList :: [NonZero a] -> ShowS

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

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

Methods

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

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

Enum a => Enum (NonNegative a)

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)

Methods

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

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

Ord a => Ord (NonNegative a)

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)

Methods

readsPrec :: Int -> ReadS (NonNegative a)

readList :: ReadS [NonNegative a]

readPrec :: ReadPrec (NonNegative a)

readListPrec :: ReadPrec [NonNegative a]

Show a => Show (NonNegative a)

Methods

showsPrec :: Int -> NonNegative a -> ShowS

show :: NonNegative a -> String

showList :: [NonNegative a] -> ShowS

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

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

Methods

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

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

Enum a => Enum (Large a)

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)

Methods

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

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

Integral a => Integral (Large a)

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)

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)

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)

Methods

readsPrec :: Int -> ReadS (Large a)

readList :: ReadS [Large a]

readPrec :: ReadPrec (Large a)

readListPrec :: ReadPrec [Large a]

Real a => Real (Large a)

Methods

toRational :: Large a -> Rational

Show a => Show (Large a)

Methods

showsPrec :: Int -> Large a -> ShowS

show :: Large a -> String

showList :: [Large a] -> ShowS

Ix a => Ix (Large a)

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)

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

Methods

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

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

Enum a => Enum (Small a)

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)

Methods

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

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

Integral a => Integral (Small a)

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)

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)

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)

Methods

readsPrec :: Int -> ReadS (Small a)

readList :: ReadS [Small a]

readPrec :: ReadPrec (Small a)

readListPrec :: ReadPrec [Small a]

Real a => Real (Small a)

Methods

toRational :: Small a -> Rational

Show a => Show (Small a)

Methods

showsPrec :: Int -> Small a -> ShowS

show :: Small a -> String

showList :: [Small a] -> ShowS

Ix a => Ix (Small a)

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)

Methods

arbitrary :: Gen (Small a)

shrink :: Small a -> [Small a]

data Smart a

Smart _ x: tries a different order when shrinking.

Constructors

Smart Int a

Instances

Functor Smart

Methods

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

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

Show a => Show (Smart a)

Methods

showsPrec :: Int -> Smart a -> ShowS

show :: Smart a -> String

showList :: [Smart a] -> ShowS

Arbitrary a => Arbitrary (Smart a)

Methods

arbitrary :: Gen (Smart a)

shrink :: Smart a -> [Smart 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

Methods

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

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

Enum a => Enum (Shrink2 a)

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)

Methods

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

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

Integral a => Integral (Shrink2 a)

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)

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)

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)

Methods

readsPrec :: Int -> ReadS (Shrink2 a)

readList :: ReadS [Shrink2 a]

readPrec :: ReadPrec (Shrink2 a)

readListPrec :: ReadPrec [Shrink2 a]

Real a => Real (Shrink2 a)

Methods

toRational :: Shrink2 a -> Rational

Show a => Show (Shrink2 a)

Methods

showsPrec :: Int -> Shrink2 a -> ShowS

show :: Shrink2 a -> String

showList :: [Shrink2 a] -> ShowS

Arbitrary a => Arbitrary (Shrink2 a)

Methods

arbitrary :: Gen (Shrink2 a)

shrink :: Shrink2 a -> [Shrink2 a]

data Shrinking s a

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

Constructors

Shrinking s a

Instances

Functor (Shrinking s)

Methods

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

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

Show a => Show (Shrinking s a)

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)

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

Methods

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

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

Ord ASCIIString

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

Methods

readsPrec :: Int -> ReadS ASCIIString

readList :: ReadS [ASCIIString]

readPrec :: ReadPrec ASCIIString

readListPrec :: ReadPrec [ASCIIString]

Show ASCIIString

Methods

showsPrec :: Int -> ASCIIString -> ShowS

show :: ASCIIString -> String

showList :: [ASCIIString] -> ShowS

Arbitrary ASCIIString

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

Methods

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

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

Ord UnicodeString

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

Methods

readsPrec :: Int -> ReadS UnicodeString

readList :: ReadS [UnicodeString]

readPrec :: ReadPrec UnicodeString

readListPrec :: ReadPrec [UnicodeString]

Show UnicodeString

Methods

showsPrec :: Int -> UnicodeString -> ShowS

show :: UnicodeString -> String

showList :: [UnicodeString] -> ShowS

Arbitrary UnicodeString

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

Methods

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

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

Ord PrintableString

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

Methods

readsPrec :: Int -> ReadS PrintableString

readList :: ReadS [PrintableString]

readPrec :: ReadPrec PrintableString

readListPrec :: ReadPrec [PrintableString]

Show PrintableString

Methods

showsPrec :: Int -> PrintableString -> ShowS

show :: PrintableString -> String

showList :: [PrintableString] -> ShowS

Arbitrary PrintableString

Methods

arbitrary :: Gen PrintableString

shrink :: PrintableString -> [PrintableString]