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


-- | Check properties on standard classes and data structures.
--   
--   '<a>Checkers'</a> wraps up the expected properties associated with
--   various standard type classes as QuickCheck properties. Also some
--   morphism properties. It also provides arbitrary instances and
--   generator combinators for common data types.
--   
--   © 2008-2013 by Conal Elliott; BSD3 license.
@package checkers
@version 0.4.13

module Test.QuickCheck.Bottoms
bottom :: Gen a
infiniteComp :: Gen a

module Test.QuickCheck.Instances.Array
instance (GHC.Arr.Ix a, GHC.Real.Integral a, Test.QuickCheck.Arbitrary.Arbitrary b) => Test.QuickCheck.Arbitrary.Arbitrary (GHC.Arr.Array a b)
instance Test.QuickCheck.Arbitrary.CoArbitrary b => Test.QuickCheck.Arbitrary.CoArbitrary (GHC.Arr.Array a b)

module Test.QuickCheck.Instances.Maybe
maybeGen :: Gen a -> Gen (Maybe a)

module Test.QuickCheck.Instances.Num
nonNegative :: (Num a, Arbitrary a) => Gen a
nonPositive :: (Num a, Arbitrary a) => Gen a
negative :: (Eq a, Num a, Arbitrary a) => Gen a
positive :: (Eq a, Num a, Arbitrary a) => Gen a
nonZero :: (Eq a, Num a) => Gen a -> Gen a
nonZero_ :: (Eq a, Num a, Arbitrary a) => Gen a

module Test.QuickCheck.Instances.List

-- | Generates any list (possibly empty) with the contents generated using
--   its argument.
anyList :: Gen a -> Gen [a]

-- | Generates a non-empty list with the contents generated using its
--   argument.
nonEmpty :: Gen a -> Gen [a]

-- | Generates an infinite list with contents generated using its argument
infiniteList :: Gen a -> Gen [a]

-- | Generates a list with a set length
setLength :: Int -> Gen a -> Gen [a]

-- | Generate increasing towards infinity
increasing :: (Arbitrary a, Eq a, Num a) => Gen [a]

-- | Generate nondecreasing values
nondecreasing :: (Arbitrary a, Num a) => Gen [a]

-- | Generate an infinite list of increasing values
increasingInf :: (Arbitrary a, Eq a, Num a) => Gen [a]

-- | Generate an infinite list of nondecreasing values
nondecreasingInf :: (Arbitrary a, Num a) => Gen [a]

-- | Generate increasing towards infinity
decreasing :: (Arbitrary a, Eq a, Num a) => Gen [a]

-- | Generate nondecreasing values
nonincreasing :: (Arbitrary a, Num a) => Gen [a]

-- | Generate an infinite list of increasing values
decreasingInf :: (Arbitrary a, Eq a, Num a) => Gen [a]

-- | Generate an infinite list of nondecreasing values
nonincreasingInf :: (Arbitrary a, Num a) => Gen [a]

module Test.QuickCheck.Instances.Ord
greaterThan :: Ord a => a -> Gen a -> Gen a
lessThan :: Ord a => a -> Gen a -> Gen a

module Test.QuickCheck.Instances.Tuple

-- | Generates a 2-tuple using its arguments to generate the parts.
(>*<) :: Gen a -> Gen b -> Gen (a, b)

-- | Generates a 3-tuple using its arguments to generate the parts.
(>**<) :: Gen a -> Gen b -> Gen c -> Gen (a, b, c)

-- | Generates a 4-tuple using its arguments to generate the parts.
(>***<) :: Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d)

-- | Generates a 5-tuple using its arguments to generate the parts.
(>****<) :: Gen a -> Gen b -> Gen c -> Gen d -> Gen e -> Gen (a, b, c, d, e)


-- | These are some general purpose utilities for use with QuickCheck.
--   
--   Copied from QuickCheck 1.2.0.0. Doesn't appear in 2.x
module Test.QuickCheck.Utils
isAssociativeBy :: (Show a, Testable prop) => (a -> a -> prop) -> Gen a -> (a -> a -> a) -> Property
isAssociative :: (Arbitrary a, Show a, Eq a) => (a -> a -> a) -> Property
isCommutableBy :: (Show a, Testable prop) => (b -> b -> prop) -> Gen a -> (a -> a -> b) -> Property
isCommutable :: (Arbitrary a, Show a, Eq b) => (a -> a -> b) -> Property
isTotalOrder :: Ord a => a -> a -> Property


