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


-- | Hedgehog will eat your typeclass bugs
--   
--   This library provides Hedgehog properties to ensure that typeclass
--   instances adhere to the set of laws that they are supposed to. There
--   are other libraries that do similar things, such as
--   `genvalidity-hspec` and <a>checkers</a>. This library differs from
--   other solutions by not introducing any new typeclasses that the user
--   needs to learn, and otherwise minimal API overhead.
--   
--   This library is directly inspired by `quickcheck-classes`.
@package hedgehog-classes
@version 0.2.5.4


-- | This library provides sets of properties that should hold for common
--   typeclasses.
--   
--   <i>Note:</i> functions that test laws of a subclass never test the
--   laws of a superclass. For example, <a>commutativeSemigroupLaws</a>
--   never tests the laws provided by <a>semigroupLaws</a>.
module Hedgehog.Classes

-- | A convenience function for testing the properties of a typeclass. For
--   example, in GHCi:
--   
--   <pre>
--   &gt;&gt;&gt; genOrdering :: Gen Ordering; genOrdering = frequency [(1,pure EQ),(1,pure LT),(1,pure GT)]
--   
--   &gt;&gt;&gt; lawsCheck (monoidLaws genOrdering)
--   Monoid: Left Identity    ✓ &lt;interactive&gt; passed 100 tests.
--   Monoid: Right Identity    ✓ &lt;interactive&gt; passed 100 tests.
--   Monoid: Associativity    ✓ &lt;interactive&gt; passed 100 tests.
--   Monoid: Concatenation    ✓ &lt;interactive&gt; passed 100 tests.
--   True
--   </pre>
lawsCheck :: Laws -> IO Bool

-- | A convenience function for testing many typeclass instances of a
--   single type.
--   
--   <pre>
--   &gt;&gt;&gt; lawsCheckOne (word8 constantBounded) [jsonLaws, showReadLaws]
--   ToJSON/FromJSON: Partial Isomorphism    ✓ &lt;interactive&gt; passed 100 tests.
--   ToJSON/FromJSON: Encoding equals value    ✓ &lt;interactive&gt; passed 100 tests.
--   Show/Read: Partial Isomorphism: show/read    ✓ &lt;interactive&gt; passed 100 tests.
--   Show/Read: Partial Isomorphism: show/read with initial space    ✓ &lt;interactive&gt; passed 100 tests.
--   Show/Read: Partial Isomorphism: showsPrec/readsPrec    ✓ &lt;interactive&gt; passed 100 tests.
--   Show/Read: Partial Isomorphism: showList/readList    ✓ &lt;interactive&gt; passed 100 tests.
--   Show/Read: Partial Isomorphism: showListWith shows/readListDefault    ✓ &lt;interactive&gt; passed 100 tests.
--   True
--   </pre>
lawsCheckOne :: Gen a -> [Gen a -> Laws] -> IO Bool

-- | A convenience function for checking many typeclass instances of
--   multiple types.
--   
--   <pre>
--   import Control.Applicative (liftA2)
--   
--   import Data.Map (Map)
--   import Data.Set (Set)
--   
--   import qualified Data.List as List
--   import qualified Data.Set as Set
--   import qualified Data.Map as Map
--   
--   import qualified Hedgehog.Gen as Gen
--   import qualified Hedgehog.Range as Range
--   
--   import Hedgehog (Gen)
--   import Hedgehog.Classes
--   
--   -- Generate a small <tt>Set Int</tt>
--   genSet :: Gen (Set Int)
--   genSet = Set.fromList &lt;$&gt; (Gen.list (Range.linear 2 10) (Gen.int Range.constantBounded))
--   
--   -- Generate a small <tt>Map String Int</tt>
--   genMap :: Gen (Map String Int)
--   genMap = Map.fromList &lt;$&gt; (liftA2 List.zip genStrings genInts)
--     where
--       rng = Range.linear 2 6
--       genStrings = Gen.list rng (Gen.string rng Gen.lower)
--       genInts = Gen.list rng (Gen.int Range.constantBounded)
--   
--   commonLaws :: (Eq a, Monoid a, Show a) =&gt; Gen a -&gt; [Laws]
--   commonLaws p = [eqLaws p, monoidLaws p]
--   
--   tests :: [(String, [Laws])]
--   tests =
--     [ ("Set Int", commonLaws genSet)
--     , ("Map String Int", commonLaws genMap)
--     ]
--   </pre>
--   
--   Now, in GHCi:
--   
--   <pre>
--   &gt;&gt;&gt; lawsCheckMany tests
--   </pre>
--   
--   <pre>
--   Testing properties for common typeclasses...
--   
--   -------------
--   -- Set Int --
--   -------------
--   
--   Eq: Transitive   ✓ <a>interactive</a> passed 100 tests.
--   Eq: Symmetric   ✓ <a>interactive</a> passed 100 tests.
--   Eq: Reflexive   ✓ <a>interactive</a> passed 100 tests.
--   Eq: Negation   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Left Identity   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Right Identity   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Associativity   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Concatenation   ✓ <a>interactive</a> passed 100 tests.
--   
--   --------------------
--   -- Map String Int --
--   --------------------
--   
--   Eq: Transitive   ✓ <a>interactive</a> passed 100 tests.
--   Eq: Symmetric   ✓ <a>interactive</a> passed 100 tests.
--   Eq: Reflexive   ✓ <a>interactive</a> passed 100 tests.
--   Eq: Negation   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Left Identity   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Right Identity   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Associativity   ✓ <a>interactive</a> passed 100 tests.
--   Monoid: Concatenation   ✓ <a>interactive</a> passed 100 tests.
--   
--   All tests succeeded
--   True
--   </pre>
lawsCheckMany :: [(String, [Laws])] -> IO Bool

