-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Automatic testing of Haskell programs
--   
--   QuickCheck is a library for random testing of program properties.
--   
--   The programmer provides a specification of the program, in the form of
--   properties which functions should satisfy, and QuickCheck then tests
--   that the properties hold in a large number of randomly generated
--   cases.
--   
--   Specifications are expressed in Haskell, using combinators defined in
--   the QuickCheck library. QuickCheck provides combinators to define
--   properties, observe the distribution of test data, and define test
--   data generators.
@package QuickCheck
@version 2.1.0.2

module Test.QuickCheck.Text
newtype Str
MkStr :: String -> Str
ranges :: (Integral a) => a -> a -> Str
number :: Int -> String -> String
short :: Int -> String -> String
showErr :: (Show a) => a -> String
bold :: String -> String
newTerminal :: IO Terminal
data Terminal
putTemp :: Terminal -> String -> IO ()
putPart :: Terminal -> String -> IO ()
putLine :: Terminal -> String -> IO ()
instance Show Str

module Test.QuickCheck.State

-- | State represents QuickCheck's internal state while testing a property.
--   | The state is made visible to callback functions.
data State
MkState :: Terminal -> Int -> Int -> (Int -> Int -> Int) -> Int -> Int -> [[(String, Int)]] -> Bool -> StdGen -> Bool -> Int -> Int -> State

-- | the current terminal
terminal :: State -> Terminal

-- | maximum number of successful tests needed
maxSuccessTests :: State -> Int

-- | maximum number of tests that can be discarded
maxDiscardedTests :: State -> Int

-- | how to compute the size of test cases from discarded tests
computeSize :: State -> Int -> Int -> Int

-- | the current number of tests that have succeeded
numSuccessTests :: State -> Int

-- | the current number of discarded tests
numDiscardedTests :: State -> Int

-- | all labels that have been collected so far
collected :: State -> [[(String, Int)]]

-- | indicates if the property is expected to fail
expectedFailure :: State -> Bool

-- | the current random seed
randomSeed :: State -> StdGen

-- | are we in a shrinking phase?
isShrinking :: State -> Bool

-- | number of successful shrinking steps so far
numSuccessShrinks :: State -> Int

-- | number of failed shrinking steps since the last successful shrink
numTryShrinks :: State -> Int

module Test.QuickCheck.Gen
newtype Gen a
MkGen :: (StdGen -> Int -> a) -> Gen a
unGen :: Gen a -> StdGen -> Int -> a

-- | Modifies a generator using an integer seed.
variant :: (Integral n) => n -> Gen a -> Gen a

-- | Used to construct generators that depend on the size parameter.
sized :: (Int -> Gen a) -> Gen a

-- | Overrides the size parameter. Returns a generator which uses the given
--   size instead of the runtime-size parameter.
resize :: Int -> Gen a -> Gen a

-- | Generates a random element in the given inclusive range.
choose :: (Random a) => (a, a) -> Gen a

-- | Promotes a generator to a generator of monadic values.
promote :: (Monad m) => m (Gen a) -> Gen (m a)

-- | Generates some example values.
sample' :: Gen a -> IO [a]

-- | Generates some example values and prints them to <tt>stdout</tt>.
sample :: (Show a) => Gen a -> IO ()

-- | Generates a value that satisfies a predicate.
suchThat :: Gen a -> (a -> Bool) -> Gen a

-- | Tries to generate a value that satisfies a predicate.
suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)

-- | Randomly uses one of the given generators. The input list must be
--   non-empty.
oneof :: [Gen a] -> Gen a

-- | Chooses one of the given generators, with a weighted random
--   distribution. The input list must be non-empty.
frequency :: [(Int, Gen a)] -> Gen a

-- | Generates one of the given values. The input list must be non-empty.
elements :: [a] -> Gen a

-- | Takes a list of elements of increasing size, and chooses among an
--   initial segment of the list. The size of this initial segment
--   increases with the size parameter. The input list must be non-empty.
growingElements :: [a] -> Gen a

-- | Generates a list of random length. The maximum length depends on the
--   size parameter.
listOf :: Gen a -> Gen [a]

-- | Generates a non-empty list of random length. The maximum length
--   depends on the size parameter.
listOf1 :: Gen a -> Gen [a]

