Test.Validity

Documentation

module Data.GenValidity

data Proxy k t :: forall k. k -> *

A concrete, poly-kinded proxy type

Constructors

Proxy

Instances

Monad (Proxy *)

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

Functor (Proxy *)

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b

(<$) :: a -> Proxy * b -> Proxy * a

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a

(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b

(*>) :: Proxy * a -> Proxy * b -> Proxy * b

(<*) :: Proxy * a -> Proxy * b -> Proxy * a

Foldable (Proxy *)

Methods

fold :: Monoid m => Proxy * m -> m

foldMap :: Monoid m => (a -> m) -> Proxy * a -> m

foldr :: (a -> b -> b) -> b -> Proxy * a -> b

foldr' :: (a -> b -> b) -> b -> Proxy * a -> b

foldl :: (b -> a -> b) -> b -> Proxy * a -> b

foldl' :: (b -> a -> b) -> b -> Proxy * a -> b

foldr1 :: (a -> a -> a) -> Proxy * a -> a

foldl1 :: (a -> a -> a) -> Proxy * a -> a

toList :: Proxy * a -> [a]

null :: Proxy * a -> Bool

length :: Proxy * a -> Int

elem :: Eq a => a -> Proxy * a -> Bool

maximum :: Ord a => Proxy * a -> a

minimum :: Ord a => Proxy * a -> a

sum :: Num a => Proxy * a -> a

product :: Num a => Proxy * a -> a

Eq1 (Proxy *)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool

Ord1 (Proxy *)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering

Read1 (Proxy *)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a]

Show1 (Proxy *)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS

Alternative (Proxy *)

Methods

empty :: Proxy * a

(<|>) :: Proxy * a -> Proxy * a -> Proxy * a

some :: Proxy * a -> Proxy * [a]

many :: Proxy * a -> Proxy * [a]

MonadPlus (Proxy *)

Methods

mzero :: Proxy * a

mplus :: Proxy * a -> Proxy * a -> Proxy * a

Bounded (Proxy k s)

Methods

minBound :: Proxy k s

maxBound :: Proxy k s

Enum (Proxy k s)

Methods

succ :: Proxy k s -> Proxy k s

pred :: Proxy k s -> Proxy k s

toEnum :: Int -> Proxy k s

fromEnum :: Proxy k s -> Int

enumFrom :: Proxy k s -> [Proxy k s]

enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s]

Eq (Proxy k s)

Methods

(==) :: Proxy k s -> Proxy k s -> Bool

(/=) :: Proxy k s -> Proxy k s -> Bool

Data t => Data (Proxy * t)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy * t -> c (Proxy * t)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy * t)

toConstr :: Proxy * t -> Constr

dataTypeOf :: Proxy * t -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy * t))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy * t))

gmapT :: (forall b. Data b => b -> b) -> Proxy * t -> Proxy * t

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r

gmapQ :: (forall d. Data d => d -> u) -> Proxy * t -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy * t -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t)

Ord (Proxy k s)

Methods

compare :: Proxy k s -> Proxy k s -> Ordering

(<) :: Proxy k s -> Proxy k s -> Bool

(<=) :: Proxy k s -> Proxy k s -> Bool

(>) :: Proxy k s -> Proxy k s -> Bool

(>=) :: Proxy k s -> Proxy k s -> Bool

max :: Proxy k s -> Proxy k s -> Proxy k s

min :: Proxy k s -> Proxy k s -> Proxy k s

Read (Proxy k s)

Methods

readsPrec :: Int -> ReadS (Proxy k s)

readList :: ReadS [Proxy k s]

readPrec :: ReadPrec (Proxy k s)

readListPrec :: ReadPrec [Proxy k s]

Show (Proxy k s)

Methods

showsPrec :: Int -> Proxy k s -> ShowS

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

Ix (Proxy k s)

Methods

range :: (Proxy k s, Proxy k s) -> [Proxy k s]

index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool

rangeSize :: (Proxy k s, Proxy k s) -> Int

unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int

Monoid (Proxy k s)

Methods