-- | Tests the following <a>Binary</a> laws:
--   
--   <ul>
--   <li><i><b>Encoding Partial Isomorphism</b></i> <tt><a>decode</a>
--   <a>.</a> <a>encode</a></tt> ≡ <tt><a>id</a></tt></li>
--   </ul>
binaryLaws :: (Binary a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Bits</a> laws:
--   
--   <ul>
--   <li><i><b>Conjunction Idempotence</b></i> <tt>n <a>.&amp;.</a> n</tt>
--   ≡ <tt>n</tt></li>
--   <li><i><b>Disjunction Idempotence</b></i> <tt>n <a>.|.</a> n</tt> ≡
--   <tt>n</tt></li>
--   <li><i><b>Double Complement</b></i> <tt><a>complement</a> <a>.</a>
--   <a>complement</a></tt> ≡ <tt>id</tt></li>
--   <li><i><b>Set Bit</b></i> <tt><a>setBit</a> n i ≡ n <a>.|.</a>
--   <a>bit</a> i</tt></li>
--   <li><i><b>Clear Bit</b></i> <tt><a>clearBit</a> n i</tt> ≡ <tt>n
--   <a>.&amp;.</a> <a>complement</a> (<a>bit</a> i)</tt></li>
--   <li><i><b>Complement Bit</b></i> <tt><a>complement</a> n i</tt> ≡
--   <tt><a>xor</a> n (<a>bit</a> i)</tt></li>
--   <li><i><b>Clear Zero</b></i> <tt><a>clearBit</a> <a>zeroBits</a>
--   i</tt> ≡ <tt><a>zeroBits</a></tt></li>
--   <li><i><b>Set Zero</b></i> <tt><a>setBit</a> <a>zeroBits</a> i</tt> ≡
--   <tt><a>zeroBits</a></tt></li>
--   <li><i><b>Test Zero</b></i> <tt><a>testBit</a> <a>zeroBits</a> i</tt>
--   ≡ <tt><a>False</a></tt></li>
--   <li><i><b>Pop Zero</b></i> <tt><a>popCount</a> <a>zeroBits</a></tt> ≡
--   <tt>0</tt></li>
--   <li><i><b>Count Leading Zeros of Zero</b></i>
--   <tt><a>countLeadingZeros</a> <a>zeroBits</a></tt> ≡
--   <tt><a>finiteBitSize</a> (<a>undefined</a> :: a)</tt></li>
--   <li><i><b>Count Trailing Zeros of Zero</b></i>
--   <tt><a>countTrailingZeros</a> <a>zeroBits</a></tt> ≡
--   <tt><a>finiteBitSize</a> (<a>undefined</a> :: a)</tt></li>
--   </ul>
bitsLaws :: (FiniteBits a, Show a) => Gen a -> Laws

-- | Tests the following <a>Eq</a> laws:
--   
--   <ul>
--   <li><i><b>Reflexivity</b></i> <tt>x <a>==</a> x</tt> ≡
--   <tt><a>True</a></tt></li>
--   <li><i><b>Symmetry</b></i> <tt>x <a>==</a> y</tt> ≡ <tt>y <a>==</a>
--   x</tt></li>
--   <li><i><b>Transitivity</b></i> <tt>x <a>==</a> y <a>&amp;&amp;</a> y
--   <a>==</a> z</tt> ≡ <tt>x <a>==</a> z</tt></li>
--   <li><i><b>Negation</b></i> <tt>x <a>/=</a> y</tt> ≡ <tt><a>not</a> (x
--   <a>==</a> y)</tt></li>
--   </ul>
eqLaws :: (Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Integral</a> laws:
--   
--   <ul>
--   <li><i><b>Quotient Remainder</b></i> <tt><a>quot</a> x y <a>*</a> y
--   <a>+</a> (<a>rem</a> x y)</tt> ≡ <tt>x</tt></li>
--   <li><i><b>Division Modulus</b></i> <tt>(<a>div</a> x y) <a>*</a> y
--   <a>+</a> (<a>mod</a> x y)</tt> ≡ <tt>x</tt></li>
--   <li><i><b>Integer Roundtrip</b></i> <tt><a>fromInteger</a> <a>.</a>
--   <a>toInteger</a></tt> ≡ <tt><a>id</a></tt></li>
--   </ul>
integralLaws :: (Integral a, Show a) => Gen a -> Laws

-- | Tests the following <a>Monoid</a> laws:
--   
--   <ul>
--   <li><i><b>Left Identity</b></i> <tt><a>mappend</a> <a>mempty</a></tt>
--   ≡ <tt><a>id</a></tt></li>
--   <li><i><b>Right Identity</b></i> <tt><a>flip</a> <a>mappend</a>
--   <a>mempty</a></tt> ≡ <tt><a>id</a></tt></li>
--   <li><i><b>Associativity</b></i> <tt><a>mappend</a> a (<a>mappend</a> b
--   c)</tt> ≡ <tt><a>mappend</a> (<a>mappend</a> a b) c</tt></li>
--   <li><i><b>Concatenation</b></i> <tt><a>mconcat</a></tt> ≡
--   <tt><a>foldr</a> <a>mappend</a> <a>mempty</a></tt></li>
--   </ul>
monoidLaws :: (Eq a, Monoid a, Show a) => Gen a -> Laws

-- | Tests the following <a>Monoid</a> laws:
--   
--   <ul>
--   <li><i><b>Commutativity</b></i> <tt><a>mappend</a> a b</tt> ≡
--   <tt><a>mappend</a> b a</tt></li>
--   </ul>
commutativeMonoidLaws :: (Eq a, Monoid a, Show a) => Gen a -> Laws

-- | Tests the following <a>Ord</a> laws:
--   
--   <ul>
--   <li><i><b>Antisymmetry</b></i> <tt>x <a>&lt;=</a> y <a>&amp;&amp;</a>
--   y <a>&lt;=</a> x</tt> ≡ <tt>x <a>==</a> y</tt></li>
--   <li><i><b>Transitivity</b></i> <tt>x <a>&lt;=</a> y <a>&amp;&amp;</a>
--   y <a>&lt;=</a> z</tt> ≡ <tt>x <a>&lt;=</a> z</tt></li>
--   <li><i><b>Reflexivity</b></i> <tt>x <a>&lt;=</a> x</tt> ≡
--   <tt><a>True</a></tt></li>
--   <li><i><b>Totality</b></i> <tt>x <a>&lt;=</a> y <a>||</a> y
--   <a>&lt;=</a> x</tt> ≡ <tt><a>True</a></tt></li>
--   </ul>
ordLaws :: (Ord a, Show a) => Gen a -> Laws

-- | Tests the following <a>Enum</a> laws:
--   
--   <ul>
--   <li><i><b>Succ-Pred Identity</b></i> <tt><a>succ</a> <a>.</a>
--   <a>pred</a></tt> ≡ <tt><a>id</a></tt></li>
--   <li><i><b>Pred-Succ Identity</b></i> <tt><a>pred</a> <a>.</a>
--   <a>succ</a></tt> ≡ <tt><a>id</a></tt></li>
--   </ul>
enumLaws :: (Enum a, Eq a, Show a) => Gen a -> Laws

-- | Tests the same laws as <a>enumLaws</a>, but uses the <a>Bounded</a>
--   constraint to ensure that <a>succ</a> and <a>pred</a> behave as though
--   they are total. This should always be preferred if your type has a
--   <a>Bounded</a> instance.
boundedEnumLaws :: (Bounded a, Enum a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Semigroup</a> laws:
--   
--   <ul>
--   <li><i><b>Associativity</b></i> <tt>a <a>&lt;&gt;</a> (b
--   <a>&lt;&gt;</a> c)</tt> ≡ <tt>(a <a>&lt;&gt;</a> b) <a>&lt;&gt;</a>
--   c</tt></li>
--   <li><i><b>Concatenation</b></i> <tt><a>sconcat</a></tt> ≡
--   <tt><a>foldr1</a> (<a>&lt;&gt;</a>)</tt></li>
--   <li><i><b>Times</b></i> <tt><a>stimes</a> n a</tt> ≡ <tt><a>foldr1</a>
--   (<a>&lt;&gt;</a>) (<a>replicate</a> n a)</tt></li>
--   </ul>
semigroupLaws :: (Eq a, Semigroup a, Show a) => Gen a -> Laws

-- | Tests the following <a>Semigroup</a> laws:
--   
--   <ul>
--   <li><i><b>Commutativity</b></i> <tt>a <a>&lt;&gt;</a> b</tt> ≡ <tt>b
--   <a>&lt;&gt;</a> a</tt></li>
--   </ul>
commutativeSemigroupLaws :: (Eq a, Semigroup a, Show a) => Gen a -> Laws

-- | Tests the following <a>Semigroup</a> laws:
--   
--   <ul>
--   <li><i><b>Exponentiality</b></i> <tt><a>stimes</a> n (a
--   <a>&lt;&gt;</a> b)</tt> ≡ <tt><a>stimes</a> n a <a>&lt;&gt;</a>
--   <a>stimes</a> n b</tt></li>
--   </ul>
exponentialSemigroupLaws :: (Eq a, Semigroup a, Show a) => Gen a -> Laws

-- | Tests the following <a>Semigroup</a> laws:
--   
--   <ul>
--   <li><i><b>Idempotency</b></i> <tt>a <a>&lt;&gt;</a> a</tt> ≡
--   <tt>a</tt></li>
--   </ul>
idempotentSemigroupLaws :: (Eq a, Semigroup a, Show a) => Gen a -> Laws

-- | Tests the following <a>Semigroup</a> laws:
--   
--   <ul>
--   <li><i><b>Rectangular Bandedness</b></i> <tt>a <a>&lt;&gt;</a> b
--   <a>&lt;&gt;</a> a</tt> ≡ <tt>a</tt></li>
--   </ul>
rectangularBandSemigroupLaws :: (Eq a, Semigroup a, Show a) => Gen a -> Laws

-- | Tests the following <a>ToJSON</a> / <a>FromJSON</a> laws:
--   
--   <ul>
--   <li><i><b>Encoding Partial Isomorphism</b></i> <tt><a>decode</a>
--   <a>.</a> <a>encode</a></tt> ≡ <tt><a>Just</a></tt></li>
--   <li><i><b>Encoding Equals Value</b></i> <tt><a>decode</a> <a>.</a>
--   <a>encode</a></tt> ≡ <tt><a>Just</a> <a>.</a> <a>toJSON</a></tt></li>
--   </ul>
jsonLaws :: (FromJSON a, ToJSON a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Generic</a> laws:
--   
--   <ul>
--   <li><i><b>From-To Inverse</b></i> <tt><a>from</a> <a>.</a>
--   <a>to</a></tt> ≡ <tt><a>id</a></tt></li>
--   <li><i><b>To-From Inverse</b></i> <tt><a>to</a> <a>.</a>
--   <a>from</a></tt> ≡ <tt><a>id</a></tt></li>
--   </ul>
genericLaws :: (Generic a, Eq a, Show a, Eq (Rep a x), Show (Rep a x)) => Gen a -> Gen (Rep a x) -> Laws

-- | Tests the following <a>Prim</a> laws:
--   
--   <ul>
--   <li><i><b>ByteArray Set-Get</b></i> <tt><a>primitive_</a>
--   (<a>writeByteArray#</a> ba# ix# x) <a>*&gt;</a> <a>primitive</a>
--   (<a>readByteArray#</a> ba# ix#)</tt> ≡ <tt><a>pure</a> x</tt></li>
--   <li><i><b>ByteArray Get-Set</b></i> <tt><a>primitive</a>
--   (<a>readByteArray#</a> ba# ix#) <a>&gt;&gt;=</a> x -&gt;
--   <a>primitive_</a> (<a>writeByteArray#</a> ba# ix# x)</tt> ≡
--   <tt><a>pure</a> ()</tt></li>
--   <li><i><b>ByteArray Set-Set</b></i> <tt><a>primitive_</a>
--   (<a>writeByteArray#</a> ba# ix# x) *&gt; <a>primitive_</a>
--   (<a>writeByteArray#</a> ba# ix# x)</tt> ≡ <tt><a>primitive_</a>
--   (<a>writeByteArray#</a> ba# ix# x)</tt></li>
--   <li><i><b>ByteArray Set Range</b></i> The behavior of
--   <a>setByteArray#</a> matches the default implementation</li>
--   <li><i><b>ByteArray List Conversion Roundtrips</b></i> Turning a list
--   into a <a>PrimArray</a> and back gives you the same list</li>
--   <li><i><b>Addr Set-Get</b></i> <tt><a>primitive_</a>
--   (<a>writeOffAddr#</a> addr# ix# x) <a>*&gt;</a> <a>primitive</a>
--   (<a>readOffAddr#</a> addr# ix#)</tt> ≡ <tt><a>pure</a> x</tt></li>
--   <li><i><b>Addr Get-Set</b></i> <tt><a>primitive</a>
--   (<a>readOffAddr#</a> addr# ix#) <a>&gt;&gt;=</a> x -&gt;
--   <a>primitive_</a> (<a>writeOffAddr#</a> addr# ix# x)</tt> ≡
--   <tt><a>pure</a> ()</tt></li>
--   <li><i><b>Addr Set-Set</b></i> <tt><a>primitive_</a>
--   (<a>writeOffAddr#</a> addr# ix# x) <a>*&gt;</a> <a>primitive_</a>
--   (<a>writeOffAddr#</a> addr# ix# x)</tt> ≡ <tt><a>primitive_</a>
--   (<a>writeOffAddr#</a> addr# ix# x)</tt></li>
--   <li><i><b>Addr Set Range</b></i> The behavior of <a>setOffAddr#</a>
--   matches the default implementation</li>
--   <li><i><b>Addr List Conversion Roundtrips</b></i> Mallocing a list and
--   then reconstructing it gives you the same list</li>
--   </ul>
primLaws :: (Prim a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Semiring</a> laws:
--   
--   <ul>
--   <li><i><b>Additive Left Identity</b></i> <tt><a>zero</a> <a>+</a>
--   x</tt> ≡ <tt>x</tt></li>
--   <li><i><b>Additive Right Identity</b></i> <tt>x <a>+</a>
--   <a>zero</a></tt> ≡ <tt>x</tt></li>
--   <li><i><b>Additive Associativity</b></i> <tt>x <a>+</a> (y <a>+</a>
--   z)</tt> ≡ <tt>(x <a>+</a> y) <a>+</a> z</tt></li>
--   <li><i><b>Additive Commutativity</b></i> <tt>x <a>+</a> y</tt> ≡ <tt>y
--   <a>+</a> x</tt></li>
--   <li><i><b>Multiplicative Left Identity</b></i> <tt><a>one</a> <a>*</a>
--   x</tt> ≡ <tt>x</tt></li>
--   <li><i><b>Multiplicative Right Identity</b></i> <tt>x <a>*</a>
--   <a>one</a></tt> ≡ <tt>x</tt></li>
--   <li><i><b>Multiplicative Associativity</b></i> <tt>x <a>*</a> (y
--   <a>*</a> z)</tt> ≡ <tt>(x <a>*</a> y) <a>*</a> z</tt></li>
--   <li><i><b>Multiplicatiion Left-Distributes Over Addtion</b></i> <tt>x
--   <a>*</a> (y <a>+</a> z)</tt> ≡ <tt>(x <a>*</a> y) <a>+</a> (x <a>*</a>
--   z)</tt></li>
--   <li><i><b>Multiplication Right-Distibutes Over Addition</b></i> <tt>(y
--   <a>+</a> z) <a>*</a> x</tt> ≡ <tt>(y <a>*</a> x) <a>+</a> (z <a>*</a>
--   x)</tt></li>
--   <li><i><b>Multiplicative Left Annihilation</b></i> <tt><a>zero</a>
--   <a>*</a> x</tt> ≡ <tt><a>zero</a></tt></li>
--   <li><i><b>Multiplicative Right Annihilation</b></i> <tt>x <a>*</a>
--   <a>zero</a></tt> ≡ <tt><a>zero</a></tt></li>
--   </ul>
semiringLaws :: (Semiring a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Ring</a> laws:
--   
--   <ul>
--   <li><i><b>Additive Inverse</b></i> <tt><a>negate</a> x <a>+</a> x</tt>
--   ≡ <tt><a>zero</a></tt></li>
--   </ul>
ringLaws :: (Ring a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Star</a> laws:
--   
--   <ul>
--   <li><i><b>Asteration</b></i> <tt><a>star</a> x</tt> ≡ <tt><a>one</a>
--   <a>+</a> x <a>*</a> <a>star</a> x</tt></li>
--   <li><i><b>APlus</b></i> <tt><a>aplus</a> x</tt> ≡ <tt>x <a>*</a>
--   <a>star</a> x</tt></li>
--   </ul>
starLaws :: (Star a, Eq a, Show a) => Gen a -> Laws

-- | Tests the following <a>Show</a> laws:
--   
--   <ul>
--   <li><i><b>ShowsPrec Zero</b></i> <tt><a>show</a> a</tt> ≡
--   <tt><a>showsPrec</a> 0 a ""</tt></li>
--   <li><i><b>ShowsPrec Equivariance</b></i> <tt><a>showsPrec</a> p a r
--   <a>++</a> s</tt> ≡ <tt>'showsPrec p a (r <a>++</a> s)</tt></li>
--   <li><i><b>ShowsPrec ShowList</b></i> <tt><a>showList</a> as r
--   <a>++</a> s</tt> ≡ <tt><a>showList</a> as (r <a>++</a> s)</tt></li>
--   </ul>
showLaws :: Show a => Gen a -> Laws

-- | Tests the following <a>Show</a> / <a>Read</a> laws:
--   
--   <ul>
--   <li><i><b>Partial Isomorphism: show/read</b></i> <tt><a>readMaybe</a>
--   <a>.</a> <a>show</a></tt> ≡ <tt><a>Just</a></tt></li>
--   <li><i><b>Partial Isomorphism: show/read with initial space</b></i>
--   <tt><a>readMaybe</a> <a>.</a> (" " <a>++</a>) <a>.</a>
--   <a>show</a></tt> ≡ <tt><a>Just</a></tt></li>
--   <li><i><b>Partial Isomorphism: showsPrec/readPrec</b></i> <tt>(a,"")
--   <a>elem</a> <a>readsPrec</a> p (<a>showsPrec</a> p a "")</tt> ≡
--   <tt><a>True</a></tt></li>
--   <li><i><b>Partial Isomorphism: showList/readList</b></i> <tt>(as,"")
--   <a>elem</a> <a>readList</a> (<a>showList</a> as "")</tt> ≡
--   <tt><a>True</a></tt></li>
--   <li><i><b>Partial Isomorphism: showListWith
--   shows/readListDefault</b></i> <tt>(as,"") <a>elem</a>
--   <a>readListDefault</a> (<a>showListWith</a> <a>shows</a> as "")</tt> ≡
--   <tt><a>True</a></tt></li>
--   </ul>
showReadLaws :: (Eq a, Read a, Show a) => Gen a -> Laws

-- | Tests the following <a>Storable</a> laws:
--   
--   <ul>
--   <li><i><b>Set-Get</b></i> <tt><a>pokeElemOff</a> ptr ix a
--   <a>&gt;&gt;</a> <a>peekElemOff</a> ptr ix</tt> ≡ <tt><a>pure</a>
--   a</tt></li>
--   <li><i><b>Get-Set</b></i> <tt><a>peekElemOff</a> ptr ix
--   <a>&gt;&gt;=</a> <a>pokeElemOff</a> ptr ix</tt> ≡ <tt><a>pure</a>
--   ()</tt> (Putting back what you got out has no effect)</li>
--   <li><i><b>List Conversion Roundtrips</b></i> Mallocing a list and then
--   reconstructing it gives you the same list</li>
--   <li><i><b>PeekElemOff/Peek</b></i> <tt><a>peekElemOff</a> a i</tt> ≡
--   <tt><a>peek</a> (<a>plusPtr</a> a (i <a>*</a> <a>sizeOf</a>
--   <a>undefined</a>))</tt></li>
--   <li><i><b>PokeElemOff/Poke</b></i> <tt><a>pokeElemOff</a> a i x</tt> ≡
--   <tt><a>poke</a> (<a>plusPtr</a> a (i <a>*</a> <a>sizeOf</a>
--   <a>undefined</a>)) x</tt></li>
--   <li><i><b>PeekByteOff/Peek</b></i> <tt><a>peekByteOff</a> a i</tt> ≡
--   <tt><a>peek</a> (<a>plusPtr</a> a i)</tt></li>
--   <li><i><b>PokeByteOff/Peek</b></i> <tt><a>pokeByteOff</a> a i x</tt> ≡
--   <tt><a>poke</a> (<a>plusPtr</a> a i) x</tt></li>
--   </ul>
storableLaws :: (Eq a, Show a, Storable a) => Gen a -> Laws

-- | Test that a <a>MVector</a> instance obey several laws.
muvectorLaws :: (Eq a, Unbox a, Show a) => Gen a -> Laws

-- | Tests the following <a>Alternative</a> laws:
--   
--   <ul>
--   <li><i><b>Left Identity</b></i> <tt><a>empty</a> <a>&lt;|&gt;</a>
--   a</tt> ≡ <tt>a</tt></li>
--   <li><i><b>Right Identity</b></i> <tt>a <a>&lt;|&gt;</a>
--   <a>empty</a></tt> ≡ <tt>a</tt></li>
--   <li><i><b>Associativity</b></i> <tt>a <a>&lt;|&gt;</a> (b
--   <a>&lt;|&gt;</a> c)</tt> ≡ <tt>(a <a>&lt;|&gt;</a> b) <a>&lt;|&gt;</a>
--   c</tt></li>
--   </ul>
alternativeLaws :: (Alternative f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Applicative</a> laws:
--   
--   <ul>
--   <li><i><b>Identity</b></i> <tt><a>pure</a> <a>id</a> <a>&lt;*&gt;</a>
--   v</tt> ≡ <tt>v</tt></li>
--   <li><i><b>Composition</b></i> <tt><a>pure</a> (<a>.</a>)
--   <a>&lt;*&gt;</a> u <a>&lt;*&gt;</a> v <a>&lt;*&gt;</a> w</tt> ≡ <tt>u
--   <a>&lt;*&gt;</a> (v <a>&lt;*&gt;</a> w)</tt></li>
--   <li><i><b>Homomorphism</b></i> <tt><a>pure</a> f <a>&lt;*&gt;</a>
--   <a>pure</a></tt> x ≡ <tt><a>pure</a> (f x)</tt></li>
--   <li><i><b>Interchange</b></i> <tt>u <a>&lt;*&gt;</a> <a>pure</a>
--   y</tt> ≡ <tt><a>pure</a> (<a>$</a> y) <a>&lt;*&gt;</a> u</tt></li>
--   <li><i><b>LiftA2 1</b></i> <tt><a>liftA2</a> <a>id</a> f x</tt> ≡
--   <tt>f <a>&lt;*&gt;</a> x</tt></li>
--   <li><i><b>LiftA2 2</b></i> <tt><a>liftA2</a> f x y</tt> ≡ <tt>f
--   <a>&lt;$&gt;</a> x <a>&lt;*&gt;</a> y</tt></li>
--   </ul>
applicativeLaws :: (Applicative f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Comonad</a> laws:
--   
--   <ul>
--   <li><i><b>Extend/Extract Identity</b></i> <tt><a>extend</a>
--   <a>extract</a> ≡ <a>id</a></tt></li>
--   <li><i><b>Extract/Extend</b></i> <tt><a>extract</a> <a>.</a>
--   <a>extend</a> f ≡ f</tt></li>
--   <li><i><b>Extend/Extend</b></i> <tt><a>extend</a> f <a>.</a>
--   <a>extend</a> g ≡ <a>extend</a> (f <a>.</a> <a>extend</a> g)</tt></li>
--   <li><i><b>Extract Right Identity</b></i> <tt>f <a>=&gt;=</a>
--   <a>extract</a> ≡ f</tt></li>
--   <li><i><b>Extract Left Identity</b></i> <tt><a>extract</a>
--   <a>=&gt;=</a> f ≡ f</tt></li>
--   <li><i><b>Cokleisli Associativity</b></i> <tt>(f <a>=&gt;=</a> g)
--   <a>=&gt;=</a> h ≡ f <a>=&gt;=</a> (g <a>=&gt;=</a> h)</tt></li>
--   <li><i><b>Extract/Duplicate Identity</b></i> <tt><a>extract</a>
--   <a>.</a> <a>duplicate</a> ≡ <a>id</a></tt></li>
--   <li><i><b>Fmap Extract/Duplicate Identity</b></i> <tt><a>fmap</a>
--   <a>extract</a> <a>.</a> <a>duplicate</a> ≡ <a>id</a></tt></li>
--   <li><i><b>Double Duplication</b></i> <tt><a>duplicate</a> <a>.</a>
--   <a>duplicate</a> ≡ <a>fmap</a> <a>duplicate</a> <a>.</a>
--   <a>duplicate</a></tt></li>
--   <li><i><b>Extend/Fmap . Duplicate Identity</b></i> <tt><a>extend</a> f
--   ≡ <a>fmap</a> f <a>.</a> <a>duplicate</a></tt></li>
--   <li><i><b>Duplicate/Extend id Identity</b></i> <tt><a>duplicate</a> ≡
--   <a>extend</a> <a>id</a></tt></li>
--   <li><i><b>Fmap/Extend Extract</b></i> <tt><a>fmap</a> f ≡
--   <a>extend</a> (f <a>.</a> <a>extract</a>)</tt></li>
--   <li><i><b>Fmap/LiftW Isomorphism</b></i> <tt><a>fmap</a> ≡
--   <a>liftW</a></tt></li>
--   </ul>
comonadLaws :: (Comonad f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Contravariant</a> laws:
--   
--   <ul>
--   <li><i><b>Identity</b></i> <tt><a>contramap</a> <a>id</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>Composition</b></i> <tt><a>contramap</a> f <a>.</a>
--   <a>contramap</a> g</tt> ≡ <tt><a>contramap</a> (g <a>.</a>
--   f)</tt></li>
--   </ul>
contravariantLaws :: (Contravariant f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Foldable</a> laws:
--   
--   <ul>
--   <li><i><b>Fold</b></i> <tt><a>fold</a> ≡ <a>foldMap</a>
--   <a>id</a></tt></li>
--   <li><i><b>FoldMap</b></i> <tt><a>foldMap</a> f ≡ <a>foldr</a>
--   (<a>mappend</a> <a>.</a> f) <a>mempty</a></tt></li>
--   <li><i><b>Foldr</b></i> <tt><a>foldr</a> f z t ≡ <a>appEndo</a>
--   (<a>foldMap</a> (<a>Endo</a> <a>.</a> f) t) z</tt></li>
--   <li><i><b>Foldr'</b></i> <tt><a>foldr'</a> f z0 t ≡ <a>foldl</a> f'
--   <a>id</a> t z0, where f' k x z = k <a>$!</a> f x z</tt></li>
--   <li><i><b>Foldl</b></i> <tt><a>foldl</a> f z t ≡ <a>appEndo</a>
--   (<a>getDual</a> (<a>foldMap</a> (<a>Dual</a> <a>.</a> <a>Endo</a>
--   <a>.</a> <a>flip</a> f) t)) z</tt></li>
--   <li><i><b>Foldl'</b></i> <tt><a>foldl'</a> f z0 xs ≡ <a>foldr</a> f'
--   <a>id</a> xs z0, where f' x k z = k <a>$!</a> f z x</tt></li>
--   <li><i><b>Foldl1</b></i> <tt><a>foldl1</a> f t ≡ let (x:xs) =
--   <a>toList</a> t in <a>foldl</a> f x xs</tt></li>
--   <li><i><b>Foldr1</b></i> <tt><a>foldr1</a> f t ≡ let (xs,x)</tt> =
--   <tt>unsnoc (<a>toList</a> t) in <a>foldr</a> f x xs</tt></li>
--   <li><i><b>ToList</b></i> <tt><a>toList</a> ≡ <a>foldr</a> (:)
--   []</tt></li>
--   <li><i><b>Null</b></i> <tt><a>null</a> ≡ <a>foldr</a> (<a>const</a>
--   (<a>const</a> <a>False</a>)) <a>True</a></tt></li>
--   <li><i><b>Length</b></i> <tt><a>length</a> ≡ <a>getSum</a> <a>.</a>
--   <a>foldMap</a> (<a>const</a> (<a>Sum</a> 1))</tt></li>
--   </ul>
--   
--   This additionally tests that the user's implementations of
--   <a>foldr'</a> and <a>foldl'</a> are strict in their accumulators.
foldableLaws :: (Foldable f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Functor</a> laws:
--   
--   <ul>
--   <li><i><b>Identity</b></i> <tt><a>fmap</a> <a>id</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>Composition</b></i> <tt><a>fmap</a> f <a>.</a> <a>fmap</a>
--   g</tt> ≡ <tt><a>fmap</a> (f <a>.</a> g)</tt></li>
--   <li><i><b>Const</b></i> <tt><a>fmap</a> (<a>const</a> x)</tt> ≡ <tt>x
--   <a>&lt;$</a></tt></li>
--   </ul>
functorLaws :: (Functor f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Monad</a> laws:
--   
--   <ul>
--   <li><i><b>Left Identity</b></i> <tt><a>return</a> a <a>&gt;&gt;=</a>
--   k</tt> ≡ <tt>k a</tt></li>
--   <li><i><b>Right Identity</b></i> <tt>m <a>&gt;&gt;=</a>
--   <a>return</a></tt> ≡ <tt>m</tt></li>
--   <li><i><b>Associativity</b></i> <tt>m <a>&gt;&gt;=</a> (\x -&gt; k x
--   <a>&gt;&gt;=</a> h)</tt> ≡ <tt>(m <a>&gt;&gt;=</a> k) <a>&gt;&gt;=</a>
--   h</tt></li>
--   <li><i><b>Return</b></i> <tt><a>return</a></tt> ≡
--   <tt><a>pure</a></tt></li>
--   <li><i><b>Ap</b></i> <tt><a>ap</a> f x</tt> ≡ <tt>f <a>&lt;*&gt;</a>
--   x</tt></li>
--   </ul>
monadLaws :: (Monad f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>MonadIO</a> laws:
--   
--   <ul>
--   <li><i><b>Return</b></i> <tt><a>liftIO</a> <a>.</a> <a>return</a></tt>
--   ≡ <tt><a>return</a></tt></li>
--   <li><i><b>Lift</b></i> <tt><a>liftIO</a> (m <a>&gt;&gt;=</a> f)</tt> ≡
--   <tt><a>liftIO</a> m <a>&gt;&gt;=</a> (<a>liftIO</a> <a>.</a>
--   f)</tt></li>
--   </ul>
monadIOLaws :: (MonadIO f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>MonadPlus</a> laws:
--   
--   <ul>
--   <li><i><b>Left Identity</b></i> <tt><a>mplus</a> <a>mzero</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>Right Identity</b></i> <tt><a>flip</a> <a>mplus</a>
--   <a>mzero</a></tt> ≡ <tt><a>id</a></tt></li>
--   <li><i><b>Associativity</b></i> <tt><a>mplus</a> a (<a>mplus</a> b
--   c)</tt> ≡ <tt><a>mplus</a> (<a>mplus</a> a b) c</tt></li>
--   <li><i><b>Left Zero</b></i> <tt><a>mzero</a> <a>&gt;&gt;=</a> f</tt> ≡
--   <tt><a>mzero</a></tt></li>
--   <li><i><b>Right Zero</b></i> <tt>v <a>&gt;&gt;</a> <a>mzero</a></tt> ≡
--   <tt><a>mzero</a></tt></li>
--   </ul>
monadPlusLaws :: (MonadPlus f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>MonadZip</a> laws:
--   
--   <ul>
--   <li><i><b>Naturality</b></i> <tt><a>fmap</a> (f <a>***</a> g)
--   (<a>mzip</a> ma mb)</tt> ≡ <tt><a>mzip</a> (<a>fmap</a> f ma)
--   (<a>fmap</a> g mb)</tt></li>
--   </ul>
monadZipLaws :: (MonadZip f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Traversable</a> laws:
--   
--   <ul>
--   <li><i><b>Naturality</b></i> <tt>t <a>.</a> <a>traverse</a> f</tt> ≡
--   <tt><a>traverse</a> (t <a>.</a> f), for every applicative
--   transformation t</tt></li>
--   <li><i><b>Identity</b></i> <tt><a>traverse</a> <a>Identity</a></tt> ≡
--   <tt><a>Identity</a></tt></li>
--   <li><i><b>Composition</b></i> <tt><a>traverse</a> (<a>Compose</a>
--   <a>.</a> <a>fmap</a> g <a>.</a> f)</tt> ≡ <tt><a>Compose</a> <a>.</a>
--   <a>fmap</a> (<a>traverse</a> g) <a>.</a> <a>traverse</a> f</tt></li>
--   <li><i><b>SequenceA Naturality</b></i> <tt>t <a>.</a>
--   <a>sequenceA</a></tt> ≡ <tt><a>sequenceA</a> <a>.</a> <a>fmap</a> t,
--   for every applicative transformation t</tt></li>
--   <li><i><b>SequenceA Identity</b></i> <tt><a>sequenceA</a> <a>.</a>
--   <a>fmap</a> <a>Identity</a></tt> ≡ <tt><a>Identity</a></tt></li>
--   <li><i><b>SequenceA Composition</b></i> <tt><a>sequenceA</a> <a>.</a>
--   <a>fmap</a> <a>Compose</a></tt> ≡ <tt><a>Compose</a> <a>.</a>
--   <a>fmap</a> <a>sequenceA</a> <a>.</a> <a>sequenceA</a></tt></li>
--   <li><i><b>FoldMap</b></i> <tt><a>foldMap</a></tt> ≡
--   <tt><a>foldMapDefault</a></tt></li>
--   <li><i><b>Fmap</b></i> <tt><a>fmap</a></tt> ≡
--   <tt><a>fmapDefault</a></tt></li>
--   </ul>
traversableLaws :: (Traversable f, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => (forall x. () => Gen x -> Gen (f x)) -> Laws

-- | Tests the following <a>Arrow</a> laws:
--   
--   <ul>
--   <li><i><b>Arr Identity</b></i> <tt><a>arr</a> <a>id</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>Arr Composition</b></i> <tt><a>arr</a> (f
--   <a>&gt;&gt;&gt;</a> g)</tt> ≡ <tt><a>arr</a> f <a>&gt;&gt;&gt;</a>
--   <a>arr</a> g</tt></li>
--   <li><i><b>Arr-First inverse</b></i> <tt><a>first</a> (<a>arr</a>
--   f)</tt> ≡ <tt><a>arr</a> (<a>first</a> f)</tt></li>
--   <li><i><b>First Composition</b></i> <tt><a>first</a> (f
--   <a>&gt;&gt;&gt;</a> g)</tt> ≡ <tt><a>first</a> f <a>&gt;&gt;&gt;</a>
--   <a>first</a> g</tt></li>
--   <li><i><b>Arrow Law 5</b></i> <tt><a>first</a> f <a>&gt;&gt;&gt;</a>
--   <a>arr</a> <a>fst</a></tt> ≡ <tt><a>arr</a> <a>fst</a>
--   <a>&gt;&gt;&gt;</a> f</tt></li>
--   <li><i><b>Arrow Law 6</b></i> <tt><a>first</a> f <a>&gt;&gt;&gt;</a>
--   <a>arr</a> (<a>id</a> <a>***</a> g)</tt> ≡ <tt><a>arr</a> (<a>id</a>
--   <a>***</a> g) <a>&gt;&gt;&gt;</a> <a>first</a> f</tt></li>
--   <li><i><b>Arrow Law 7</b></i> <tt><a>first</a> (<a>first</a> f)
--   <a>&gt;&gt;&gt;</a> <a>arr</a> assoc</tt> ≡ <tt><a>arr</a> assoc
--   <a>&gt;&gt;&gt;</a> <a>first</a> f, where assoc ((a,b),c) =
--   (a,(b,c))</tt></li>
--   </ul>
arrowLaws :: (Arrow f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | Tests the following <a>Bifoldable</a> laws:
--   
--   <ul>
--   <li><i><b>Identity</b></i> <tt><a>bifold</a></tt> ≡
--   <tt><a>bifoldMap</a> <a>id</a> <a>id</a></tt></li>
--   <li><i><b>FoldMap</b></i> <tt><a>bifoldMap</a> f g</tt> ≡
--   <tt><a>bifoldr</a> (<a>mappend</a> <a>.</a> f) (<a>mappend</a>
--   <a>.</a> g) <a>mempty</a></tt></li>
--   <li><i><b>Foldr</b></i> <tt><a>bifoldr</a> f g z t</tt> ≡
--   <tt><a>appEndo</a> (<a>bifoldMap</a> (<a>Endo</a> <a>.</a> f)
--   (<a>Endo</a> <a>.</a> g) t) z</tt></li>
--   </ul>
bifoldableLaws :: (Bifoldable f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | Tests the following <a>Bifoldable</a> / <a>Bifunctor</a> laws:
--   
--   <ul>
--   <li><i><b>Composition</b></i> <tt><a>bifoldMap</a> f g</tt> ≡
--   <tt><a>bifold</a> <a>.</a> <a>bimap</a> f g</tt></li>
--   <li><i><b>FoldMap</b></i> <tt><a>bifoldMap</a> f g <a>.</a>
--   <a>bimap</a> h i</tt> ≡ <tt><a>bifoldMap</a> (f <a>.</a> h) (g
--   <a>.</a> i)</tt></li>
--   </ul>
bifoldableFunctorLaws :: (Bifoldable f, Bifunctor f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | Tests the following <a>Bifunctor</a> laws:
--   
--   <ul>
--   <li><i><b>Identity</b></i> <tt><a>bimap</a> <a>id</a> <a>id</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>First Identity</b></i> <tt><a>first</a> <a>id</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>Second Identity</b></i> <tt><a>second</a> <a>id</a></tt> ≡
--   <tt><a>id</a></tt></li>
--   <li><i><b>Composition</b></i> <tt><a>bimap</a> <a>id</a>
--   <a>id</a></tt> ≡ <tt><a>first</a> <a>id</a> <a>.</a> <a>second</a>
--   <a>id</a></tt></li>
--   </ul>
bifunctorLaws :: (Bifunctor f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | Tests the following <a>Bitraversable</a> laws:
--   
--   <ul>
--   <li><i><b>Naturality</b></i> <tt><a>bitraverse</a> (t <a>.</a> f) (t
--   <a>.</a> g)</tt> ≡ <tt>t <a>.</a> <a>bitraverse</a> f g, for every
--   applicative transformation t</tt></li>
--   <li><i><b>Identity</b></i> <tt><a>bitraverse</a> <a>Identity</a>
--   <a>Identity</a></tt> ≡ <tt><a>Identity</a></tt></li>
--   <li><i><b>Composition</b></i> <tt><a>Compose</a> <a>.</a> <a>fmap</a>
--   (<a>bitraverse</a> g1 g2) <a>.</a> <a>bitraverse</a> f1 f2</tt> ≡
--   <tt><a>bitraverse</a> (<a>Compose</a> <a>.</a> <a>fmap</a> g1 <a>.</a>
--   f1) (<a>Compose</a> <a>.</a> <a>fmap</a> g2 <a>.</a> f2)</tt></li>
--   </ul>
bitraversableLaws :: (Bitraversable f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | Tests the following <a>Category</a> laws:
--   
--   <ul>
--   <li><i><b>Left Identity</b></i> <tt><a>id</a> <a>.</a> f</tt> ≡
--   <tt>f</tt></li>
--   <li><i><b>Right Identity</b></i> <tt>f <a>.</a> <a>id</a></tt> ≡
--   <tt>f</tt></li>
--   <li><i><b>Associativity</b></i> <tt>f <a>.</a> (g <a>.</a> h)</tt> ≡
--   <tt>(f <a>.</a> g) <a>.</a> h</tt></li>
--   </ul>
categoryLaws :: (Category f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | Tests the following <a>Category</a> laws:
--   
--   <ul>
--   <li><i><b>Commutativity</b></i> <tt>f <a>.</a> g</tt> ≡ <tt>g <a>.</a>
--   f</tt></li>
--   </ul>
commutativeCategoryLaws :: (Category f, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => (forall x y. () => Gen x -> Gen y -> Gen (f x y)) -> Laws

-- | A <a>Laws</a> is the name of the typeclass and the set of named
--   properties associated with that typeclass.
data Laws
Laws :: String -> [(String, Property)] -> Laws
[lawsTypeClass] :: Laws -> String
[lawsProperties] :: Laws -> [(String, Property)]

-- | The context surrounding the property test of a law. Use
--   <a>contextualise</a> to turn this into a <a>Context</a>.
data LawContext
LawContext :: String -> String -> String -> String -> String -> LawContext

-- | law name
[lawContextLawName] :: LawContext -> String

-- | law body
[lawContextLawBody] :: LawContext -> String

-- | typeclass name
[lawContextTcName] :: LawContext -> String

-- | how to show the specific property test
[lawContextTcProp] :: LawContext -> String

-- | reduced equation, eg "LHS = RHS" where neither LHS nor RHS are
--   reducible
[lawContextReduced] :: LawContext -> String

-- | You can provide a <a>Context</a> to
--   <a>heqCtx</a>,<a>heqCtx1</a>,<a>heqCtx2</a>,<a>hneqCtx</a>,<a>hneqCtx1</a>,or
--   <a>hneqCtx2</a>. The <a>Context</a> is used to provide useful error
--   messages in the event of a failure.
data Context
NoContext :: Context
Context :: String -> Context

-- | Turn a <a>LawContext</a> into a <a>Context</a>.
contextualise :: LawContext -> Context

-- | Fails the test if the right argument is less than or equal to the
--   left. see
--   <a>https://github.com/hedgehogqa/haskell-hedgehog/pull/196</a>
hLessThan :: (MonadTest m, Ord a, Show a, HasCallStack) => a -> a -> m ()

-- | Fails the test if the right argument is greater than or equal to the
--   left. see
--   <a>https://github.com/hedgehogqa/haskell-hedgehog/pull/196</a>
hGreaterThan :: (MonadTest m, Ord a, Show a, HasCallStack) => a -> a -> m ()

-- | Passes the test if the given arguments are equal. Otherwise fails with
--   <a>NoContext</a>.
heq :: (MonadTest m, HasCallStack, Eq a, Show a) => a -> a -> m ()
infix 4 `heq`

-- | Passes the test if the given arguments are equal. Otherwise fails with
--   <a>NoContext</a>.
heq1 :: (MonadTest m, HasCallStack, Eq a, Show a, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => f a -> f a -> m ()
infix 4 `heq1`

-- | Passes the test if the given arguments are equal. Otherwise fails with
--   <a>NoContext</a>.
heq2 :: (MonadTest m, HasCallStack, Eq a, Eq b, Show a, Show b, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => f a b -> f a b -> m ()
infix 4 `heq2`

-- | Passes the test if the given arguments are equal. Otherwise fails with
--   the given <a>Context</a>.
heqCtx :: (MonadTest m, HasCallStack, Eq a, Show a) => a -> a -> Context -> m ()

-- | Passes the test if the given arguments are equal. Otherwise fails with
--   the given <a>Context</a>.
heqCtx1 :: (MonadTest m, HasCallStack, Eq a, Show a, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => f a -> f a -> Context -> m ()

-- | Passes the test if the given arguments are equal. Otherwise fails with
--   the given <a>Context</a>.
heqCtx2 :: (MonadTest m, HasCallStack, Eq a, Eq b, Show a, Show b, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => f a b -> f a b -> Context -> m ()

-- | Passes the test if the given arguments are not equal. Otherwise fails
--   with <a>NoContext</a>.
hneq :: (MonadTest m, HasCallStack, Eq a, Show a) => a -> a -> m ()
infix 4 `hneq`

-- | Passes the test if the given arguments are not equal. Otherwise fails
--   with <a>NoContext</a>.
hneq1 :: (MonadTest m, HasCallStack, Eq a, Show a, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => f a -> f a -> m ()

-- | Passes the test if the given arguments are not equal. Otherwise fails
--   with <a>NoContext</a>.
hneq2 :: (MonadTest m, HasCallStack, Eq a, Eq b, Show a, Show b, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => f a b -> f a b -> m ()
infix 4 `hneq2`

-- | Passes the test if the given arguments are not equal. Otherwise fails
--   with the given <a>Context</a>.
hneqCtx :: (MonadTest m, HasCallStack, Eq a, Show a) => a -> a -> Context -> m ()

-- | Passes the test if the given arguments are not equal. Otherwise fails
--   with the given <a>Context</a>.
hneqCtx1 :: (MonadTest m, HasCallStack, Eq a, Show a, forall x. Eq x => Eq (f x), forall x. Show x => Show (f x)) => f a -> f a -> Context -> m ()

-- | Passes the test if the given arguments are not equal. Otherwise fails
--   with the given <a>Context</a>.
hneqCtx2 :: (MonadTest m, HasCallStack, Eq a, Eq b, Show a, Show b, forall x y. (Eq x, Eq y) => Eq (f x y), forall x y. (Show x, Show y) => Show (f x y)) => f a b -> f a b -> Context -> m ()
