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


-- | QuickCheck common typeclasses
--   
--   This library provides QuickCheck 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 checkers. This library differs from
--   other solutions by not introducing any new typeclasses that the user
--   needs to learn.
--   
--   Note: on GHC < 8.5, this library uses the higher-kinded
--   typeclasses (Data.Functor.Classes.Show1,
--   Data.Functor.Classes.Eq1, Data.Functor.Classes.Ord1,
--   etc.), but on GHC >= 8.5, it uses `-XQuantifiedConstraints` to
--   express these constraints more cleanly.
@package quickcheck-classes
@version 0.6.5.0

module Test.QuickCheck.Classes.IsList

-- | This library provides sets of properties that should hold for common
--   typeclasses.
--   
--   Note: on GHC < 8.6, this library uses the higher-kinded
--   typeclasses (Show1, Eq1, Ord1, etc.), but on GHC
--   >= 8.6, it uses -XQuantifiedConstraints to express these
--   constraints more cleanly.
module Test.QuickCheck.Classes

-- | A convenience function for testing properties in GHCi. For example, at
--   GHCi:
--   
--   
--   >>> lawsCheck (monoidLaws (Proxy :: Proxy Ordering))
--   Monoid: Associative +++ OK, passed 100 tests.
--   Monoid: Left Identity +++ OK, passed 100 tests.
--   Monoid: Right Identity +++ OK, passed 100 tests.
--   
--   
--   Assuming that the Arbitrary instance for Ordering is
--   good, we now have confidence that the Monoid instance for
--   Ordering satisfies the monoid laws.
lawsCheck :: Laws -> IO ()

-- | A convenience function for checking multiple typeclass instances of
--   multiple types. Consider the following Haskell source file:
--   
--   
--   import Data.Proxy (Proxy(..))
--   import Data.Map (Map)
--   import Data.Set (Set)
--   
--   -- A Proxy for Set Int.
--   setInt :: Proxy (Set Int)
--   setInt = Proxy
--   
--   -- A Proxy for Map Int Int.
--   mapInt :: Proxy (Map Int Int)
--   mapInt = Proxy
--   
--   myLaws :: Proxy a -> [Laws]
--   myLaws p = [eqLaws p, monoidLaws p]
--   
--   namedTests :: [(String, [Laws])]
--   namedTests =
--     [ ("Set Int", myLaws setInt)
--     , ("Map Int Int", myLaws mapInt)
--     ]
--   
--   
--   Now, in GHCi:
--   
--   
--   >>> lawsCheckMany namedTests
--   
--   
--   
--   Testing properties for common typeclasses
--   -------------
--   -- Set Int --
--   -------------
--   
--   Eq: Transitive +++ OK, passed 100 tests.
--   Eq: Symmetric +++ OK, passed 100 tests.
--   Eq: Reflexive +++ OK, passed 100 tests.
--   Monoid: Associative +++ OK, passed 100 tests.
--   Monoid: Left Identity +++ OK, passed 100 tests.
--   Monoid: Right Identity +++ OK, passed 100 tests.
--   Monoid: Concatenation +++ OK, passed 100 tests.
--   
--   -----------------
--   -- Map Int Int --
--   -----------------
--   
--   Eq: Transitive +++ OK, passed 100 tests.
--   Eq: Symmetric +++ OK, passed 100 tests.
--   Eq: Reflexive +++ OK, passed 100 tests.
--   Monoid: Associative +++ OK, passed 100 tests.
--   Monoid: Left Identity +++ OK, passed 100 tests.
--   Monoid: Right Identity +++ OK, passed 100 tests.
--   Monoid: Concatenation +++ OK, passed 100 tests.
--   
--   
--   In the case of a failing test, the program terminates with exit code
--   1.
lawsCheckMany :: [(String, [Laws])] -> IO ()

-- | A convenience function that allows one to check many typeclass
--   instances of the same type.
--   
--   
--   >>> specialisedLawsCheckMany (Proxy :: Proxy Word) [jsonLaws, showReadLaws]
--   ToJSON/FromJSON: Encoding Equals Value +++ OK, passed 100 tests.
--   ToJSON/FromJSON: Partial Isomorphism +++ OK, passed 100 tests.
--   Show/Read: Partial Isomorphism +++ OK, passed 100 tests.
--   
lawsCheckOne :: Proxy a -> [Proxy a -> Laws] -> IO ()