mempty :: Proxy k s

mappend :: Proxy k s -> Proxy k s -> Proxy k s

mconcat :: [Proxy k s] -> Proxy k s

Tests for Arbitrary instances involving Validity

arbitrarySpec :: (Typeable a, Show a, Validity a, Arbitrary a) => Proxy a -> Spec

A Spec that specifies that arbitrary only generates data that satisfy isValid and that shrink only produces data that satisfy isValid.

Example usage:

arbitrarySpec (Proxy :: Proxy MyData)

arbitraryGeneratesOnlyValid :: forall a. (Show a, Validity a, Arbitrary a) => Proxy a -> Property

arbitrary only generates valid data

shrinkProducesOnlyValids :: forall a. (Show a, Validity a, Arbitrary a) => Proxy a -> Property

shrink, applied to valid data only produces valid data

Tests for GenValidity instances

genValiditySpec :: (Typeable a, Show a, GenValidity a) => Proxy a -> Spec

A Spec that specifies that genValid only generates valid data and that genInvalid only generates invalid data.

In general it is a good idea to add this spec to your test suite if you write a custom implementation of genValid or genInvalid.

Example usage:

genValiditySpec (Proxy :: Proxy MyData)

genValidityValidGeneratesValid :: forall a. (Show a, GenValidity a) => Proxy a -> Property

genValid only generates valid data

genGeneratesValid :: (Show a, Validity a) => Gen a -> Property

The given generator generates only valid data points

genValidityInvalidGeneratesInvalid :: forall a. (Show a, GenValidity a) => Proxy a -> Property

genValid only generates invalid data

genGeneratesInvalid :: (Show a, Validity a) => Gen a -> Property

The given generator generates only invalid data points

Tests for RelativeValidity instances

relativeValiditySpec :: (Typeable a, Typeable b, Show a, Show b, GenValidity a, GenValidity b, GenRelativeValidity a b) => Proxy a -> Proxy b -> Spec

A Spec that specifies that isValidFor implies isValid

In general it is a good idea to add this spec to your test suite if the a and b in RelativeValidity a b also have a Validity instance.

Example usage:

relativeValiditySpec
    (Proxy :: Proxy MyDataFor)
    (Proxy :: Proxy MyOtherData)

relativeValidityImpliesValidA :: (Show a, Show b, GenValidity a, GenValidity b, RelativeValidity a b) => Proxy a -> Proxy b -> Property

isValidFor a b implies isValid a for all b

relativeValidityImpliesValidB :: (Show a, Show b, GenValidity a, GenValidity b, RelativeValidity a b) => Proxy a -> Proxy b -> Property

isValidFor a b implies isValid b for all a

Tests for GenRelativeValidity instances

genRelativeValiditySpec :: (Typeable a, Typeable b, Show a, Show b, GenValidity a, GenValidity b, RelativeValidity a b, GenRelativeValidity a b) => Proxy a -> Proxy b -> Spec

A Spec that specifies that genValidFor and genInvalidFor work as intended.

In general it is a good idea to add this spec to your test suite if you write a custom implementation of genValidFor or genInvalidFor.

Example usage:

relativeGenValiditySpec (proxy :: MyDataFor) (proxy :: MyOtherData)

genRelativeValidityValidGeneratesValid :: (Show a, Show b, GenValidity a, GenValidity b, RelativeValidity a b, GenRelativeValidity a b) => Proxy a -> Proxy b -> Property

genValidFor b only generates values that satisfy isValidFor b

genRelativeValidityInvalidGeneratesInvalid :: (Show a, Show b, GenValidity a, GenValidity b, RelativeValidity a b, GenRelativeValidity a b) => Proxy a -> Proxy b -> Property

genInvalidFor b only generates values that do not satisfy isValidFor b

Standard tests involving functions

Standard tests involving validity

producesValidsOnGen :: (Show a, Show b, Validity b) => (a -> b) -> Gen a -> Property

The function produces valid output when the input is generated as specified by the given generator.

producesValidsOnValids :: (Show a, Show b, GenValidity a, Validity b) => (a -> b) -> Property