-- | Generates a list of the given length.
vectorOf :: Int -> Gen a -> Gen [a]
instance Monad Gen
instance Applicative Gen
instance Functor Gen

module Test.QuickCheck.Arbitrary

-- | Random generation and shrinking of values.
class Arbitrary a
arbitrary :: (Arbitrary a) => Gen a
shrink :: (Arbitrary a) => a -> [a]

-- | Used for random generation of functions.
class CoArbitrary a
coarbitrary :: (CoArbitrary a) => a -> Gen c -> Gen c

-- | Generates an integral number. The number can be positive or negative
--   and its maximum absolute value depends on the size parameter.
arbitrarySizedIntegral :: (Num a) => Gen a

-- | Generates a fractional number. The number can be positive or negative
--   and its maximum absolute value depends on the size parameter.
arbitrarySizedFractional :: (Fractional a) => Gen a

-- | Generates an integral number. The number is chosen from the entire
--   range of the type.
arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a

-- | Generates an element of a bounded type. The element is chosen from the
--   entire range of the type.
arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a

-- | Returns no shrinking alternatives.
shrinkNothing :: a -> [a]
shrinkList :: (a -> [a]) -> [a] -> [[a]]

-- | Shrink an integral number.
shrinkIntegral :: (Integral a) => a -> [a]

-- | Shrink a fraction.
shrinkRealFrac :: (RealFrac a) => a -> [a]

-- | Combine two generator perturbing functions, for example the results of
--   calls to <a>variant</a> or <a>coarbitrary</a>.
(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> (Gen a -> Gen a)

-- | A <a>coarbitrary</a> implementation for integral numbers.
coarbitraryIntegral :: (Integral a) => a -> Gen b -> Gen b

-- | A <a>coarbitrary</a> implementation for real numbers.
coarbitraryReal :: (Real a) => a -> Gen b -> Gen b

-- | <a>coarbitrary</a> helper for lazy people :-).
coarbitraryShow :: (Show a) => a -> Gen b -> Gen b

-- | Generates a list of a given length.
vector :: (Arbitrary a) => Int -> Gen [a]

-- | Generates an ordered list of a given length.
orderedList :: (Ord a, Arbitrary a) => Gen [a]
instance CoArbitrary Double
instance CoArbitrary Float
instance CoArbitrary Char
instance CoArbitrary Int
instance CoArbitrary Integer
instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e) => CoArbitrary (a, b, c, d, e)
instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d) => CoArbitrary (a, b, c, d)
instance (CoArbitrary a, CoArbitrary b, CoArbitrary c) => CoArbitrary (a, b, c)
instance (CoArbitrary a, CoArbitrary b) => CoArbitrary (a, b)
instance (Integral a, CoArbitrary a) => CoArbitrary (Ratio a)
instance (CoArbitrary a) => CoArbitrary [a]
instance (CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b)
instance (CoArbitrary a) => CoArbitrary (Maybe a)
instance CoArbitrary Bool
instance CoArbitrary ()
instance (Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b)
instance Arbitrary Double
instance Arbitrary Float
instance Arbitrary Char
instance Arbitrary Int
instance Arbitrary Integer
instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a, b, c, d, e)
instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a, b, c, d)
instance (Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a, b, c)
instance (Arbitrary a, Arbitrary b) => Arbitrary (a, b)
instance (Integral a, Arbitrary a) => Arbitrary (Ratio a)
instance (Arbitrary a) => Arbitrary [a]
instance (Arbitrary a, Arbitrary b) => Arbitrary (Either a b)
instance (Arbitrary a) => Arbitrary (Maybe a)
instance Arbitrary Bool
instance Arbitrary ()
instance (CoArbitrary a, Arbitrary b) => Arbitrary (a -> b)

