Safe Haskell	Trustworthy
Language	Haskell98

Test.QuickCheck.Modifiers

Contents

Type-level modifiers for changing generator behavior

Description

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

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
Fields getBlind :: a

newtype Fixed a Source #

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

Constructors

Fixed
Fields getFixed :: a

Instances

Functor Fixed Source #
Methods fmap :: (a -> b) -> Fixed a -> Fixed b # (<$) :: a -> Fixed b -> Fixed a #
Enum a => Enum (Fixed a) Source #
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) Source #
Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed a -> Bool #
Integral a => Integral (Fixed a) Source #
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) Source #
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) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (Fixed a) # readList :: ReadS [Fixed a] # readPrec :: ReadPrec (Fixed a) # readListPrec :: ReadPrec [Fixed a] #
Real a => Real (Fixed a) Source #
Methods toRational :: Fixed a -> Rational #
Show a => Show (Fixed a) Source #
Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Arbitrary a => Arbitrary (Fixed a) Source #
Methods arbitrary :: Gen (Fixed a) Source # shrink :: Fixed a -> [Fixed a] Source #

newtype OrderedList a Source #

Ordered xs: guarantees that xs is ordered.

Constructors

Ordered
Fields getOrdered :: [a]

Instances

Functor OrderedList Source #
Methods fmap :: (a -> b) -> OrderedList a -> OrderedList b # (<$) :: a -> OrderedList b -> OrderedList a #
Eq a => Eq (OrderedList a) Source #
Methods (==) :: OrderedList a -> OrderedList a -> Bool # (/=) :: OrderedList a -> OrderedList a -> Bool #
Ord a => Ord (OrderedList a) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (OrderedList a) # readList :: ReadS [OrderedList a] # readPrec :: ReadPrec (OrderedList a) # readListPrec :: ReadPrec [OrderedList a] #
Show a => Show (OrderedList a) Source #
Methods showsPrec :: Int -> OrderedList a -> ShowS # show :: OrderedList a -> String # showList :: [OrderedList a] -> ShowS #
(Ord a, Arbitrary a) => Arbitrary (OrderedList a) Source #
Methods arbitrary :: Gen (OrderedList a) Source # shrink :: OrderedList a -> [OrderedList a] Source #

newtype NonEmptyList a Source #

NonEmpty xs: guarantees that xs is non-empty.

Constructors

NonEmpty
Fields getNonEmpty :: [a]

Instances

Functor NonEmptyList Source #
Methods fmap :: (a -> b) -> NonEmptyList a -> NonEmptyList b # (<$) :: a -> NonEmptyList b -> NonEmptyList a #
Eq a => Eq (NonEmptyList a) Source #
Methods (==) :: NonEmptyList a -> NonEmptyList a -> Bool # (/=) :: NonEmptyList a -> NonEmptyList a -> Bool #
Ord a => Ord (NonEmptyList a) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (NonEmptyList a) # readList :: ReadS [NonEmptyList a] # readPrec :: ReadPrec (NonEmptyList a) # readListPrec :: ReadPrec [NonEmptyList a] #
Show a => Show (NonEmptyList a) Source #
Methods showsPrec :: Int -> NonEmptyList a -> ShowS # show :: NonEmptyList a -> String # showList :: [NonEmptyList a] -> ShowS #
Arbitrary a => Arbitrary (NonEmptyList a) Source #
Methods arbitrary :: Gen (NonEmptyList a) Source # shrink :: NonEmptyList a -> [NonEmptyList a] Source #

newtype Positive a Source #

Positive x: guarantees that x > 0.

Constructors

Positive
Fields getPositive :: a

Instances

Functor Positive Source #
Methods fmap :: (a -> b) -> Positive a -> Positive b # (<$) :: a -> Positive b -> Positive a #
Enum a => Enum (Positive a) Source #
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) Source #
Methods (==) :: Positive a -> Positive a -> Bool # (/=) :: Positive a -> Positive a -> Bool #
Ord a => Ord (Positive a) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (Positive a) # readList :: ReadS [Positive a] # readPrec :: ReadPrec (Positive a) # readListPrec :: ReadPrec [Positive a] #
Show a => Show (Positive a) Source #
Methods showsPrec :: Int -> Positive a -> ShowS # show :: Positive a -> String # showList :: [Positive a] -> ShowS #
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a) Source #
Methods arbitrary :: Gen (Positive a) Source # shrink :: Positive a -> [Positive a] Source #

newtype NonZero a Source #

NonZero x: guarantees that x /= 0.

Constructors

NonZero
Fields getNonZero :: a

Instances