The function produces valid output when the input is generated by genValid

producesValid :: (Show a, Show b, GenValidity a, Validity b) => (a -> b) -> Property

The function produces valid output when the input is generated by genUnchecked

producesValidsOnArbitrary :: (Show a, Show b, Arbitrary a, Validity b) => (a -> b) -> Property

The function produces valid output when the input is generated by arbitrary

producesValidsOnGens2 :: (Show a, Show b, Show c, Validity c) => (a -> b -> c) -> Gen (a, b) -> Property

producesValidsOnValids2 :: (Show a, Show b, Show c, GenValidity a, GenValidity b, Validity c) => (a -> b -> c) -> Property

producesValid2 :: (Show a, Show b, Show c, GenValidity a, GenValidity b, Validity c) => (a -> b -> c) -> Property

producesValidsOnArbitrary2 :: (Show a, Show b, Show c, Arbitrary a, Arbitrary b, Validity c) => (a -> b -> c) -> Property

producesValidsOnGens3 :: (Show a, Show b, Show c, Show d, Validity d) => (a -> b -> c -> d) -> Gen (a, b, c) -> Property

producesValidsOnValids3 :: (Show a, Show b, Show c, Show d, GenValidity a, GenValidity b, GenValidity c, Validity d) => (a -> b -> c -> d) -> Property

producesValid3 :: (Show a, Show b, Show c, Show d, GenValidity a, GenValidity b, GenValidity c, Validity d) => (a -> b -> c -> d) -> Property

producesValidsOnArbitrary3 :: (Show a, Show b, Show c, Show d, Arbitrary a, Arbitrary b, Arbitrary c, Validity d) => (a -> b -> c -> d) -> Property

Standard tests involving functions that can fail

class CanFail f where

A class of types that are the result of functions that can fail

Minimal complete definition

hasFailed, resultIfSucceeded

Methods

hasFailed :: f a -> Bool

resultIfSucceeded :: f a -> Maybe a

Instances

CanFail Maybe

Methods

hasFailed :: Maybe a -> Bool

resultIfSucceeded :: Maybe a -> Maybe a

CanFail (Either e)

Methods

hasFailed :: Either e a -> Bool

resultIfSucceeded :: Either e a -> Maybe a

succeedsOnGen :: (Show a, Show b, Show (f b), CanFail f) => (a -> f b) -> Gen a -> Property

The function succeeds if the input is generated by the given generator

succeedsOnValid :: (Show a, Show b, Show (f b), GenValidity a, CanFail f) => (a -> f b) -> Property

The function succeeds if the input is generated by genValid

succeeds :: (Show a, Show b, Show (f b), GenValidity a, CanFail f) => (a -> f b) -> Property

The function succeeds if the input is generated by genUnchecked

succeedsOnArbitrary :: (Show a, Show b, Show (f b), Arbitrary a, CanFail f) => (a -> f b) -> Property

The function succeeds if the input is generated by arbitrary

succeedsOnGens2 :: (Show a, Show b, Show c, Show (f c), CanFail f) => (a -> b -> f c) -> Gen (a, b) -> Property

succeedsOnValids2 :: (Show a, Show b, Show c, Show (f c), GenValidity a, GenValidity b, CanFail f) => (a -> b -> f c) -> Property

succeeds2 :: (Show a, Show b, Show c, Show (f c), GenValidity a, GenValidity b, CanFail f) => (a -> b -> f c) -> Property

succeedsOnArbitrary2 :: (Show a, Show b, Show c, Show (f c), Arbitrary a, Arbitrary b, CanFail f) => (a -> b -> f c) -> Property

failsOnGen :: (Show a, Show b, Show (f b), CanFail f) => (a -> f b) -> Gen a -> Property

The function fails if the input is generated by the given generator

failsOnInvalid :: (Show a, Show b, Show (f b), GenValidity a, CanFail f) => (a -> f b) -> Property

The function fails if the input is generated by genInvalid