module Test.QuickCheck.Poly
newtype A
A :: Integer -> A
unA :: A -> Integer
newtype B
B :: Integer -> B
unB :: B -> Integer
newtype C
C :: Integer -> C
unC :: C -> Integer
newtype OrdA
OrdA :: Integer -> OrdA
unOrdA :: OrdA -> Integer
newtype OrdB
OrdB :: Integer -> OrdB
unOrdB :: OrdB -> Integer
newtype OrdC
OrdC :: Integer -> OrdC
unOrdC :: OrdC -> Integer
instance Eq OrdC
instance Ord OrdC
instance Eq OrdB
instance Ord OrdB
instance Eq OrdA
instance Ord OrdA
instance Eq C
instance Eq B
instance Eq A
instance CoArbitrary OrdC
instance Arbitrary OrdC
instance Show OrdC
instance CoArbitrary OrdB
instance Arbitrary OrdB
instance Show OrdB
instance CoArbitrary OrdA
instance Arbitrary OrdA
instance Show OrdA
instance CoArbitrary C
instance Arbitrary C
instance Show C
instance CoArbitrary B
instance Arbitrary B
instance Show B
instance CoArbitrary A
instance Arbitrary A
instance Show A

module Test.QuickCheck.Modifiers

-- | <tt>Blind x</tt>: as x, but x does not have to be in the <a>Show</a>
--   class.
newtype Blind a
Blind :: a -> Blind a

-- | <tt>Fixed x</tt>: as x, but will not be shrunk.
newtype Fixed a
Fixed :: a -> Fixed a

-- | <tt>Ordered xs</tt>: guarantees that xs is ordered.
newtype OrderedList a
Ordered :: [a] -> OrderedList a

-- | <tt>NonEmpty xs</tt>: guarantees that xs is non-empty.
newtype NonEmptyList a
NonEmpty :: [a] -> NonEmptyList a

-- | <tt>Positive x</tt>: guarantees that <tt>x &gt; 0</tt>.
newtype Positive a
Positive :: a -> Positive a

-- | <tt>NonZero x</tt>: guarantees that <tt>x /= 0</tt>.
newtype NonZero a
NonZero :: a -> NonZero a

-- | <tt>NonNegative x</tt>: guarantees that <tt>x &gt;= 0</tt>.
newtype NonNegative a
NonNegative :: a -> NonNegative a

-- | <tt>Smart _ x</tt>: tries a different order when shrinking.
data Smart a
Smart :: Int -> a -> Smart a

-- | <tt>Shrink2 x</tt>: allows 2 shrinking steps at the same time when
--   shrinking x
newtype Shrink2 a
Shrink2 :: a -> Shrink2 a

-- | <tt>Shrinking _ x</tt>: allows for maintaining a state during
--   shrinking.
data Shrinking s a
Shrinking :: s -> a -> Shrinking s a
class ShrinkState s a
shrinkInit :: (ShrinkState s a) => a -> s
shrinkState :: (ShrinkState s a) => a -> s -> [(a, s)]
instance (Eq a) => Eq (Shrink2 a)
instance (Ord a) => Ord (Shrink2 a)
instance (Num a) => Num (Shrink2 a)
instance (Integral a) => Integral (Shrink2 a)
instance (Real a) => Real (Shrink2 a)
instance (Enum a) => Enum (Shrink2 a)
instance (Show a) => Show (Shrink2 a)
instance (Read a) => Read (Shrink2 a)
instance (Eq a) => Eq (NonNegative a)
instance (Ord a) => Ord (NonNegative a)
instance (Num a) => Num (NonNegative a)
instance (Integral a) => Integral (NonNegative a)
instance (Real a) => Real (NonNegative a)
instance (Enum a) => Enum (NonNegative a)
instance (Show a) => Show (NonNegative a)
instance (Read a) => Read (NonNegative a)
instance (Eq a) => Eq (NonZero a)
instance (Ord a) => Ord (NonZero a)
instance (Num a) => Num (NonZero a)
instance (Integral a) => Integral (NonZero a)
instance (Real a) => Real (NonZero a)
instance (Enum a) => Enum (NonZero a)
instance (Show a) => Show (NonZero a)
instance (Read a) => Read (NonZero a)
instance (Eq a) => Eq (Positive a)
instance (Ord a) => Ord (Positive a)
instance (Num a) => Num (Positive a)
instance (Integral a) => Integral (Positive a)
instance (Real a) => Real (Positive a)
instance (Enum a) => Enum (Positive a)
instance (Show a) => Show (Positive a)
instance (Read a) => Read (Positive a)
instance (Eq a) => Eq (NonEmptyList a)
instance (Ord a) => Ord (NonEmptyList a)
instance (Show a) => Show (NonEmptyList a)
instance (Read a) => Read (NonEmptyList a)
instance (Eq a) => Eq (OrderedList a)
instance (Ord a) => Ord (OrderedList a)
instance (Show a) => Show (OrderedList a)
instance (Read a) => Read (OrderedList a)
instance (Eq a) => Eq (Fixed a)
instance (Ord a) => Ord (Fixed a)
instance (Num a) => Num (Fixed a)
instance (Integral a) => Integral (Fixed a)
instance (Real a) => Real (Fixed a)
instance (Enum a) => Enum (Fixed a)
instance (Show a) => Show (Fixed a)
instance (Read a) => Read (Fixed a)
instance (Eq a) => Eq (Blind a)
instance (Ord a) => Ord (Blind a)
instance (Num a) => Num (Blind a)
instance (Integral a) => Integral (Blind a)
instance (Real a) => Real (Blind a)
instance (Enum a) => Enum (Blind a)
instance (Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a)
instance (Show a) => Show (Shrinking s a)
instance (Arbitrary a) => Arbitrary (Smart a)
instance (Show a) => Show (Smart a)
instance (Arbitrary a) => Arbitrary (Shrink2 a)
instance (Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a)
instance (Num a, Ord a, Arbitrary a) => Arbitrary (NonZero a)
instance (Num a, Ord a, Arbitrary a) => Arbitrary (Positive a)
instance (Arbitrary a) => Arbitrary (NonEmptyList a)
instance (Ord a, Arbitrary a) => Arbitrary (OrderedList a)
instance (Arbitrary a) => Arbitrary (Fixed a)
instance (Arbitrary a) => Arbitrary (Blind a)
instance Show (Blind a)

