-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | A GenT monad transformer for QuickCheck library.
--
-- A GenT monad transformer for QuickCheck library.
@package QuickCheck-GenT
@version 0.2.2.1
-- | Most of the code is borrowed from a mailing list discussion.
-- Therefor, credits go to Paul Johnson and Felix Martini.
module QuickCheck.GenT
data GenT m a
runGenT :: GenT m a -> Gen (m a)
class (Applicative g, Monad g) => MonadGen g
liftGen :: MonadGen g => Gen a -> g a
variant :: (MonadGen g, Integral n) => n -> g a -> g a
sized :: MonadGen g => (Int -> g a) -> g a
resize :: MonadGen g => Int -> g a -> g a
choose :: (MonadGen g, Random a) => (a, a) -> g a
arbitrary' :: (Arbitrary a, MonadGen m) => m a
-- | Randomly uses one of the given generators. The input list must be
-- non-empty.
oneof :: MonadGen m => [m a] -> m a
-- | Chooses one of the given generators, with a weighted random
-- distribution. The input list must be non-empty.
frequency :: MonadGen m => [(Int, m a)] -> m a
-- | Generates one of the given values. The input list must be non-empty.
elements :: MonadGen m => [a] -> m 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 :: MonadGen m => [a] -> m a
getSize :: MonadGen m => m Int
scale :: MonadGen m => (Int -> Int) -> m a -> m a
-- | Generates a value that satisfies a predicate.
suchThat :: MonadGen m => m a -> (a -> Bool) -> m a
-- | Generates a value for which the given function returns a Just,
-- and then applies the function.
suchThatMap :: MonadGen m => m a -> (a -> Maybe b) -> m b
-- | Tries to generate a value that satisfies a predicate.
suchThatMaybe :: MonadGen m => m a -> (a -> Bool) -> m (Maybe a)
applyArbitrary2 :: MonadGen m => (Arbitrary a, Arbitrary b) => (a -> b -> r) -> m r
applyArbitrary3 :: MonadGen m => (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> m r
applyArbitrary4 :: MonadGen m => (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> m r
-- | Generates a list of random length. The maximum length depends on the
-- size parameter.
listOf :: MonadGen m => m a -> m [a]
-- | Generates a non-empty list of random length. The maximum length
-- depends on the size parameter.
listOf1 :: MonadGen m => m a -> m [a]
-- | Generates a list of the given length.
vectorOf :: MonadGen m => Int -> m a -> m [a]
-- | Generates a list of a given length.
vector :: (Arbitrary a, MonadGen m) => Int -> m [a]
infiniteListOf :: MonadGen m => m a -> m [a]
infiniteList :: (Arbitrary a, MonadGen m) => m [a]
shuffle :: MonadGen m => [a] -> m [a]
sublistOf :: MonadGen m => [a] -> m [a]
orderedList :: (Ord a, Arbitrary a, MonadGen m) => m [a]
-- | Random generation and shrinking of values.
--
-- QuickCheck provides Arbitrary instances for most types in
-- base, except those which incur extra dependencies. For a
-- wider range of Arbitrary instances see the
-- quickcheck-instances package.
class Arbitrary a
-- | A generator for values of the given type.
--
-- It is worth spending time thinking about what sort of test data you
-- want - good generators are often the difference between finding bugs
-- and not finding them. You can use sample, label and
-- classify to check the quality of your test data.
--
-- There is no generic arbitrary implementation included because
-- we don't know how to make a high-quality one. If you want one,
-- consider using the testing-feat or generic-random
-- packages.
--
-- The QuickCheck manual goes into detail on how to write good
-- generators. Make sure to look at it, especially if your type is
-- recursive!
arbitrary :: Arbitrary a => Gen a
-- | Produces a (possibly) empty list of all the possible immediate shrinks
-- of the given value.
--
-- The default implementation returns the empty list, so will not try to
-- shrink the value. If your data type has no special invariants, you can
-- enable shrinking by defining shrink = genericShrink,
-- but by customising the behaviour of shrink you can often get
-- simpler counterexamples.
--
-- Most implementations of shrink should try at least three
-- things:
--
--
-- - Shrink a term to any of its immediate subterms. You can use
-- subterms to do this.
-- - Recursively apply shrink to all immediate subterms. You can
-- use recursivelyShrink to do this.
-- - Type-specific shrinkings such as replacing a constructor by a
-- simpler constructor.
--
--
-- For example, suppose we have the following implementation of binary
-- trees:
--
--
-- data Tree a = Nil | Branch a (Tree a) (Tree a)
--
--
-- We can then define shrink as follows:
--
--
-- shrink Nil = []
-- shrink (Branch x l r) =
-- -- shrink Branch to Nil
-- [Nil] ++
-- -- shrink to subterms
-- [l, r] ++
-- -- recursively shrink subterms
-- [Branch x' l' r' | (x', l', r') <- shrink (x, l, r)]
--
--
-- There are a couple of subtleties here:
--
--
-- - QuickCheck tries the shrinking candidates in the order they appear
-- in the list, so we put more aggressive shrinking steps (such as
-- replacing the whole tree by Nil) before smaller ones (such as
-- recursively shrinking the subtrees).
-- - It is tempting to write the last line as [Branch x' l' r' | x'
-- <- shrink x, l' <- shrink l, r' <- shrink r] but this is
-- the wrong thing! It will force QuickCheck to shrink x,
-- l and r in tandem, and shrinking will stop once
-- one of the three is fully shrunk.
--
--
-- There is a fair bit of boilerplate in the code above. We can avoid it
-- with the help of some generic functions. The function
-- genericShrink tries shrinking a term to all of its subterms
-- and, failing that, recursively shrinks the subterms. Using it, we can
-- define shrink as:
--
--
-- shrink x = shrinkToNil x ++ genericShrink x
-- where
-- shrinkToNil Nil = []
-- shrinkToNil (Branch _ l r) = [Nil]
--
--
-- genericShrink is a combination of subterms, which
-- shrinks a term to any of its subterms, and recursivelyShrink,
-- which shrinks all subterms of a term. These may be useful if you need
-- a bit more control over shrinking than genericShrink gives you.
--
-- A final gotcha: we cannot define shrink as simply
-- shrink x = Nil:genericShrink x as this shrinks
-- Nil to Nil, and shrinking will go into an infinite
-- loop.
--
-- If all this leaves you bewildered, you might try shrink =
-- genericShrink to begin with, after deriving
-- Generic for your type. However, if your data type has any
-- special invariants, you will need to check that genericShrink
-- can't break those invariants.
shrink :: Arbitrary a => a -> [a]
-- | A generator for values of type a.
--
-- The third-party packages QuickCheck-GenT and
-- quickcheck-transformer provide monad transformer versions of
-- Gen.
data Gen a
-- | Randomly uses one of the given generators.
oneofMay :: MonadGen m => [m a] -> m (Maybe a)
-- | Generates one of the given values.
elementsMay :: MonadGen m => [a] -> m (Maybe 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.
growingElementsMay :: MonadGen m => [a] -> m (Maybe a)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => QuickCheck.GenT.MonadGen (QuickCheck.GenT.GenT m)
instance QuickCheck.GenT.MonadGen Test.QuickCheck.Gen.Gen
instance Control.Monad.Morph.MFunctor QuickCheck.GenT.GenT
instance GHC.Base.Functor m => GHC.Base.Functor (QuickCheck.GenT.GenT m)
instance GHC.Base.Monad m => GHC.Base.Monad (QuickCheck.GenT.GenT m)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (QuickCheck.GenT.GenT m)
instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (QuickCheck.GenT.GenT m)
instance Control.Monad.Trans.Class.MonadTrans QuickCheck.GenT.GenT
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (QuickCheck.GenT.GenT m)