-- | Some QuickCheck helpers
module Test.QuickCheck.Checkers

-- | Named test
type Test = (String, Property)

-- | Named batch of tests
type TestBatch = (String, [Test])

-- | Flatten a test batch for inclusion in another
unbatch :: TestBatch -> [Test]

-- | Run a batch of tests. See <a>quickBatch</a> and <a>verboseBatch</a>.
checkBatch :: Args -> TestBatch -> IO ()

-- | Check a batch tersely.
quickBatch :: TestBatch -> IO ()

-- | Check a batch verbosely.
verboseBatch :: TestBatch -> IO ()

-- | Unary function, handy for type annotations
type Unop a = a -> a

-- | Binary function, handy for type annotations
type Binop a = a -> a -> a
genR :: Random a => (a, a) -> Gen a

-- | <tt>f</tt> is its own inverse. See also <a>inverse</a>.
involution :: (Show a, Arbitrary a, EqProp a) => (a -> a) -> Property

-- | <tt>f</tt> is a left inverse of <tt>g</tt>. See also <a>inverse</a>.
inverseL :: (EqProp b, Arbitrary b, Show b) => (a -> b) -> (b -> a) -> Property

-- | <tt>f</tt> is a left and right inverse of <tt>g</tt>. See also
--   <a>inverseL</a>.
inverse :: (EqProp a, Arbitrary a, Show a, EqProp b, Arbitrary b, Show b) => (a -> b) -> (b -> a) -> Property

-- | Token <a>Fractional</a> type for tests
type FracT = Float

-- | Token <a>Num</a> type for tests
type NumT = Int

-- | Token <a>Ord</a> type for tests
type OrdT = Int

-- | Token uninteresting type for tests
type T = Char

-- | Types of values that can be tested for equality, perhaps through
--   random sampling.
class EqProp a
(=-=) :: EqProp a => a -> a -> Property
infix 4 =-=

-- | For <a>Eq</a> types as <a>EqProp</a> types
eq :: Eq a => a -> a -> Property
type BinRel a = a -> a -> Bool

-- | Reflexive property: <tt>a <tt>rel</tt> a</tt>
reflexive :: (Arbitrary a, Show a) => BinRel a -> Property

-- | Transitive property: <tt>a <tt>rel</tt> b &amp;&amp; b <tt>rel</tt> c
--   ==&gt; a <tt>rel</tt> c</tt>. Generate <tt>a</tt> randomly, but use
--   <tt>gen a</tt> to generate <tt>b</tt> and <tt>gen b</tt> to generate
--   <tt>c</tt>. <tt>gen</tt> ought to satisfy <tt>rel</tt> fairly often.
transitive :: (Arbitrary a, Show a) => BinRel a -> (a -> Gen a) -> Property

-- | Symmetric property: <tt>a <tt>rel</tt> b ==&gt; b <tt>rel</tt> a</tt>.
--   Generate <tt>a</tt> randomly, but use <tt>gen a</tt> to generate
--   <tt>b</tt>. <tt>gen</tt> ought to satisfy <tt>rel</tt> fairly often.
symmetric :: (Arbitrary a, Show a) => BinRel a -> (a -> Gen a) -> Property

-- | Symmetric property: <tt>a <tt>rel</tt> b &amp;&amp; b <tt>rel</tt> a
--   ==&gt; a == b</tt>. Generate <tt>a</tt> randomly, but use <tt>gen
--   a</tt> to generate <tt>b</tt>. <tt>gen</tt> ought to satisfy both
--   <tt>rel</tt> directions fairly often but not always.
antiSymmetric :: (Arbitrary a, Show a, Eq a) => BinRel a -> (a -> Gen a) -> Property

-- | Has a given left identity, according to '(=-=)'
leftId :: (Show a, Arbitrary a, EqProp a) => (i -> a -> a) -> i -> Property

-- | Has a given right identity, according to '(=-=)'
rightId :: (Show a, Arbitrary a, EqProp a) => (a -> i -> a) -> i -> Property