failsOnGens2 :: (Show a, Show b, Show c, Show (f c), CanFail f) => (a -> b -> f c) -> Gen a -> Gen b -> Property

failsOnInvalid2 :: (Show a, Show b, Show c, Show (f c), GenValidity a, GenValidity b, CanFail f) => (a -> b -> f c) -> Property

validIfSucceedsOnGen :: (Show a, Show b, Show (f b), Validity b, CanFail f) => (a -> f b) -> Gen a -> Property

The function produces output that satisfies isValid if it is given input that is generated by the given generator.

validIfSucceedsOnValid :: (Show a, Show b, Show (f b), GenValidity a, Validity b, CanFail f) => (a -> f b) -> Property

The function produces output that satisfies isValid if it is given input that is generated by arbitrary.

validIfSucceedsOnArbitrary :: (Show a, Show b, Show (f b), Arbitrary a, Validity b, CanFail f) => (a -> f b) -> Property

The function produces output that satisfies isValid if it is given input that is generated by arbitrary.

validIfSucceeds :: (Show a, Show b, Show (f b), GenValidity a, Validity b, CanFail f) => (a -> f b) -> Property

The function produces output that satisfies isValid if it is given input that is generated by genUnchecked.

validIfSucceedsOnGens2 :: (Show a, Show b, Show c, Show (f c), Validity c, CanFail f) => (a -> b -> f c) -> Gen (a, b) -> Property

validIfSucceedsOnValids2 :: (Show a, Show b, Show c, Show (f c), GenValidity a, GenValidity b, Validity c, CanFail f) => (a -> b -> f c) -> Property

validIfSucceeds2 :: (Show a, Show b, Show c, Show (f c), GenValidity a, GenValidity b, Validity c, CanFail f) => (a -> b -> f c) -> Property

validIfSucceedsOnArbitrary2 :: (Show a, Show b, Show c, Show (f c), Arbitrary a, Arbitrary b, Validity c, CanFail f) => (a -> b -> f c) -> Property

Standard tests involving equivalence of functions

equivalentOnGen :: (Show a, Eq a, Show b, Eq b) => (a -> b) -> (a -> b) -> Gen a -> Property

equivalentOnValid :: (Show a, Eq a, GenValidity a, Show b, Eq b) => (a -> b) -> (a -> b) -> Property

equivalent :: (Show a, Eq a, GenValidity a, Show b, Eq b) => (a -> b) -> (a -> b) -> Property

equivalentOnGens2 :: (Show a, Eq a, Show b, Eq b, Show c, Eq c) => (a -> b -> c) -> (a -> b -> c) -> Gen (a, b) -> Property

equivalentOnValids2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c) => (a -> b -> c) -> (a -> b -> c) -> Property

equivalent2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c) => (a -> b -> c) -> (a -> b -> c) -> Property

equivalentWhenFirstSucceedsOnGen :: (Show a, Eq a, Show b, Eq b, CanFail f) => (a -> f b) -> (a -> b) -> Gen a -> Property

equivalentWhenFirstSucceedsOnValid :: (Show a, Eq a, GenValidity a, Show b, Eq b, CanFail f) => (a -> f b) -> (a -> b) -> Property

equivalentWhenFirstSucceeds :: (Show a, Eq a, GenValidity a, Show b, Eq b, CanFail f) => (a -> f b) -> (a -> b) -> Property

equivalentWhenFirstSucceedsOnGens2 :: (Show a, Eq a, Show b, Eq b, Show c, Eq c, CanFail f) => (a -> b -> f c) -> (a -> b -> c) -> Gen (a, b) -> Property

equivalentWhenFirstSucceedsOnValids2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c, CanFail f) => (a -> b -> f c) -> (a -> b -> c) -> Property

equivalentWhenFirstSucceeds2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c, CanFail f) => (a -> b -> f c) -> (a -> b -> c) -> Property

equivalentWhenSecondSucceedsOnGen :: (Show a, Eq a, Show b, Eq b, CanFail f) => (a -> b) -> (a -> f b) -> Gen a -> Property