module Test.QuickCheck.Property
type Property = Gen Prop

-- | The class of things which can be tested, i.e. turned into a property.
class Testable prop
property :: (Testable prop) => prop -> Property
newtype Prop
MkProp :: Rose (IO Result) -> Prop
unProp :: Prop -> Rose (IO Result)
data Rose a
MkRose :: a -> [Rose a] -> Rose a
join :: Rose (Rose a) -> Rose a

-- | Different kinds of callbacks
data Callback

-- | Called just after a test
PostTest :: (State -> Result -> IO ()) -> Callback

-- | Called with the final failing test-case
PostFinalFailure :: (State -> Result -> IO ()) -> Callback

-- | The result of a single test.
data Result
MkResult :: Maybe Bool -> Bool -> String -> [(String, Int)] -> [Callback] -> Result

-- | result of the test case; Nothing = discard
ok :: Result -> Maybe Bool

-- | indicates what the expected result of the property is
expect :: Result -> Bool

-- | a message indicating what went wrong
reason :: Result -> String

-- | the collected values for this test case
stamp :: Result -> [(String, Int)]

-- | the callbacks for this test case
callbacks :: Result -> [Callback]
result :: Result
failed :: Result
exception :: (Show a) => a -> Result
succeeded :: Result
rejected :: Result
liftBool :: Bool -> Property
liftResult :: Result -> Property
liftIOResult :: IO Result -> Property
liftRoseIOResult :: Rose (IO Result) -> Property
mapResult :: (Testable prop) => (Result -> Result) -> prop -> Property
mapIOResult :: (Testable prop) => (IO Result -> IO Result) -> prop -> Property
mapRoseIOResult :: (Testable prop) => (Rose (IO Result) -> Rose (IO Result)) -> prop -> Property
mapProp :: (Testable prop) => (Prop -> Prop) -> prop -> Property

-- | Changes the maximum test case size for a property.
mapSize :: (Testable prop) => (Int -> Int) -> prop -> Property

-- | Shrinks the argument to property if it fails. Shrinking is done
--   automatically for most types. This is only needed weh you want to
--   override the default behavior.
shrinking :: (Testable prop) => (a -> [a]) -> a -> (a -> prop) -> Property

-- | Adds a callback
callback :: (Testable prop) => Callback -> prop -> Property

-- | Performs an <a>IO</a> action after the last failure of a property.
whenFail :: (Testable prop) => IO () -> prop -> Property

-- | Performs an <a>IO</a> action every time a property fails. Thus, if
--   shrinking is done, this can be used to keep track of the failures
--   along the way.
whenFail' :: (Testable prop) => IO () -> prop -> Property

-- | Modifies a property so that it is expected to fail for some test
--   cases.
expectFailure :: (Testable prop) => prop -> Property