-- | Has a given left and right identity, according to '(=-=)'
bothId :: (Show a, Arbitrary a, EqProp a) => (a -> a -> a) -> a -> Property

-- | Associative, according to '(=-=)'
isAssoc :: (EqProp a, Show a, Arbitrary a) => (a -> a -> a) -> Property

-- | Commutative, according to '(=-=)'
isCommut :: (EqProp a, Show a, Arbitrary a) => (a -> a -> a) -> Property

-- | Commutative, according to '(=-=)'
commutes :: EqProp z => (a -> a -> z) -> a -> a -> Property

-- | Explicit <a>Monoid</a> dictionary. Doesn't have to correspond to an
--   actual <a>Monoid</a> instance, though see <a>monoidD</a>.
data MonoidD a

-- | <a>Monoid</a> dictionary built from the <a>Monoid</a> methods.
monoidD :: Monoid a => MonoidD a

-- | Monoid dictionary for an unwrapped endomorphism. See also
--   <a>monoidD</a> and <tt>Endo</tt>.
endoMonoidD :: MonoidD (a -> a)

-- | Homomorphism properties with respect to given monoid dictionaries. See
--   also <tt>monoidMorphism</tt>.
homomorphism :: (EqProp b, Show a, Arbitrary a) => MonoidD a -> MonoidD b -> (a -> b) -> [(String, Property)]

-- | The unary function <tt>f</tt> is idempotent, i.e., <tt>f . f == f</tt>
idempotent :: (Show a, Arbitrary a, EqProp a) => (a -> a) -> Property

-- | A binary function <tt>op</tt> is idempotent, i.e., <tt>x <tt>op</tt> x
--   == x</tt>, for all <tt>x</tt>
idempotent2 :: (Show a, Arbitrary a, EqProp a) => (a -> a -> a) -> Property

-- | A binary function <tt>op</tt> is has an idempotent element <tt>x</tt>,
--   i.e., <tt>x <tt>op</tt> x == x</tt>
idemElem :: EqProp a => (a -> a -> a) -> a -> Property
class Model a b | a -> b
model :: Model a b => a -> b
meq :: (Model a b, EqProp b) => a -> b -> Property
meq1 :: (Model a b, Model a1 b1, EqProp b) => (a1 -> a) -> (b1 -> b) -> a1 -> Property
meq2 :: (Model a b, Model a1 b1, Model a2 b2, EqProp b) => (a1 -> a2 -> a) -> (b1 -> b2 -> b) -> a1 -> a2 -> Property
meq3 :: (Model a b, Model a1 b1, Model a2 b2, Model a3 b3, EqProp b) => (a1 -> a2 -> a3 -> a) -> (b1 -> b2 -> b3 -> b) -> a1 -> a2 -> a3 -> Property
meq4 :: (Model a b, Model a1 b1, Model a2 b2, Model a3 b3, Model a4 b4, EqProp b) => (a1 -> a2 -> a3 -> a4 -> a) -> (b1 -> b2 -> b3 -> b4 -> b) -> a1 -> a2 -> a3 -> a4 -> Property
meq5 :: (Model a b, Model a1 b1, Model a2 b2, Model a3 b3, Model a4 b4, Model a5 b5, EqProp b) => (a1 -> a2 -> a3 -> a4 -> a5 -> a) -> (b1 -> b2 -> b3 -> b4 -> b5 -> b) -> a1 -> a2 -> a3 -> a4 -> a5 -> Property
eqModels :: (Model a b, EqProp b) => a -> a -> Property

-- | Like <a>Model</a> but for unary type constructors.
class Model1 f g | f -> g
model1 :: forall a. Model1 f g => f a -> g a

-- | Generate n arbitrary values
arbs :: Arbitrary a => Int -> IO [a]

-- | Produce n values from a generator
gens :: Int -> Gen a -> IO [a]