equivalentWhenSecondSucceedsOnValid :: (Show a, Eq a, GenValidity a, Show b, Eq b, CanFail f) => (a -> b) -> (a -> f b) -> Property

equivalentWhenSecondSucceeds :: (Show a, Eq a, GenValidity a, Show b, Eq b, CanFail f) => (a -> b) -> (a -> f b) -> Property

equivalentWhenSecondSucceedsOnGens2 :: (Show a, Eq a, Show b, Eq b, Show c, Eq c, CanFail f) => (a -> b -> c) -> (a -> b -> f c) -> Gen (a, b) -> Property

equivalentWhenSecondSucceedsOnValids2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c, CanFail f) => (a -> b -> c) -> (a -> b -> f c) -> Property

equivalentWhenSecondSucceeds2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c, CanFail f) => (a -> b -> c) -> (a -> b -> f c) -> Property

equivalentWhenSucceedOnGen :: (Show a, Eq a, Show b, Eq b, CanFail f) => (a -> f b) -> (a -> f b) -> Gen a -> Property

equivalentWhenSucceedOnValid :: (Show a, Eq a, GenValidity a, Show b, Eq b, CanFail f) => (a -> f b) -> (a -> f b) -> Property

equivalentWhenSucceed :: (Show a, Eq a, GenValidity a, Show b, Eq b, CanFail f) => (a -> f b) -> (a -> f b) -> Property

equivalentWhenSucceedOnGens2 :: (Show a, Eq a, Show b, Eq b, Show c, Eq c, CanFail f) => (a -> b -> f c) -> (a -> b -> f c) -> Gen (a, b) -> Property

equivalentWhenSucceedOnValids2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c, CanFail f) => (a -> b -> f c) -> (a -> b -> f c) -> Property

equivalentWhenSucceed2 :: (Show a, Eq a, GenValidity a, Show b, Eq b, GenValidity b, Show c, Eq c, CanFail f) => (a -> b -> f c) -> (a -> b -> f c) -> Property

Standard tests involving inverse functions

inverseFunctionsOnGen :: (Show a, Eq a) => (a -> b) -> (b -> a) -> Gen a -> Property

inverseFunctionsOnValid :: (Show a, Eq a, GenValidity a) => (a -> b) -> (b -> a) -> Property

inverseFunctions :: (Show a, Eq a, GenValidity a) => (a -> b) -> (b -> a) -> Property

inverseFunctionsOnArbitrary :: (Show a, Eq a, Arbitrary a) => (a -> b) -> (b -> a) -> Property

id is its own inverse function for every type: prop> inverseFunctionsOnArbitrary id (id :: Int -> Int)

inverseFunctionsIfFirstSucceedsOnGen :: (Show a, Eq a, CanFail f) => (a -> f b) -> (b -> a) -> Gen a -> Property

inverseFunctionsIfFirstSucceedsOnValid :: (Show a, Eq a, GenValidity a, CanFail f) => (a -> f b) -> (b -> a) -> Property

inverseFunctionsIfFirstSucceeds :: (Show a, Eq a, GenValidity a, CanFail f) => (a -> f b) -> (b -> a) -> Property

inverseFunctionsIfFirstSucceedsOnArbitrary :: (Show a, Eq a, Arbitrary a, CanFail f) => (a -> f b) -> (b -> a) -> Property

inverseFunctionsIfSecondSucceedsOnGen :: (Show a, Eq a, CanFail f) => (a -> b) -> (b -> f a) -> Gen a -> Property

inverseFunctionsIfSecondSucceedsOnValid :: (Show a, Eq a, GenValidity a, CanFail f) => (a -> b) -> (b -> f a) -> Property

inverseFunctionsIfSecondSucceeds :: (Show a, Eq a, GenValidity a, CanFail f) => (a -> b) -> (b -> f a) -> Property

inverseFunctionsIfSecondSucceedsOnArbitrary :: (Show a, Eq a, Arbitrary a, CanFail f) => (a -> b) -> (b -> f a) -> Property

inverseFunctionsIfSucceedOnGen :: (Show a, Eq a, CanFail f, CanFail g) => (a -> f b) -> (b -> g a) -> Gen a -> Property