-- | Attaches a label to a property. This is used for reporting test case
--   distribution.
label :: (Testable prop) => String -> prop -> Property

-- | Labels a property with a value:
--   
--   <pre>
--   collect x = label (show x)
--   </pre>
collect :: (Show a, Testable prop) => a -> prop -> Property

-- | Conditionally labels test case.
classify :: (Testable prop) => Bool -> String -> prop -> Property

-- | Checks that at least the given proportion of the test cases belong to
--   the given class.
cover :: (Testable prop) => Bool -> Int -> String -> prop -> Property

-- | Implication for properties: The resulting property holds if the first
--   argument is <a>False</a>, or if the given property holds.
(==>) :: (Testable prop) => Bool -> prop -> Property

-- | Considers a property failed if it does not complete within the given
--   number of microseconds.
within :: (Testable prop) => Int -> prop -> Property

-- | Explicit universal quantification: uses an explicitly given test case
--   generator.
forAll :: (Show a, Testable prop) => Gen a -> (a -> prop) -> Property

-- | Like <a>forAll</a>, but tries to shrink the argument for failing test
--   cases.
forAllShrink :: (Show a, Testable prop) => Gen a -> (a -> [a]) -> (a -> prop) -> Property
(.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
instance Monad Rose
instance Functor Rose
instance (Arbitrary a, Show a, Testable prop) => Testable (a -> prop)
instance (Testable prop) => Testable (Gen prop)
instance Testable Prop
instance Testable Result
instance Testable Bool
instance Testable ()

module Test.QuickCheck.Test

-- | Args specifies arguments to the QuickCheck driver
data Args
Args :: Maybe (StdGen, Int) -> Int -> Int -> Int -> Args

-- | should we replay a previous test?
replay :: Args -> Maybe (StdGen, Int)

-- | maximum number of successful tests before succeeding
maxSuccess :: Args -> Int

-- | maximum number of discarded tests before giving up
maxDiscard :: Args -> Int

-- | size to use for the biggest test cases
maxSize :: Args -> Int

-- | Result represents the test result
data Result
Success :: [(String, Int)] -> Result

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]
GaveUp :: Int -> [(String, Int)] -> Result

-- | number of successful tests performed
numTests :: Result -> Int

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]
Failure :: StdGen -> Int -> String -> [(String, Int)] -> Result

-- | what seed was used
usedSeed :: Result -> StdGen

-- | what was the test size
usedSize :: Result -> Int

-- | what was the reason
reason :: Result -> String

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]
NoExpectedFailure :: [(String, Int)] -> Result

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]

-- | isSuccess checks if the test run result was a success
isSuccess :: Result -> Bool

-- | stdArgs are the default test arguments used
stdArgs :: Args

-- | Tests a property and prints the results to <tt>stdout</tt>.
quickCheck :: (Testable prop) => prop -> IO ()

-- | Tests a property, using test arguments, and prints the results to
--   <tt>stdout</tt>.
quickCheckWith :: (Testable prop) => Args -> prop -> IO ()

-- | Tests a property, produces a test result, and prints the results to
--   <tt>stdout</tt>.
quickCheckResult :: (Testable prop) => prop -> IO Result

-- | Tests a property, using test arguments, produces a test result, and
--   prints the results to <tt>stdout</tt>.
quickCheckWithResult :: (Testable prop) => Args -> prop -> IO Result
test :: State -> (StdGen -> Int -> Prop) -> IO Result
doneTesting :: State -> (StdGen -> Int -> Prop) -> IO Result
giveUp :: State -> (StdGen -> Int -> Prop) -> IO Result
runATest :: State -> (StdGen -> Int -> Prop) -> IO Result
summary :: State -> [(String, Int)]
success :: State -> IO ()
foundFailure :: State -> Result -> [Rose (IO Result)] -> IO ()
localMin :: State -> Result -> [Rose (IO Result)] -> IO ()
callbackPostTest :: State -> Result -> IO ()
callbackPostFinalFailure :: State -> Result -> IO ()
instance Show Result
instance Read Result
instance Show Args
instance Read Args