-- | Nondeterministic choice: <tt>p1</tt> <a>.&amp;.</a> <tt>p2</tt> picks
--   randomly one of <tt>p1</tt> and <tt>p2</tt> to test. If you test the
--   property 100 times it makes 100 random choices.
(.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
infixr 1 .&.
arbitrarySatisfying :: Arbitrary a => (a -> Bool) -> Gen a
instance Test.QuickCheck.Checkers.Model GHC.Types.Bool GHC.Types.Bool
instance Test.QuickCheck.Checkers.Model GHC.Types.Char GHC.Types.Char
instance Test.QuickCheck.Checkers.Model GHC.Types.Int GHC.Types.Int
instance Test.QuickCheck.Checkers.Model GHC.Types.Float GHC.Types.Float
instance Test.QuickCheck.Checkers.Model GHC.Types.Double GHC.Types.Double
instance Test.QuickCheck.Checkers.Model GHC.Base.String GHC.Base.String
instance (Test.QuickCheck.Checkers.Model a b, Test.QuickCheck.Checkers.Model a' b') => Test.QuickCheck.Checkers.Model (a, a') (b, b')
instance Test.QuickCheck.Checkers.EqProp ()
instance Test.QuickCheck.Checkers.EqProp GHC.Types.Bool
instance Test.QuickCheck.Checkers.EqProp GHC.Types.Char
instance Test.QuickCheck.Checkers.EqProp GHC.Types.Int
instance Test.QuickCheck.Checkers.EqProp GHC.Types.Float
instance Test.QuickCheck.Checkers.EqProp GHC.Types.Double
instance Test.QuickCheck.Checkers.EqProp a => Test.QuickCheck.Checkers.EqProp [a]
instance Test.QuickCheck.Checkers.EqProp a => Test.QuickCheck.Checkers.EqProp (GHC.Maybe.Maybe a)
instance (Test.QuickCheck.Checkers.EqProp a, Test.QuickCheck.Checkers.EqProp b) => Test.QuickCheck.Checkers.EqProp (a, b)
instance (Test.QuickCheck.Checkers.EqProp a, Test.QuickCheck.Checkers.EqProp b, Test.QuickCheck.Checkers.EqProp c) => Test.QuickCheck.Checkers.EqProp (a, b, c)
instance (Test.QuickCheck.Checkers.EqProp a, Test.QuickCheck.Checkers.EqProp b, Test.QuickCheck.Checkers.EqProp c, Test.QuickCheck.Checkers.EqProp d) => Test.QuickCheck.Checkers.EqProp (a, b, c, d)
instance (Test.QuickCheck.Checkers.EqProp a, Test.QuickCheck.Checkers.EqProp b) => Test.QuickCheck.Checkers.EqProp (Data.Either.Either a b)
instance (GHC.Show.Show a, Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Checkers.EqProp b) => Test.QuickCheck.Checkers.EqProp (a -> b)
instance Test.QuickCheck.Property.Testable a => Test.QuickCheck.Property.Testable [a]
instance (Test.QuickCheck.Property.Testable a, Test.QuickCheck.Property.Testable b) => Test.QuickCheck.Property.Testable (a, b)


-- | Later. Allows for testing of functions that depend on the order of
--   evaluation.
--   
--   TODO: move this functionality to the testing package for Unamb.
module Test.QuickCheck.Later

-- | Is the given function associative when restricted to the same value
--   but possibly different times?
isAssocTimes :: (EqProp a, Arbitrary a, Show a) => Double -> (a -> a -> a) -> Property

-- | Is the given function commutative when restricted to the same value
--   but possibly different times?
isCommutTimes :: (EqProp b, Arbitrary a, Show a) => Double -> (a -> a -> b) -> Property

-- | Delay a value's availability by the given duration in seconds. Note
--   that the delay happens only on the first evaluation.
delay :: RealFrac t => t -> a -> a

-- | A value that is never available. Rerun of <tt>hang</tt> from unamb,
--   but replicated to avoid mutual dependency.
--   
--   TODO: Remove when this module is moved into the unamb-test package.
delayForever :: a

module Test.QuickCheck.Instances.Eq
notEqualTo :: Eq a => a -> Gen a -> Gen a
notOneof :: (Eq a, Arbitrary a) => [a] -> Gen a

module Test.QuickCheck.Instances.Char

-- | Generates a 'non space' character, i.e. any ascii except ' ', '\t',
--   '\n' and '\r'.
nonSpace :: Gen Char

-- | Generates any whitespace character, including new lines.
whitespace :: Gen Char

-- | Generates a whitespace charecter, not a newline.
space :: Gen Char

-- | Generates either a '\n' or '\r'.
newline :: Gen Char

-- | Generates any lower case alpha character.
lowerAlpha :: Gen Char

-- | Generates any upper case alpha character.
upperAlpha :: Gen Char

-- | Generates a digit character.
numeric :: Gen Char

-- | Generates one or other of '(' and ')'.
parenthesis :: Gen Char

-- | Generates one or other of '[' and ']'.
bracket :: Gen Char

-- | Generates one or other of '{' and '}'.
brace :: Gen Char

-- | Generates one of <a>*</a>, <a>/</a>, <a>-</a>, <a>+</a>, <a>&lt;</a>,
--   <a>&gt;</a>, '|' and <tt>#</tt>.
operator :: Gen Char

module Test.QuickCheck.Instances


-- | Some QuickCheck properties for standard type classes
module Test.QuickCheck.Classes

-- | Total ordering. <tt>gen a</tt> ought to generate values <tt>b</tt>
--   satisfying <tt>a <tt>rel</tt> b</tt> fairly often.
ordRel :: forall a. (Ord a, Show a, Arbitrary a) => BinRel a -> (a -> Gen a) -> TestBatch

-- | Total ordering
ord :: forall a. (Ord a, Show a, Arbitrary a) => (a -> Gen a) -> TestBatch

-- | <a>Ord</a> morphism properties. <tt>h</tt> is an <a>Ord</a> morphism
--   iff:
--   
--   <pre>
--   a &lt;= b = h a &lt;= h b
--   
--   h (a `min` b) = h a `min` h b
--   h (a `max` b) = h a `max` h b
--   </pre>
ordMorphism :: (Ord a, Ord b, EqProp b, Show a, Arbitrary a) => (a -> b) -> TestBatch

-- | The semantic function (<a>model</a>) for <tt>a</tt> is an
--   <a>ordMorphism</a>.
semanticOrd :: forall a b. (Model a b, Ord a, Ord b, Show a, Arbitrary a, EqProp b) => a -> TestBatch

-- | Properties to check that the <a>Semigroup</a> <tt>a</tt> satisfies the
--   semigroup properties. The argument value is ignored and is present
--   only for its type.
semigroup :: forall a. (Semigroup a, Show a, Arbitrary a, EqProp a) => a -> TestBatch

-- | Properties to check that the <a>Monoid</a> <tt>a</tt> satisfies the
--   monoid properties. The argument value is ignored and is present only
--   for its type.
monoid :: forall a. (Monoid a, Show a, Arbitrary a, EqProp a) => a -> TestBatch

-- | Monoid homomorphism properties. See also <a>homomorphism</a>.
monoidMorphism :: (Monoid a, Monoid b, EqProp b, Show a, Arbitrary a) => (a -> b) -> TestBatch

-- | The semantic function (<a>model</a>) for <tt>a</tt> is a
--   <a>monoidMorphism</a>.
semanticMonoid :: forall a b. (Model a b, Monoid a, Monoid b, Show a, Arbitrary a, EqProp b) => a -> TestBatch

-- | Properties to check that the <a>Functor</a> <tt>m</tt> satisfies the
--   functor properties.
functor :: forall m a b c. (Functor m, Arbitrary b, Arbitrary c, CoArbitrary a, CoArbitrary b, Show (m a), Arbitrary (m a), EqProp (m a), EqProp (m c)) => m (a, b, c) -> TestBatch

-- | <a>Functor</a> morphism (natural transformation) properties
functorMorphism :: forall f g. (Functor f, Functor g, Arbitrary (f NumT), Show (f NumT), EqProp (g T)) => (forall a. f a -> g a) -> TestBatch

-- | The semantic function (<a>model1</a>) for <tt>f</tt> is a
--   <a>functorMorphism</a>.
semanticFunctor :: forall f g. (Model1 f g, Functor f, Functor g, Arbitrary (f NumT), Show (f NumT), EqProp (g T)) => f () -> TestBatch
functorMonoid :: forall m a b. (Functor m, Monoid (m a), Monoid (m b), CoArbitrary a, Arbitrary b, Arbitrary (m a), Show (m a), EqProp (m b)) => m (a, b) -> TestBatch

-- | Properties to check that the <a>Apply</a> <tt>m</tt> satisfies the
--   apply properties
apply :: forall m a b c. (Apply m, CoArbitrary a, Arbitrary b, CoArbitrary b, Arbitrary c, Arbitrary (m a), Arbitrary (m (b -> c)), Show (m (b -> c)), Arbitrary (m (a -> b)), Show (m (a -> b)), Show (m a), EqProp (m c)) => m (a, b, c) -> TestBatch

-- | <a>Apply</a> morphism properties
applyMorphism :: forall f g. (Apply f, Apply g, Show (f NumT), Arbitrary (f NumT), EqProp (g T), Show (f (NumT -> T)), Arbitrary (f (NumT -> T))) => (forall a. f a -> g a) -> TestBatch

-- | The semantic function (<a>model1</a>) for <tt>f</tt> is an
--   <a>applyMorphism</a>.
semanticApply :: forall f g. (Model1 f g, Apply f, Apply g, Arbitrary (f NumT), Arbitrary (f (NumT -> T)), EqProp (g T), Show (f NumT), Show (f (NumT -> T))) => f () -> TestBatch

-- | Properties to check that the <a>Applicative</a> <tt>m</tt> satisfies
--   the applicative properties
applicative :: forall m a b c. (Applicative m, Arbitrary a, CoArbitrary a, Arbitrary b, Arbitrary (m a), Arbitrary (m (b -> c)), Show (m (b -> c)), Arbitrary (m (a -> b)), Show (m (a -> b)), Show a, Show (m a), EqProp (m a), EqProp (m b), EqProp (m c)) => m (a, b, c) -> TestBatch

-- | <a>Applicative</a> morphism properties
applicativeMorphism :: forall f g. (Applicative f, Applicative g, Show (f NumT), Arbitrary (f NumT), EqProp (g NumT), EqProp (g T), Show (f (NumT -> T)), Arbitrary (f (NumT -> T))) => (forall a. f a -> g a) -> TestBatch

-- | The semantic function (<a>model1</a>) for <tt>f</tt> is an
--   <a>applicativeMorphism</a>.
semanticApplicative :: forall f g. (Model1 f g, Applicative f, Applicative g, Arbitrary (f NumT), Arbitrary (f (NumT -> T)), EqProp (g NumT), EqProp (g T), Show (f NumT), Show (f (NumT -> T))) => f () -> TestBatch

-- | Properties to check that the <a>bind</a> <tt>m</tt> satisfies the bind
--   properties
bind :: forall m a b c. (Bind m, CoArbitrary a, CoArbitrary b, Arbitrary (m a), EqProp (m a), Show (m a), Arbitrary (m b), Arbitrary (m c), EqProp (m c), Arbitrary (m (m (m a))), Show (m (m (m a)))) => m (a, b, c) -> TestBatch

-- | <a>bind</a> morphism properties
bindMorphism :: forall f g. (Bind f, Bind g, Show (f NumT), Show (f (f (NumT -> T))), Arbitrary (f NumT), Arbitrary (f T), Arbitrary (f (f (NumT -> T))), EqProp (g T), EqProp (g (NumT -> T))) => (forall a. f a -> g a) -> TestBatch

-- | The semantic function (<a>model1</a>) for <tt>f</tt> is a
--   <a>bindMorphism</a>.
semanticBind :: forall f g. (Model1 f g, Bind f, Bind g, EqProp (g T), EqProp (g (NumT -> T)), Arbitrary (f T), Arbitrary (f NumT), Arbitrary (f (f (NumT -> T))), Show (f (f (NumT -> T))), Show (f NumT)) => f () -> TestBatch
bindApply :: forall m a b. (Bind m, EqProp (m b), Show (m a), Arbitrary (m a), Show (m (a -> b)), Arbitrary (m (a -> b))) => m (a, b) -> TestBatch

-- | Properties to check that the <a>Monad</a> <tt>m</tt> satisfies the
--   monad properties
monad :: forall m a b c. (Monad m, Show a, Arbitrary a, CoArbitrary a, CoArbitrary b, Arbitrary (m a), EqProp (m a), Show (m a), Arbitrary (m b), EqProp (m b), Arbitrary (m c), EqProp (m c)) => m (a, b, c) -> TestBatch

-- | <a>Monad</a> morphism properties
--   
--   <a>Applicative</a> morphism properties
monadMorphism :: forall f g. (Monad f, Monad g, Show (f NumT), Show (f (f (NumT -> T))), Arbitrary (f NumT), Arbitrary (f T), Arbitrary (f (f (NumT -> T))), EqProp (g NumT), EqProp (g T), EqProp (g (NumT -> T))) => (forall a. f a -> g a) -> TestBatch

-- | The semantic function (<a>model1</a>) for <tt>f</tt> is a
--   <a>monadMorphism</a>.
semanticMonad :: forall f g. (Model1 f g, Monad f, Monad g, EqProp (g T), EqProp (g NumT), EqProp (g (NumT -> T)), Arbitrary (f T), Arbitrary (f NumT), Arbitrary (f (f (NumT -> T))), Show (f (f (NumT -> T))), Show (f NumT)) => f () -> TestBatch

-- | Law for monads that are also instances of <a>Functor</a>.
monadFunctor :: forall m a b. (Monad m, Arbitrary b, CoArbitrary a, Arbitrary (m a), Show (m a), EqProp (m b)) => m (a, b) -> TestBatch
monadApplicative :: forall m a b. (Monad m, EqProp (m a), EqProp (m b), Show a, Arbitrary a, Show (m a), Arbitrary (m a), Show (m (a -> b)), Arbitrary (m (a -> b))) => m (a, b) -> TestBatch
arrow :: forall a b c d e. (Arrow a, Show (a d e), Show (a c d), Show (a b c), Arbitrary (a d e), Arbitrary (a c d), Arbitrary (a b c), Arbitrary c, Arbitrary d, Arbitrary e, CoArbitrary b, CoArbitrary c, CoArbitrary d, EqProp (a b e), EqProp (a b d), EqProp (a (b, d) c), EqProp (a (b, d) (c, d)), EqProp (a (b, e) (d, e)), EqProp (a (b, d) (c, e))) => a b (c, d, e) -> TestBatch
arrowChoice :: forall a b c d e. (ArrowChoice a, Show (a b c), Arbitrary (a b c), Arbitrary c, Arbitrary e, CoArbitrary b, CoArbitrary d, EqProp (a (Either b d) (Either c e)), EqProp (a (Either b d) (Either c d))) => a b (c, d, e) -> TestBatch

-- | Note that <a>foldable</a> doesn't check the strictness of
--   <a>foldl'</a>, <a>foldr'</a> and <tt>foldMap'</tt>.
foldable :: forall t a b m n o. (Foldable t, CoArbitrary a, CoArbitrary b, Arbitrary a, Arbitrary b, Arbitrary o, Arbitrary (t a), Arbitrary (t m), Arbitrary (t n), Arbitrary (t o), Monoid m, Num n, Ord o, EqProp m, EqProp n, EqProp b, EqProp o, EqProp a, Show (t m), Show (t n), Show (t o), Show b, Show (t a), Show o) => t (a, b, m, n, o) -> TestBatch
foldableFunctor :: forall t a m. (Functor t, Foldable t, CoArbitrary a, Arbitrary m, Arbitrary (t a), EqProp m, Monoid m, Show (t a)) => t (a, m) -> TestBatch
traversable :: forall f a b m. (Traversable f, Monoid m, Show (f a), Arbitrary (f a), Arbitrary b, Arbitrary m, CoArbitrary a, EqProp (f b), EqProp m) => f (a, b, m) -> TestBatch

-- | Laws for MonadPlus instances with left distribution.
monadPlus :: forall m a b. (MonadPlus m, Show (m a), CoArbitrary a, Arbitrary (m a), Arbitrary (m b), EqProp (m a), EqProp (m b)) => m (a, b) -> TestBatch

-- | Laws for MonadPlus instances with left catch.
monadOr :: forall m a b. (MonadPlus m, Show a, Show (m a), Arbitrary a, CoArbitrary a, Arbitrary (m a), Arbitrary (m b), EqProp (m a), EqProp (m b)) => m (a, b) -> TestBatch

-- | Check Alt Semigroup law
alt :: forall f a. (Alt f, Arbitrary (f a), EqProp (f a), Show (f a)) => f a -> TestBatch

-- | Check Alternative Monoid laws
alternative :: forall f a. (Alternative f, Arbitrary (f a), EqProp (f a), Show (f a)) => f a -> TestBatch