inverseFunctionsIfSucceedOnValid :: (Show a, Eq a, GenValidity a, CanFail f, CanFail g) => (a -> f b) -> (b -> g a) -> Property

inverseFunctionsIfSucceed :: (Show a, Eq a, GenValidity a, CanFail f, CanFail g) => (a -> f b) -> (b -> g a) -> Property

inverseFunctionsIfSucceedOnArbitrary :: (Show a, Eq a, Arbitrary a, CanFail f, CanFail g) => (a -> f b) -> (b -> g a) -> Property

Properties involving idempotence

idempotentOnGen :: (Show a, Eq a) => (a -> a) -> Gen a -> Property

idempotentOnValid :: (Show a, Eq a, GenValidity a) => (a -> a) -> Property

idempotent :: (Show a, Eq a, GenValidity a) => (a -> a) -> Property

idempotentOnArbitrary :: (Show a, Eq a, Arbitrary a) => (a -> a) -> Property

id is idempotent for any type:

idempotentOnArbitrary (id :: Int -> Int)

const, given any input, is idempotent for any type as well:

\int -> idempotentOnArbitrary (const int :: Int -> Int)

Properties of relations

Reflexivity

reflexiveOnElem

Arguments

:: (a -> a -> Bool)

A relation

-> a

An element

-> Bool

\[ Reflexive(prec) \quad\equiv\quad \forall a: (a \prec a) \]

reflexivityOnGen :: Show a => (a -> a -> Bool) -> Gen a -> Property

reflexivityOnValid :: (Show a, GenValidity a) => (a -> a -> Bool) -> Property

reflexivity :: (Show a, GenValidity a) => (a -> a -> Bool) -> Property

reflexivityOnArbitrary :: (Show a, Arbitrary a) => (a -> a -> Bool) -> Property

reflexivityOnArbitrary ((==) :: Int -> Int -> Bool)

Transitivity

transitiveOnElems

Arguments

:: (a -> a -> Bool)

A relation

-> a

-> a

-> a

Three elements

-> Bool

\[ Transitive(\prec) \quad\equiv\quad \forall a, b, c: ((a \prec b) \wedge (b \prec c)) \Rightarrow (a \prec c) \]

transitivityOnGens :: Show a => (a -> a -> Bool) -> Gen (a, a, a) -> Property

transitivityOnValid :: (Show a, GenValidity a) => (a -> a -> Bool) -> Property

transitivity :: (Show a, GenValidity a) => (a -> a -> Bool) -> Property

transitivityOnArbitrary :: (Show a, Arbitrary a) => (a -> a -> Bool) -> Property

transitivityOnArbitrary ((==) :: Int -> Int -> Bool)

Antisymmetry

antisymmetricOnElemsWithEquality

Arguments

:: (a -> a -> Bool)

A relation

-> (a -> a -> Bool)

An equivalence relation

-> a

-> a

Two elements

-> Bool

\[ Antisymmetric(\prec, \doteq) \quad\equiv\quad \forall a, b: ((a \prec b) \wedge (b \prec a)) \Rightarrow (a \doteq b) \]

antisymmetryOnGensWithEquality :: Show a => (a -> a -> Bool) -> Gen (a, a) -> (a -> a -> Bool) -> Property

antisymmetryOnGensEq :: (Show a, Eq a) => (a -> a -> Bool) -> Gen (a, a) -> Property

antisymmetryOnValid :: (Show a, Eq a, GenValidity a) => (a -> a -> Bool) -> Property

antisymmetry :: (Show a, Eq a, GenValidity a) => (a -> a -> Bool) -> Property

antisymmetryOnArbitrary :: (Show a, Eq a, Arbitrary a) => (a -> a -> Bool) -> Property

antisymmetryOnArbitrary ((<=) :: Int -> Int -> Bool)

Symmetry

symmetricOnElems

Arguments

:: (a -> a -> Bool)

A relation

-> a

-> a

Two elements

-> Bool