Functor NonZero Source #
Methods fmap :: (a -> b) -> NonZero a -> NonZero b # (<$) :: a -> NonZero b -> NonZero a #
Enum a => Enum (NonZero a) Source #
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) Source #
Methods (==) :: NonZero a -> NonZero a -> Bool # (/=) :: NonZero a -> NonZero a -> Bool #
Ord a => Ord (NonZero a) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (NonZero a) # readList :: ReadS [NonZero a] # readPrec :: ReadPrec (NonZero a) # readListPrec :: ReadPrec [NonZero a] #
Show a => Show (NonZero a) Source #
Methods showsPrec :: Int -> NonZero a -> ShowS # show :: NonZero a -> String # showList :: [NonZero a] -> ShowS #
(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a) Source #
Methods arbitrary :: Gen (NonZero a) Source # shrink :: NonZero a -> [NonZero a] Source #

newtype NonNegative a Source #

NonNegative x: guarantees that x >= 0.

Constructors

NonNegative
Fields getNonNegative :: a

Instances

Functor NonNegative Source #
Methods fmap :: (a -> b) -> NonNegative a -> NonNegative b # (<$) :: a -> NonNegative b -> NonNegative a #
Enum a => Enum (NonNegative a) Source #
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) Source #
Methods (==) :: NonNegative a -> NonNegative a -> Bool # (/=) :: NonNegative a -> NonNegative a -> Bool #
Ord a => Ord (NonNegative a) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (NonNegative a) # readList :: ReadS [NonNegative a] # readPrec :: ReadPrec (NonNegative a) # readListPrec :: ReadPrec [NonNegative a] #
Show a => Show (NonNegative a) Source #
Methods showsPrec :: Int -> NonNegative a -> ShowS # show :: NonNegative a -> String # showList :: [NonNegative a] -> ShowS #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a) Source #
Methods arbitrary :: Gen (NonNegative a) Source # shrink :: NonNegative a -> [NonNegative a] Source #

newtype Large a Source #

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 Source #
Methods fmap :: (a -> b) -> Large a -> Large b # (<$) :: a -> Large b -> Large a #
Enum a => Enum (Large a) Source #
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) Source #
Methods (==) :: Large a -> Large a -> Bool # (/=) :: Large a -> Large a -> Bool #
Integral a => Integral (Large a) Source #
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) Source #
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) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (Large a) # readList :: ReadS [Large a] # readPrec :: ReadPrec (Large a) # readListPrec :: ReadPrec [Large a] #
Real a => Real (Large a) Source #
Methods toRational :: Large a -> Rational #
Show a => Show (Large a) Source #
Methods showsPrec :: Int -> Large a -> ShowS # show :: Large a -> String # showList :: [Large a] -> ShowS #
Ix a => Ix (Large a) Source #
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) Source #
Methods arbitrary :: Gen (Large a) Source # shrink :: Large a -> [Large a] Source #

newtype Small a Source #

Small x: generates values of x drawn from a small range. The opposite of Large.

Constructors

Small
Fields getSmall :: a

Instances

Functor Small Source #
Methods fmap :: (a -> b) -> Small a -> Small b # (<$) :: a -> Small b -> Small a #
Enum a => Enum (Small a) Source #
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) Source #
Methods (==) :: Small a -> Small a -> Bool # (/=) :: Small a -> Small a -> Bool #
Integral a => Integral (Small a) Source #
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) Source #
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) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (Small a) # readList :: ReadS [Small a] # readPrec :: ReadPrec (Small a) # readListPrec :: ReadPrec [Small a] #
Real a => Real (Small a) Source #
Methods toRational :: Small a -> Rational #
Show a => Show (Small a) Source #
Methods showsPrec :: Int -> Small a -> ShowS # show :: Small a -> String # showList :: [Small a] -> ShowS #
Ix a => Ix (Small a) Source #
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) Source #
Methods arbitrary :: Gen (Small a) Source # shrink :: Small a -> [Small a] Source #

data Smart a Source #

Smart _ x: tries a different order when shrinking.

Constructors

Smart Int a

Instances

Functor Smart Source #
Methods fmap :: (a -> b) -> Smart a -> Smart b # (<$) :: a -> Smart b -> Smart a #
Show a => Show (Smart a) Source #
Methods showsPrec :: Int -> Smart a -> ShowS # show :: Smart a -> String # showList :: [Smart a] -> ShowS #
Arbitrary a => Arbitrary (Smart a) Source #
Methods arbitrary :: Gen (Smart a) Source # shrink :: Smart a -> [Smart a] Source #

newtype Shrink2 a Source #

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

Constructors

Shrink2
Fields getShrink2 :: a

Instances