module Test.QuickCheck.Function
data Fun a b
Fun :: (a :-> b) -> (a -> b) -> Fun a b
apply :: Fun a b -> (a -> b)
data (:->) a c
class FunArbitrary a
funArbitrary :: (FunArbitrary a, Arbitrary c) => Gen (a :-> c)
funArbitraryMap :: (FunArbitrary a, Arbitrary c) => (b -> a) -> (a -> b) -> Gen (b :-> c)
funArbitraryShow :: (Show a, Read a, Arbitrary c) => Gen (a :-> c)
instance (FunArbitrary a, Arbitrary b) => Arbitrary (Fun a b)
instance (Show a, Show b) => Show (Fun a b)
instance FunArbitrary OrdC
instance FunArbitrary OrdB
instance FunArbitrary OrdA
instance FunArbitrary C
instance FunArbitrary B
instance FunArbitrary A
instance FunArbitrary Char
instance FunArbitrary Int
instance FunArbitrary Integer
instance FunArbitrary Bool
instance (FunArbitrary a) => FunArbitrary (Maybe a)
instance (FunArbitrary a) => FunArbitrary [a]
instance FunArbitrary Word8
instance FunArbitrary ()
instance (FunArbitrary a, FunArbitrary b) => FunArbitrary (Either a b)
instance (FunArbitrary a, FunArbitrary b) => FunArbitrary (a, b)
instance (FunArbitrary a, Arbitrary c) => Arbitrary (a :-> c)
instance (Show a, Show b) => Show (a :-> b)
instance Functor ((:->) a)


-- | Allows testing of monadic values.
module Test.QuickCheck.Monadic
newtype PropertyM m a
MkPropertyM :: ((a -> Gen (m Property)) -> Gen (m Property)) -> PropertyM m a
unPropertyM :: PropertyM m a -> (a -> Gen (m Property)) -> Gen (m Property)
assert :: (Monad m) => Bool -> PropertyM m ()
pre :: (Monad m) => Bool -> PropertyM m ()
run :: (Monad m) => m a -> PropertyM m a
pick :: (Monad m, Show a) => Gen a -> PropertyM m a
wp :: (Monad m) => m a -> (a -> PropertyM m b) -> PropertyM m b
forAllM :: (Monad m, Show a) => Gen a -> (a -> PropertyM m b) -> PropertyM m b
monitor :: (Monad m) => (Property -> Property) -> PropertyM m ()
monadic :: (Monad m) => (m Property -> Property) -> PropertyM m a -> Property
monadicIO :: PropertyM IO a -> Property
newtype IdM m s a
MkIdM :: m s a -> IdM m s a
unIdM :: IdM m s a -> m s a
data MonadS' m
MkMonadS :: (forall a s. a -> m s a) -> (forall a b s. m s a -> (a -> m s b) -> m s b) -> MonadS' m
ret :: MonadS' m -> forall a s. a -> m s a
bin :: MonadS' m -> forall a b s. m s a -> (a -> m s b) -> m s b
class MonadS m
return' :: (MonadS m) => a -> m s a
bind' :: (MonadS m) => m s a -> (a -> m s b) -> m s b
instance (MonadS m) => Monad (IdM m s)
instance (Monad m) => Monad (PropertyM m)
instance Functor (PropertyM m)

module Test.QuickCheck

-- | Tests a property and prints the results to <tt>stdout</tt>.
quickCheck :: (Testable prop) => prop -> IO ()

-- | Args specifies arguments to the QuickCheck driver
data Args
Args :: Maybe (StdGen, Int) -> Int -> Int -> Int -> Args

-- | should we replay a previous test?
replay :: Args -> Maybe (StdGen, Int)

-- | maximum number of successful tests before succeeding
maxSuccess :: Args -> Int

-- | maximum number of discarded tests before giving up
maxDiscard :: Args -> Int

-- | size to use for the biggest test cases
maxSize :: Args -> Int

-- | Result represents the test result
data Result
Success :: [(String, Int)] -> Result

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]
GaveUp :: Int -> [(String, Int)] -> Result

-- | number of successful tests performed
numTests :: Result -> Int

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]
Failure :: StdGen -> Int -> String -> [(String, Int)] -> Result

-- | what seed was used
usedSeed :: Result -> StdGen

-- | what was the test size
usedSize :: Result -> Int

-- | what was the reason
reason :: Result -> String

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]
NoExpectedFailure :: [(String, Int)] -> Result

