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


-- | Simple boolean tests to see if a value abides by certain properties
--   
--   Please see the README on GitHub at
--   <a>https://github.com/athanclark/abides#readme</a>
@package abides
@version 0.0.1

module Test.Abides.Control.Applicative
identity :: Applicative f => Eq (f a) => f a -> Bool
composition :: Applicative f => Eq (f c) => f (b -> c) -> f (a -> b) -> f a -> Bool

module Test.Abides.Control.Category
identity :: Category c => Eq (c a b) => c a b -> Bool
associative :: Category q => Eq (q a d) => q c d -> q b c -> q a b -> Bool

module Test.Abides.Control.Comonad
leftIdentity :: Comonad w => Eq (w a) => w a -> Bool
rightIdentity :: Comonad w => Eq a => (w a -> a) -> w a -> Bool
associative :: Comonad w => Eq (w c) => (w b -> c) -> (w a -> b) -> w a -> Bool

module Test.Abides.Data.Bounded

-- | minBound &lt;= x &lt;= maxBound?
bounded :: Bounded a => Ord a => a -> Bool

module Test.Abides.Data.DivisionRing
inverse :: Fractional a => Eq a => a -> Bool

module Test.Abides.Data.Enum

-- | compare x y == compare (fromEnum x) (fromEnum y)
compareHom :: Enum a => Ord a => a -> a -> Bool

-- | pred (succ x) == x
predsucc :: Enum a => Eq a => a -> Bool

-- | succ (pred x) == x
succpred :: Enum a => Eq a => a -> Bool

module Test.Abides.Data.EuclideanRing
integralDomain :: Num a => Eq a => a -> a -> Bool

module Test.Abides.Data.Foldable

-- | fold (map f x) == foldMap f x
foldMap' :: Foldable f => Functor f => Monoid b => Eq b => (a -> b) -> f a -> Bool

module Test.Abides.Data.Functor

-- | fmap id x == x?
identity :: Functor f => Eq (f a) => f a -> Bool

-- | fmap (f . g) x == fmap f (fmap g x)?
composition :: Functor f => Eq (f a) => (a -> a) -> (a -> a) -> f a -> Bool

module Test.Abides.Data.Ord

-- | x &lt;= x?
reflexive :: Ord a => a -> Bool

-- | x <a>y &amp;&amp; y &lt;= x =</a> x == y
antisymmetry :: Ord a => a -> a -> Bool

-- | x <a>y &amp;&amp; y &lt;= z =</a> x &lt;= z
transitive :: Ord a => a -> a -> a -> Bool

module Test.Abides.Data.Ring
additiveInverse :: Num a => Eq a => a -> Bool

module Test.Abides.Properties

-- | x == x?
reflexive :: Eq a => a -> Bool

-- | f x y == f y x?
commutative :: Eq b => (a -> a -> b) -> a -> a -> Bool

-- | f (f x y) z == f x (f y z)?
associative :: Eq a => (a -> a -> a) -> a -> a -> a -> Bool

-- | f (f x) == f x?
idempotent :: Eq a => (a -> a) -> a -> Bool

-- | f (g x y) == g (f x) (f y)?
distributive :: Eq a => (a -> a) -> (a -> a -> a) -> a -> a -> Bool

-- | f (g x y) == g' (f x) (f y)?
distributive' :: Eq b => (a -> b) -> (a -> a -> a) -> (b -> b -> b) -> a -> a -> Bool

-- | f x y == x? Note: bottom ~ forall y. f bottom y == bottom, while unit
--   ~ forall x. f x unit == x
constL :: Eq a => (a -> a -> a) -> a -> a -> Bool

-- | f x y == y?
constR :: Eq a => (a -> a -> a) -> a -> a -> Bool

module Test.Abides.Data.Semiring
commutativeMonoid :: Num a => Eq a => a -> a -> a -> Bool
monoid :: Num a => Eq a => a -> a -> a -> Bool
leftDistributive :: Num a => Eq a => a -> a -> a -> Bool
rightDistributive :: Num a => Eq a => a -> a -> a -> Bool
annihilation :: Num a => Eq a => a -> Bool

module Test.Abides.Data.Semigroup
associative :: Semigroup a => Eq a => a -> a -> a -> Bool

module Test.Abides.Data.Monoid
leftIdentity :: Monoid a => Eq a => a -> Bool
rightIdentity :: Monoid a => Eq a => a -> Bool

module Test.Abides.Data.Eq

-- | x == x?
reflexive :: Eq a => a -> Bool

-- | x == y =&gt; y == x?
symmetry :: Eq a => a -> a -> Bool

-- | x == y &amp;&amp; y == z =&gt; x == z
transitive :: Eq a => a -> a -> a -> Bool

-- | x /= y =&gt; not (x == y)
negation :: Eq a => a -> a -> Bool

module Test.Abides.Data.CommutativeRing
commutative :: Num a => Eq a => a -> a -> Bool

module Test.Abides.Control.Monad
leftIdentity :: Monad m => Eq (m b) => (a -> m b) -> a -> Bool
rightIdentity :: Monad m => Eq (m a) => m a -> Bool
associative :: Monad m => Eq (m c) => (a -> m b) -> (b -> m c) -> m a -> Bool
annihilation :: MonadPlus m => Eq (m b) => (a -> m b) -> Bool
distributive :: MonadPlus m => Eq (m b) => (a -> m b) -> m a -> m a -> Bool

module Test.Abides.Control.Alternative

-- | (f <a>|</a> g) <a>*</a> x == (f <a>*</a> x) <a>|</a> (g <a>|</a> x)
distributive :: Alternative f => Applicative f => Eq (f b) => f a -> f (a -> b) -> f (a -> b) -> Bool

-- | empty <a>*</a> x == empty
annihilation :: Alternative f => Applicative f => Eq (f b) => f (a -> b) -> Bool