-- | Tests the following properties:
--   
--   
--   
- Conjunction Idempotence n .&. n ≡
--   n
--   
- Disjunction Idempotence n .|. n ≡ n
--   
- Double Complement complement (complement n) ≡
--   n
--   
- Set Bit setBit n i ≡ n .|. bit i
--   
- Clear Bit clearBit n i ≡ n .&. complement
--   (bit i)
--   
- Complement Bit complementBit n i ≡ xor n (bit
--   i)
--   
- Clear Zero clearBit zeroBits i ≡
--   zeroBits
--   
- Set Zero setBit zeroBits i ≡ bit i
--   
- Test Zero testBit zeroBits i ≡ False
--   
- Pop Zero popCount zeroBits ≡ 0
--   
- Right Rotation no sign extension → (rotateR n i
--   ≡ (shiftR n i) .|. (shiftL n (finiteBitSize ⊥ - i)))
--   
- Left Rotation no sign extension → (rotateL n i ≡
--   (shiftL n i) .|. (shiftR n (finiteBitSize ⊥ - i)))
--   
- Count Leading Zeros of Zero countLeadingZeros
--   zeroBits ≡ finiteBitSize ⊥
--   
- Count Trailing Zeros of Zero countTrailingZeros
--   zeroBits ≡ finiteBitSize ⊥
--   
--   
--   All of the useful instances of the Bits typeclass also have
--   FiniteBits instances, so these property tests actually require
--   that instance as well.
--   
--   Note: This property test is only available when using
--   base-4.7 or newer.
bitsLaws :: (FiniteBits a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Transitive a == b ∧ b == c ⇒ a
--   == c
--   
- Symmetric a == b ⇒ b ==
--   a
--   
- Reflexive a == a
--   
- Negation x /= y == not (x
--   == y)
--   
--   
--   Some of these properties involve implication. In the case that the
--   left hand side of the implication arrow does not hold, we do not
--   retry. Consequently, these properties only end up being useful when
--   the data type has a small number of inhabitants.
eqLaws :: (Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Substitutive x == y ⇒ f x == f
--   y
--   
--   
--   Note: This does not test eqLaws. If you want to use
--   this, You should use it in addition to eqLaws.
substitutiveEqLaws :: (Eq a, Arbitrary a, CoArbitrary a, Function a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Additive Commutativity a + b ≡ b + a
--   
- Additive Left Identity 0 + a ≡ a
--   
- Additive Right Identity a + 0 ≡ a
--   
- Multiplicative Associativity a * (b * c) ≡ (a *
--   b) * c
--   
- Multiplicative Left Identity 1 * a ≡ a
--   
- Multiplicative Right Identity a * 1 ≡
--   a
--   
- Multiplication Left Distributes Over Addition a
--   * (b + c) ≡ (a * b) + (a * c)
--   
- Multiplication Right Distributes Over Addition
--   (a + b) * c ≡ (a * c) + (b * c)
--   
- Multiplicative Left Annihilation 0 * a ≡
--   0
--   
- Multiplicative Right Annihilation a * 0 ≡
--   0
--   
- Additive Inverse negate a + a ≡
--   0
--   
- Subtraction a + negate b ≡ a
--   - b
--   
- Abs Is Idempotent @abs (abs a) ≡
--   abs a
--   
- Signum Is Idempotent @signum (signum
--   a) ≡ signum a
--   
- Product Of Abs And Signum Is Id abs a *
--   signum a ≡ a
--   
numLaws :: (Num a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Quotient Remainder (quot x y) * y + (rem x y) ≡
--   x
--   
- Division Modulus (div x y) * y + (mod x y) ≡
--   x
--   
- Integer Roundtrip fromInteger (toInteger x) ≡
--   x
--   
- QuotRem is (Quot, Rem) quotRem x y ≡ (quot x y,
--   rem x y)
--   
- DivMod is (Div, Mod) divMod x y ≡ (div x y, mod
--   x y)
--   
integralLaws :: (Integral a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the various Ix properties:
--   
--   
--   inRange (l,u) i == elem i (range (l,u))
--   
--   
--   range (l,u) !! index (l,u) i ==
--   i, when inRange (l,u) i
--   
--   
--   map (index (l,u)) (range (l,u)) == [0 .. rangeSize (l,u) - 1]
--   
--   
--   
--   rangeSize (l,u) == length (range (l,u))
--   
ixLaws :: (Ix a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Partial Isomorphism fromList . toList ≡
--   id
--   
- Length Preservation fromList xs ≡ fromListN
--   (length xs) xs
--   
--   
--   Note: This property test is only available when using
--   base-4.7 or newer.
isListLaws :: (IsList a, Show a, Show (Item a), Arbitrary a, Arbitrary (Item a), Eq a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Partial Isomorphism decode . encode ≡
--   Just
--   
- Encoding Equals Value decode . encode ≡ Just .
--   toJSON
--   
--   
--   Note that in the second property, the type of decode is ByteString
--   -> Value, not ByteString -> a
jsonLaws :: (ToJSON a, FromJSON a, Show a, Arbitrary a, Eq a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Associative mappend a (mappend b c) ≡ mappend
--   (mappend a b) c
--   
- Left Identity mappend mempty a ≡ a
--   
- Right Identity mappend a mempty ≡ a
--   
- Concatenation mconcat as ≡ foldr mappend mempty
--   as
--   
monoidLaws :: (Monoid a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Commutative mappend a b ≡ mappend b a
--   
--   
--   Note that this does not test associativity or identity. Make sure to
--   use monoidLaws in addition to this set of laws.
commutativeMonoidLaws :: (Monoid a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws
semigroupMonoidLaws :: (Semigroup a, Monoid a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Antisymmetry a ≤ b ∧ b ≤ a ⇒ a = b
--   
- Transitivity a ≤ b ∧ b ≤ c ⇒ a ≤ c
--   
- Totality a ≤ b ∨ a > b
--   
ordLaws :: (Ord a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Succ Pred Identity succ (pred x) ≡
--   x
--   
- Pred Succ Identity pred (succ x) ≡
--   x
--   
--   
--   This only works for Enum types that are not bounded, meaning
--   that succ and pred must be total. This means that these
--   property tests work correctly for types like Integer but not
--   for Int.
--   
--   Sadly, there is not a good way to test fromEnum and
--   toEnum, since many types that have reasonable implementations
--   for succ and pred have more inhabitants than Int
--   does.
enumLaws :: (Enum a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the same properties as enumLaws except that it requires
--   the type to have a Bounded instance. These tests avoid taking
--   the successor of the maximum element or the predecessor of the minimal
--   element.
boundedEnumLaws :: (Enum a, Bounded a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Test that a Prim instance obey the several laws.
primLaws :: (Prim a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Associative a <> (b <>
--   c) ≡ (a <> b) <> c
--   
- Concatenation sconcat as ≡ foldr1
--   (<>) as
--   
- Times stimes n a ≡ foldr1
--   (<>) (replicate n a)
--   
semigroupLaws :: (Semigroup a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Commutative a <> b ≡ b
--   <> a
--   
--   
--   Note that this does not test associativity. Make sure to use
--   semigroupLaws in addition to this set of laws.
commutativeSemigroupLaws :: (Semigroup a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Exponential stimes n (a <>
--   b) ≡ stimes n a <> stimes n b
--   
--   
--   Note that this does not test associativity. Make sure to use
--   semigroupLaws in addition to this set of laws.
exponentialSemigroupLaws :: (Semigroup a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Idempotent a <> a ≡ a
--   
--   
--   Note that this does not test associativity. Make sure to use
--   semigroupLaws in addition to this set of laws. In literature,
--   this class of semigroup is known as a band.
idempotentSemigroupLaws :: (Semigroup a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Rectangular Band a <> b
--   <> a ≡ a
--   
--   
--   Note that this does not test associativity. Make sure to use
--   semigroupLaws in addition to this set of laws.
rectangularBandSemigroupLaws :: (Semigroup a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Additive Commutativity a + b ≡ b + a
--   
- Additive Left Identity 0 + a ≡ a
--   
- Additive Right Identity a + 0 ≡ a
--   
- Multiplicative Associativity a * (b * c) ≡ (a *
--   b) * c
--   
- Multiplicative Left Identity 1 * a ≡ a
--   
- Multiplicative Right Identity a * 1 ≡
--   a
--   
- Multiplication Left Distributes Over Addition a
--   * (b + c) ≡ (a * b) + (a * c)
--   
- Multiplication Right Distributes Over Addition
--   (a + b) * c ≡ (a * c) + (b * c)
--   
- Multiplicative Left Annihilation 0 * a ≡
--   0
--   
- Multiplicative Right Annihilation a * 0 ≡
--   0
--   
--   
--   Also tests that fromNatural is a homomorphism of semirings:
--   
--   
--   
- FromNatural Maps Zero fromNatural 0 =
--   zero
--   
- FromNatural Maps One fromNatural 1 =
--   one
--   
- FromNatural Maps Plus fromNatural (a
--   + b) = fromNatural a + fromNatural
--   b
--   
- FromNatural Maps Times fromNatural
--   (a * b) = fromNatural a *
--   fromNatural b
--   
semiringLaws :: (Semiring a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Additive Inverse negate a + a ≡
--   0
--   
--   
--   Note that this does not test any of the laws tested by
--   semiringLaws.
ringLaws :: (Ring a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Test that a GcdDomain instance obey several laws.
--   
--   Check that divide is an inverse of times:
--   
--   
--   
- y /= 0 => (x * y) `divide` y == Just x,
--   
- y /= 0, x `divide` y == Just z => x == z * y.
--   
--   
--   Check that gcd is a common divisor and is a multiple of any
--   common divisor:
--   
--   
--   
- x /= 0, y /= 0 => isJust (x `divide` gcd x y) &&
--   isJust (y `divide` gcd x y),
--   
- z /= 0 => isJust (gcd (x * z) (y * z) `divide`
--   z).
--   
--   
--   Check that lcm is a common multiple and is a factor of any
--   common multiple:
--   
--   
--   
- x /= 0, y /= 0 => isJust (lcm x y `divide` x) &&
--   isJust (lcm x y `divide` y),
--   
- x /= 0, y /= 0, isJust (z `divide` x), isJust (z `divide` y)
--   => isJust (z `divide` lcm x y).
--   
--   
--   Check that gcd of coprime numbers is a unit of the
--   semiring (has an inverse):
--   
--   
--   
- y /= 0, coprime x y => isJust (1 `divide` gcd x
--   y).
--   
gcdDomainLaws :: (Eq a, GcdDomain a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Test that a Euclidean instance obey laws of a Euclidean domain.
--   
--   
--   
- y /= 0, r == x `rem` y => r == 0 || degree r < degree
--   y,
--   
- y /= 0, (q, r) == x `quotRem` y => x == q * y +
--   r,
--   
- y /= 0 => x `quot` x y == fst (x `quotRem` y),
--   
- y /= 0 => x `rem` x y == snd (x `quotRem` y).
--   
euclideanLaws :: (Eq a, Euclidean a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Show show a ≡ showsPrec 0 a
--   ""
--   
- Equivariance: showsPrec showsPrec
--   p a r ++ s ≡ showsPrec p a (r ++ s)
--   
- Equivariance: showList showList as
--   r ++ s ≡ showList as (r ++ s)
--   
showLaws :: (Show a, Arbitrary a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- Partial Isomorphism: show / read
--   readMaybe (show a) ≡ Just a
--   
- Partial Isomorphism: show / read with initial
--   space readMaybe (" " ++ show a) ≡
--   Just a
--   
- Partial Isomorphism: showsPrec /
--   readsPrec (a,"") `elem` readsPrec p
--   (showsPrec p a "")
--   
- Partial Isomorphism: showList /
--   readList (as,"") `elem` readList
--   (showList as "")
--   
- Partial Isomorphism: showListWith shows /
--   readListDefault (as,"") `elem`
--   readListDefault (showListWith shows as
--   "")
--   
--   
--   Note: When using base-4.5 or older, a shim
--   implementation of readMaybe is used.
showReadLaws :: (Show a, Read a, Eq a, Arbitrary a) => Proxy a -> Laws

-- | Tests the following Storable properties:
--   
--   
--   
- Set-Get (pokeElemOff ptr ix a >>
--   peekElemOff ptr ix') ≡ pure a
--   
- Get-Set (peekElemOff ptr ix >>
--   pokeElemOff ptr ix a) ≡ pure a
--   
storableLaws :: (Storable a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- From-To Inverse from . to ≡
--   id
--   
- To-From Inverse to . from ≡
--   id
--   
--   
--   Note: This property test is only available when using
--   base-4.5 or newer.
--   
--   Note: from and to don't actually care about the
--   type variable x in Rep a x, so here we
--   instantiate it to () by default. If you would like
--   to instantiate x as something else, please file a bug report.
genericLaws :: (Generic a, Eq a, Arbitrary a, Show a, Show (Rep a ()), Arbitrary (Rep a ()), Eq (Rep a ())) => Proxy a -> Laws

-- | Tests the following properties:
--   
--   
--   
- From-To Inverse from1 . to1
--   ≡ id
--   
- To-From Inverse to1 . from1
--   ≡ id
--   
--   
--   Note: This property test is only available when using
--   base-4.9 or newer.
generic1Laws :: forall (f :: Type -> Type) proxy. (Generic1 f, Eq1 f, Arbitrary1 f, Show1 f, Eq1 (Rep1 f), Show1 (Rep1 f), Arbitrary1 (Rep1 f)) => proxy f -> Laws

-- | Tests the following alternative properties:
--   
--   
--   
- Left Identity empty <|> x ≡
--   x
--   
- Right Identity x <|> empty ≡
--   x
--   
- Associativity a <|> (b
--   <|> c) ≡ (a <|> b) <|>
--   c)
--   
alternativeLaws :: forall (f :: Type -> Type) proxy. (Alternative f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following alt properties:
--   
--   
--   
- Associativity (a <!> b)
--   <!> c ≡ a <!> (b <!>
--   c)
--   
- Left Distributivity f <$> (a
--   <!> b) ≡ (f <$> a) <!> (f
--   <$> b)
--   
altLaws :: forall proxy (f :: Type -> Type). (Alt f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following alt properties:
--   
--   
--   
- LiftF2 (1) (<.>) ≡ liftF2
--   id
--   
- Associativity fmap (.) u
--   <.> v <.> w ≡ u <.> (v
--   <.> w)
--   
applyLaws :: forall (f :: Type -> Type) proxy. (Apply f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following applicative properties:
--   
--   
--   
- Identity pure id <*>
--   v ≡ v
--   
- Composition pure (.)
--   <*> u <*> v <*> w ≡ u
--   <*> (v <*> w)
--   
- Homomorphism pure f <*>
--   pure x ≡ pure (f x)
--   
- Interchange u <*> pure y ≡
--   pure ($ y) <*> u
--   
- LiftA2 (1) (<*>) ≡ liftA2
--   id
--   
applicativeLaws :: forall (f :: Type -> Type) proxy. (Applicative f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following contravariant properties:
--   
--   
--   
- Identity contramap id ≡
--   id
--   
- Composition contramap f .
--   contramap g ≡ contramap (g . f)
--   
contravariantLaws :: forall (f :: Type -> Type) proxy. (Contravariant f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following Foldable properties:
--   
--   
--   
- fold fold ≡ foldMap
--   id
--   
- foldMap foldMap f ≡ foldr
--   (mappend . f) mempty
--   
- foldr foldr f z t ≡ appEndo
--   (foldMap (Endo . f) t ) z
--   
- foldr' foldr' f z0 xs ≡ let f' k x z = k
--   $! f x z in foldl f' id xs z0
--   
- foldr1 foldr1 f t ≡ let Just
--   (xs,x) = unsnoc (toList t) in foldr f x
--   xs
--   
- foldl foldl f z t ≡ appEndo
--   (getDual (foldMap (Dual . Endo .
--   flip f) t)) z
--   
- foldl' foldl' f z0 xs ≡ let f' x k z = k
--   $! f z x in foldr f' id xs z0
--   
- foldl1 foldl1 f t ≡ let x : xs =
--   toList t in foldl f x xs
--   
- toList toList ≡ foldr (:)
--   []
--   
- null null ≡ foldr (const
--   (const False)) True
--   
- length length ≡ getSum .
--   foldMap (const (Sum 1))
--   
--   
--   Note that this checks to ensure that foldl' and
--   foldr' are suitably strict.
foldableLaws :: forall proxy (f :: Type -> Type). (Foldable f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following functor properties:
--   
--   
--   
- Identity fmap id ≡
--   id
--   
- Composition fmap (f . g) ≡
--   fmap f . fmap g
--   
- Const (<$) ≡ fmap
--   const
--   
functorLaws :: forall (f :: Type -> Type) proxy. (Functor f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following monadic properties:
--   
--   
--   
- Left Identity return a >>= k
--   ≡ k a
--   
- Right Identity m >>= return
--   ≡ m
--   
- Associativity m >>= (\x -> k x
--   >>= h) ≡ (m >>= k) >>=
--   h
--   
- Return pure ≡ return
--   
- Ap (<*>) ≡ ap
--   
monadLaws :: forall (f :: Type -> Type) proxy. (Monad f, Applicative f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following monad plus properties:
--   
--   
--   
- Left Identity mplus mzero x ≡
--   x
--   
- Right Identity mplus x mzero ≡
--   x
--   
- Associativity mplus a (mplus b c)
--   ≡ mplus (mplus a b) c)
--   
- Left Zero mzero >>= f ≡
--   mzero
--   
- Right Zero m >> mzero ≡
--   mzero
--   
monadPlusLaws :: forall (f :: Type -> Type) proxy. (MonadPlus f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following monadic zipping properties:
--   
--   
--   
- Naturality liftM (f *** g)
--   (mzip ma mb) = mzip (liftM f ma) (liftM g
--   mb)
--   
--   
--   In the laws above, the infix function *** refers to a
--   typeclass method of Arrow.
monadZipLaws :: forall (f :: Type -> Type) proxy. (MonadZip f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following alt properties:
--   
--   
--   
- Left Identity zero <!> m ≡
--   m
--   
- Right Identity m <!> zero ≡
--   m
--   
plusLaws :: forall proxy (f :: Type -> Type). (Plus f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests everything from altLaws, plus the following:
--   
--   
--   
- Congruency zero ≡ empty
--   
extendedPlusLaws :: forall proxy (f :: Type -> Type). (Plus f, Alternative f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following Traversable properties:
--   
--   
--   
- Naturality t . traverse f ≡
--   traverse (t . f) for every applicative
--   transformation t
--   
- Identity traverse Identity ≡
--   Identity
--   
- Composition traverse (Compose
--   . fmap g . f) ≡ Compose .
--   fmap (traverse g) . traverse f
--   
- Sequence Naturality t . sequenceA
--   ≡ sequenceA . fmap t for every applicative
--   transformation t
--   
- Sequence Identity sequenceA .
--   fmap Identity ≡ Identity
--   
- Sequence Composition sequenceA .
--   fmap Compose ≡ Compose . fmap
--   sequenceA . sequenceA
--   
- foldMap foldMap ≡
--   foldMapDefault
--   
- fmap fmap ≡ fmapDefault
--   
--   
--   Where an applicative transformation is a function
--   
--   
--   t :: (Applicative f, Applicative g) => f a -> g a
--   
--   
--   preserving the Applicative operations, i.e.
--   
--   
--   
- Identity: t (pure x) ≡ pure x
--   
- Distributivity: t (x <*> y) ≡ t x
--   <*> t y
--   
traversableLaws :: forall (f :: Type -> Type) proxy. (Traversable f, forall a. Eq a => Eq (f a), forall a. Show a => Show (f a), forall a. Arbitrary a => Arbitrary (f a)) => proxy f -> Laws

-- | Tests the following Bifunctor properties:
--   
--   
--   
- Bifold Identity bifold ≡ bifoldMap
--   id id
--   
- BifoldMap Identity bifoldMap f g ≡
--   bifoldr (mappend . f) (mappend . g)
--   mempty
--   
- Bifoldr Identity bifoldr f g z t ≡
--   appEndo (bifoldMap (Endo . f) (Endo
--   . g) t) z
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.10+ or transformers-0.5+.
bifoldableLaws :: forall proxy (f :: Type -> Type -> Type). (Bifoldable f, forall a b. (Eq a, Eq b) => Eq (f a b), forall a b. (Show a, Show b) => Show (f a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (f a b)) => proxy f -> Laws

-- | Tests the following Bifunctor properties:
--   
--   
--   
- Identity bimap id id ≡
--   id
--   
- First Identity first id ≡
--   id
--   
- Second Identity second id ≡
--   id
--   
- Bifunctor Composition bimap f g ≡
--   first f . second g
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.9+ or transformers-0.5+.
bifunctorLaws :: forall proxy (f :: Type -> Type -> Type). (Bifunctor f, forall a b. (Eq a, Eq b) => Eq (f a b), forall a b. (Show a, Show b) => Show (f a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (f a b)) => proxy f -> Laws

-- | Tests the following Bitraversable properties:
--   
--   
--   
- Naturality bitraverse (t . f) (t
--   . g) ≡ t . bitraverse f g for every
--   applicative transformation t
--   
- Identity bitraverse Identity
--   Identity ≡ Identity
--   
- Composition Compose . fmap
--   (bitraverse g1 g2) . bitraverse f1 f2 ≡
--   bitraverse (Compose . fmap g1 g2 .
--   f1) (Compose . fmap g2 . f2)
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.9+ or transformers-0.5+.
bitraversableLaws :: forall proxy (f :: Type -> Type -> Type). (Bitraversable f, forall a b. (Eq a, Eq b) => Eq (f a b), forall a b. (Show a, Show b) => Show (f a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (f a b)) => proxy f -> Laws

-- | Tests the following Category properties:
--   
--   
--   
- Right Identity f . id ≡
--   f
--   
- Left Identity id . f ≡ f
--   
- Associativity f . (g . h) ≡ (f
--   . g) . h
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.9+ or transformers-0.5+.
categoryLaws :: forall proxy (c :: Type -> Type -> Type). (Category c, forall a b. (Eq a, Eq b) => Eq (c a b), forall a b. (Show a, Show b) => Show (c a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (c a b)) => proxy c -> Laws

-- | Test everything from categoryLaws plus the following:
--   
--   
--   
- Commutative f . g ≡ g .
--   f
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.9+ or transformers-0.5+.
commutativeCategoryLaws :: forall proxy (c :: Type -> Type -> Type). (Category c, forall a b. (Eq a, Eq b) => Eq (c a b), forall a b. (Show a, Show b) => Show (c a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (c a b)) => proxy c -> Laws

-- | Tests the following Semigroupoid properties:
--   
--   
--   
- Associativity f `<tt>o'</tt> (g `o' h)
--   ≡ (f `<tt>o'</tt> g) `o' h
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.9+ or transformers-0.5+.
semigroupoidLaws :: forall proxy (s :: Type -> Type -> Type). (Semigroupoid s, forall a b. (Eq a, Eq b) => Eq (s a b), forall a b. (Show a, Show b) => Show (s a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (s a b)) => proxy s -> Laws

-- | Tests everything from semigroupoidLaws plus the following:
--   
--   
--   
- Commutative f `<tt>o'</tt> g ≡ g `o'
--   f
--   
--   
--   Note: This property test is only available when this package is
--   built with base-4.9+ or transformers-0.5+.
commutativeSemigroupoidLaws :: forall proxy (s :: Type -> Type -> Type). (Semigroupoid s, forall a b. (Eq a, Eq b) => Eq (s a b), forall a b. (Show a, Show b) => Show (s a b), forall a b. (Arbitrary a, Arbitrary b) => Arbitrary (s a b)) => proxy s -> Laws

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

-- | A set of laws associated with a typeclass.
--   
--   Note: Most of the top-level functions provided by this library
--   have the shape `forall a. (Ctx a) =&gt; Proxy a -&gt; Laws`. You can
--   just as easily provide your own Laws in libraries/test suites
--   using regular QuickCheck machinery.
data Laws
Laws :: String -> [(String, Property)] -> Laws

-- | Name of the typeclass whose laws are tested
[lawsTypeclass] :: Laws -> String

-- | Pairs of law name and property
[lawsProperties] :: Laws -> [(String, Property)]

-- | In older versions of GHC, Proxy is not poly-kinded, so we provide
--   Proxy1.
data Proxy1 (f :: Type -> Type)
Proxy1 :: Proxy1 (f :: Type -> Type)

-- | In older versions of GHC, Proxy is not poly-kinded, so we provide
--   Proxy2.
data Proxy2 (f :: Type -> Type -> Type)
Proxy2 :: Proxy2 (f :: Type -> Type -> Type)