-- | labels and frequencies found during all tests
labels :: Result -> [(String, Int)]

-- | stdArgs are the default test arguments used
stdArgs :: Args

-- | Tests a property, using test arguments, and prints the results to
--   <tt>stdout</tt>.
quickCheckWith :: (Testable prop) => Args -> prop -> IO ()

-- | Tests a property, using test arguments, produces a test result, and
--   prints the results to <tt>stdout</tt>.
quickCheckWithResult :: (Testable prop) => Args -> prop -> IO Result

-- | Tests a property, produces a test result, and prints the results to
--   <tt>stdout</tt>.
quickCheckResult :: (Testable prop) => prop -> IO Result
data Gen a

-- | Used to construct generators that depend on the size parameter.
sized :: (Int -> Gen a) -> Gen a

-- | Overrides the size parameter. Returns a generator which uses the given
--   size instead of the runtime-size parameter.
resize :: Int -> Gen a -> Gen a

-- | Generates a random element in the given inclusive range.
choose :: (Random a) => (a, a) -> Gen a

-- | Promotes a generator to a generator of monadic values.
promote :: (Monad m) => m (Gen a) -> Gen (m a)

-- | Generates a value that satisfies a predicate.
suchThat :: Gen a -> (a -> Bool) -> Gen a

-- | Tries to generate a value that satisfies a predicate.
suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)

-- | Randomly uses one of the given generators. The input list must be
--   non-empty.
oneof :: [Gen a] -> Gen a

-- | Chooses one of the given generators, with a weighted random
--   distribution. The input list must be non-empty.
frequency :: [(Int, Gen a)] -> Gen a

-- | Generates one of the given values. The input list must be non-empty.
elements :: [a] -> Gen a

-- | Takes a list of elements of increasing size, and chooses among an
--   initial segment of the list. The size of this initial segment
--   increases with the size parameter. The input list must be non-empty.
growingElements :: [a] -> Gen a

-- | Generates a list of random length. The maximum length depends on the
--   size parameter.
listOf :: Gen a -> Gen [a]

-- | Generates a non-empty list of random length. The maximum length
--   depends on the size parameter.
listOf1 :: Gen a -> Gen [a]

-- | Generates a list of the given length.
vectorOf :: Int -> Gen a -> Gen [a]

-- | Generates a list of a given length.
vector :: (Arbitrary a) => Int -> Gen [a]

-- | Generates an ordered list of a given length.
orderedList :: (Ord a, Arbitrary a) => Gen [a]

-- | Generates some example values and prints them to <tt>stdout</tt>.
sample :: (Show a) => Gen a -> IO ()

-- | Generates some example values.
sample' :: Gen a -> IO [a]

-- | Random generation and shrinking of values.
class Arbitrary a
arbitrary :: (Arbitrary a) => Gen a
shrink :: (Arbitrary a) => a -> [a]

-- | Used for random generation of functions.
class CoArbitrary a
coarbitrary :: (CoArbitrary a) => a -> Gen c -> Gen c

-- | Generates an integral number. The number can be positive or negative
--   and its maximum absolute value depends on the size parameter.
arbitrarySizedIntegral :: (Num a) => Gen a

-- | Generates a fractional number. The number can be positive or negative
--   and its maximum absolute value depends on the size parameter.
arbitrarySizedFractional :: (Fractional a) => Gen a

-- | Generates an integral number. The number is chosen from the entire
--   range of the type.
arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a

-- | Generates an element of a bounded type. The element is chosen from the
--   entire range of the type.
arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a

-- | Returns no shrinking alternatives.
shrinkNothing :: a -> [a]

-- | Shrink an integral number.
shrinkIntegral :: (Integral a) => a -> [a]

-- | Shrink a fraction.
shrinkRealFrac :: (RealFrac a) => a -> [a]

-- | Modifies a generator using an integer seed.
variant :: (Integral n) => n -> Gen a -> Gen a

-- | Combine two generator perturbing functions, for example the results of
--   calls to <a>variant</a> or <a>coarbitrary</a>.
(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> (Gen a -> Gen a)

-- | A <a>coarbitrary</a> implementation for integral numbers.
coarbitraryIntegral :: (Integral a) => a -> Gen b -> Gen b

-- | A <a>coarbitrary</a> implementation for real numbers.
coarbitraryReal :: (Real a) => a -> Gen b -> Gen b

-- | <a>coarbitrary</a> helper for lazy people :-).
coarbitraryShow :: (Show a) => a -> Gen b -> Gen b