Functor Shrink2 Source #
Methods fmap :: (a -> b) -> Shrink2 a -> Shrink2 b # (<$) :: a -> Shrink2 b -> Shrink2 a #
Enum a => Enum (Shrink2 a) Source #
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) Source #
Methods (==) :: Shrink2 a -> Shrink2 a -> Bool # (/=) :: Shrink2 a -> Shrink2 a -> Bool #
Integral a => Integral (Shrink2 a) Source #
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) Source #
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) Source #
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) Source #
Methods readsPrec :: Int -> ReadS (Shrink2 a) # readList :: ReadS [Shrink2 a] # readPrec :: ReadPrec (Shrink2 a) # readListPrec :: ReadPrec [Shrink2 a] #
Real a => Real (Shrink2 a) Source #
Methods toRational :: Shrink2 a -> Rational #
Show a => Show (Shrink2 a) Source #
Methods showsPrec :: Int -> Shrink2 a -> ShowS # show :: Shrink2 a -> String # showList :: [Shrink2 a] -> ShowS #
Arbitrary a => Arbitrary (Shrink2 a) Source #
Methods arbitrary :: Gen (Shrink2 a) Source # shrink :: Shrink2 a -> [Shrink2 a] Source #

data Shrinking s a Source #

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

Constructors

Shrinking s a

Instances

Functor (Shrinking s) Source #
Methods fmap :: (a -> b) -> Shrinking s a -> Shrinking s b # (<$) :: a -> Shrinking s b -> Shrinking s a #
Show a => Show (Shrinking s a) Source #
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) Source #
Methods arbitrary :: Gen (Shrinking s a) Source # shrink :: Shrinking s a -> [Shrinking s a] Source #

class ShrinkState s a where Source #

Minimal complete definition

shrinkInit, shrinkState

Methods

shrinkInit :: a -> s Source #

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

newtype ASCIIString Source #

ASCIIString: generates an ASCII string.

Constructors

ASCIIString
Fields getASCIIString :: String

Instances

Eq ASCIIString Source #
Methods (==) :: ASCIIString -> ASCIIString -> Bool # (/=) :: ASCIIString -> ASCIIString -> Bool #
Ord ASCIIString Source #
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 Source #
Methods readsPrec :: Int -> ReadS ASCIIString # readList :: ReadS [ASCIIString] # readPrec :: ReadPrec ASCIIString # readListPrec :: ReadPrec [ASCIIString] #
Show ASCIIString Source #
Methods showsPrec :: Int -> ASCIIString -> ShowS # show :: ASCIIString -> String # showList :: [ASCIIString] -> ShowS #
Arbitrary ASCIIString Source #
Methods arbitrary :: Gen ASCIIString Source # shrink :: ASCIIString -> [ASCIIString] Source #

newtype UnicodeString Source #

UnicodeString: generates a unicode String. The string will not contain surrogate pairs.

Constructors

UnicodeString
Fields getUnicodeString :: String

Instances

Eq UnicodeString Source #
Methods (==) :: UnicodeString -> UnicodeString -> Bool # (/=) :: UnicodeString -> UnicodeString -> Bool #
Ord UnicodeString Source #
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 Source #
Methods readsPrec :: Int -> ReadS UnicodeString # readList :: ReadS [UnicodeString] # readPrec :: ReadPrec UnicodeString # readListPrec :: ReadPrec [UnicodeString] #
Show UnicodeString Source #
Methods showsPrec :: Int -> UnicodeString -> ShowS # show :: UnicodeString -> String # showList :: [UnicodeString] -> ShowS #
Arbitrary UnicodeString Source #
Methods arbitrary :: Gen UnicodeString Source # shrink :: UnicodeString -> [UnicodeString] Source #

newtype PrintableString Source #

PrintableString: generates a printable unicode String. The string will not contain surrogate pairs.

Constructors

PrintableString
Fields getPrintableString :: String

Instances

Eq PrintableString Source #
Methods (==) :: PrintableString -> PrintableString -> Bool # (/=) :: PrintableString -> PrintableString -> Bool #
Ord PrintableString Source #
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 Source #
Methods readsPrec :: Int -> ReadS PrintableString # readList :: ReadS [PrintableString] # readPrec :: ReadPrec PrintableString # readListPrec :: ReadPrec [PrintableString] #
Show PrintableString Source #
Methods showsPrec :: Int -> PrintableString -> ShowS # show :: PrintableString -> String # showList :: [PrintableString] -> ShowS #
Arbitrary PrintableString Source #
Methods arbitrary :: Gen PrintableString Source # shrink :: PrintableString -> [PrintableString] Source #

Functor Blind Source #
Methods fmap :: (a -> b) -> Blind a -> Blind b # (<$) :: a -> Blind b -> Blind a #
Enum a => Enum (Blind a) Source #
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) Source #
Methods (==) :: Blind a -> Blind a -> Bool # (/=) :: Blind a -> Blind a -> Bool #
Integral a => Integral (Blind a) Source #
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) Source #
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) Source #
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) Source #
Methods toRational :: Blind a -> Rational #
Show (Blind a) Source #
Methods showsPrec :: Int -> Blind a -> ShowS # show :: Blind a -> String # showList :: [Blind a] -> ShowS #
Arbitrary a => Arbitrary (Blind a) Source #
Methods arbitrary :: Gen (Blind a) Source # shrink :: Blind a -> [Blind a] Source #