\[ Symmetric(\prec) \quad\equiv\quad \forall a, b: (a \prec b) \Leftrightarrow (b \prec a) \]

symmetryOnGens :: Show a => (a -> a -> Bool) -> Gen (a, a) -> Property

symmetryOnValid :: (Show a, GenValidity a) => (a -> a -> Bool) -> Property

symmetry :: (Show a, GenValidity a) => (a -> a -> Bool) -> Property

symmetryOnArbitrary :: (Show a, Arbitrary a) => (a -> a -> Bool) -> Property

symmetryOnArbitrary ((==) :: Int -> Int -> Bool)

Properties of operations

Identity element

Left Identity

leftIdentityOnElemWithEquality

Arguments

:: (b -> a -> a)

A binary operation

-> (a -> a -> Bool)

An equality

-> b

A candidate left-identity

-> a

An element

-> Bool

\[ LeftIdentity(\star, \doteq, b) \quad\equiv\quad \forall a: (b \star a) \doteq a \]

leftIdentityOnGenWithEquality

Arguments

:: Show a

=> (b -> a -> a)

A binary operation

-> (a -> a -> Bool)

An equality

-> b

A candidate left-identity

-> Gen a

-> Property

leftIdentityOnGen

Arguments

:: (Show a, Eq a)

=> (b -> a -> a)

A binary operation

-> b

A candidate left-identity

-> Gen a

-> Property

leftIdentityOnValid :: (Show a, Eq a, GenValidity a) => (b -> a -> a) -> b -> Property

leftIdentity :: (Show a, Eq a, GenValidity a) => (b -> a -> a) -> b -> Property

Right Identity

rightIdentityOnElemWithEquality

Arguments

:: (a -> b -> a)

A binary operation

-> (a -> a -> Bool)

An equality

-> b

A candidate right-identity

-> a

An element

-> Bool

\[ RightIdentity(\star, \doteq, b) \quad\equiv\quad \forall a: (a \star b) \doteq a \]

rightIdentityOnGenWithEquality

Arguments

:: Show a

=> (a -> b -> a)

A binary operation

-> (a -> a -> Bool)

An equality

-> b

A candidate right-identity

-> Gen a

-> Property

rightIdentityOnGen

Arguments

:: (Show a, Eq a)

=> (a -> b -> a)

A binary operation

-> b

A candidate right-identity

-> Gen a

-> Property

rightIdentityOnValid :: (Show a, Eq a, GenValidity a) => (a -> b -> a) -> b -> Property

rightIdentity :: (Show a, Eq a, GenValidity a) => (a -> b -> a) -> b -> Property

Identity

identityOnGen :: (Show a, Eq a) => (a -> a -> a) -> a -> Gen a -> Property

identityOnValid :: (Show a, Eq a, GenValidity a) => (a -> a -> a) -> a -> Property

identity :: (Show a, Eq a, GenValidity a) => (a -> a -> a) -> a -> Property

Associativity

associativeOnGens :: (Show a, Eq a) => (a -> a -> a) -> Gen (a, a, a) -> Property

associativeOnValids :: (Show a, Eq a, GenValidity a) => (a -> a -> a) -> Property

associative :: (Show a, Eq a, GenValidity a) => (a -> a -> a) -> Property

associativeOnArbitrary :: (Show a, Eq a, Arbitrary a) => (a -> a -> a) -> Property

Commutativity

commutativeOnGens :: (Show a, Eq a) => (a -> a -> a) -> Gen (a, a) -> Property

commutativeOnValids :: (Show a, Eq a, GenValidity a) => (a -> a -> a) -> Property

commutative :: (Show a, Eq a, GenValidity a) => (a -> a -> a) -> Property

commutativeOnArbitrary :: (Show a, Eq a, Arbitrary a) => (a -> a -> a) -> Property

Eq properties

eqSpec :: (Show a, Eq a, Typeable a, GenValidity a) => Proxy a -> Spec

Ord properties

ordSpec :: (Show a, Eq a, Ord a, Typeable a, GenValidity a) => Proxy a -> Spec