-- | <tt>Blind x</tt>: as x, but x does not have to be in the <a>Show</a>
--   class.
newtype Blind a
Blind :: a -> Blind a

-- | <tt>Fixed x</tt>: as x, but will not be shrunk.
newtype Fixed a
Fixed :: a -> Fixed a

-- | <tt>Ordered xs</tt>: guarantees that xs is ordered.
newtype OrderedList a
Ordered :: [a] -> OrderedList a

-- | <tt>NonEmpty xs</tt>: guarantees that xs is non-empty.
newtype NonEmptyList a
NonEmpty :: [a] -> NonEmptyList a

-- | <tt>Positive x</tt>: guarantees that <tt>x &gt; 0</tt>.
newtype Positive a
Positive :: a -> Positive a

-- | <tt>NonZero x</tt>: guarantees that <tt>x /= 0</tt>.
newtype NonZero a
NonZero :: a -> NonZero a

-- | <tt>NonNegative x</tt>: guarantees that <tt>x &gt;= 0</tt>.
newtype NonNegative a
NonNegative :: a -> NonNegative a

-- | <tt>Smart _ x</tt>: tries a different order when shrinking.
data Smart a
Smart :: Int -> a -> Smart a

-- | <tt>Shrink2 x</tt>: allows 2 shrinking steps at the same time when
--   shrinking x
newtype Shrink2 a
Shrink2 :: a -> Shrink2 a

-- | <tt>Shrinking _ x</tt>: allows for maintaining a state during
--   shrinking.
data Shrinking s a
Shrinking :: s -> a -> Shrinking s a
class ShrinkState s a
shrinkInit :: (ShrinkState s a) => a -> s
shrinkState :: (ShrinkState s a) => a -> s -> [(a, s)]
type Property = Gen Prop
data Prop

-- | The class of things which can be tested, i.e. turned into a property.
class Testable prop
property :: (Testable prop) => prop -> Property

-- | Changes the maximum test case size for a property.
mapSize :: (Testable prop) => (Int -> Int) -> prop -> Property

-- | Shrinks the argument to property if it fails. Shrinking is done
--   automatically for most types. This is only needed weh you want to
--   override the default behavior.
shrinking :: (Testable prop) => (a -> [a]) -> a -> (a -> prop) -> Property

-- | Implication for properties: The resulting property holds if the first
--   argument is <a>False</a>, or if the given property holds.
(==>) :: (Testable prop) => Bool -> prop -> Property

-- | Explicit universal quantification: uses an explicitly given test case
--   generator.
forAll :: (Show a, Testable prop) => Gen a -> (a -> prop) -> Property

-- | Like <a>forAll</a>, but tries to shrink the argument for failing test
--   cases.
forAllShrink :: (Show a, Testable prop) => Gen a -> (a -> [a]) -> (a -> prop) -> Property
(.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property

-- | Performs an <a>IO</a> action after the last failure of a property.
whenFail :: (Testable prop) => IO () -> prop -> Property

-- | Performs an <a>IO</a> action every time a property fails. Thus, if
--   shrinking is done, this can be used to keep track of the failures
--   along the way.
whenFail' :: (Testable prop) => IO () -> prop -> Property

-- | Modifies a property so that it is expected to fail for some test
--   cases.
expectFailure :: (Testable prop) => prop -> Property

-- | Considers a property failed if it does not complete within the given
--   number of microseconds.
within :: (Testable prop) => Int -> prop -> Property

-- | Attaches a label to a property. This is used for reporting test case
--   distribution.
label :: (Testable prop) => String -> prop -> Property

-- | Labels a property with a value:
--   
--   <pre>
--   collect x = label (show x)
--   </pre>
collect :: (Show a, Testable prop) => a -> prop -> Property

-- | Conditionally labels test case.
classify :: (Testable prop) => Bool -> String -> prop -> Property

-- | Checks that at least the given proportion of the test cases belong to
--   the given class.
cover :: (Testable prop) => Bool -> Int -> String -> prop -> Property
newtype Str
MkStr :: String -> Str
ranges :: (Integral a) => a -> a -> Str