Test.ClassLaws.Core

The core of ClassLaws are the type families LawArgs, LawBody and Param, tied together by the type class LawTest.

Documentation

type Equal = []

An equality proof is represented as a list of (at least two) equal values.

type Theorem = Equal

A Theorem is a claim that a LHS equals a RHS - an Equal of length two.

(=.=) :: a -> a -> Theorem a

Contructing an equality theorem: lhs =.= rhs = [lhs, rhs].

addSteps :: Theorem a -> Equal a -> Equal a

Take a two-element theorem and an equality proof chain to splice in the middle.

type family LawArgs t

The forall quantified part on the top level of the law

type family LawBody t

The type in the body of the forall

type family Param b

Parameters needed for Equal checking of the body

type Law t = LawArgs t -> Equal (LawBody t)

The Laws we handle are of this form.

class LawTest t where

Class LawTest defines a test method, which returns a testable property, which we can use to test a law for a type t. This class is independent of the actual laws to test - it can be used for Monoid, Monad, ...

Methods

lawtest :: t -> LawArgs t -> Param (LawBody t) -> Property

Instances

(MonadStateLaws s m, TestEqual (m ())) => LawTest (MonadStateGetPut m)

(MonoidLaws a, TestEqual a) => LawTest (MonoidLaw3 a)

(MonoidLaws a, TestEqual a) => LawTest (MonoidLaw2 a)

(MonoidLaws a, TestEqual a) => LawTest (MonoidLaw1 a)

ShowLaws s => LawTest (ShowLaw s)

(MonadPlusLaws m, TestEqual (m a)) => LawTest (MonadPlusLaw5 a m)

(MonadPlusLaws m, TestEqual (m a)) => LawTest (MonadPlusLaw4 a m)

(MonadPlusLaws m, TestEqual (m a)) => LawTest (MonadPlusLaw2 a m)

(MonadPlusLaws m, TestEqual (m a)) => LawTest (MonadPlusLaw1 a m)

(MonadLaws m, TestEqual (m b)) => LawTest (MonadLaw2 b m)

(FunctorLaws f, TestEqual (f a)) => LawTest (FunctorLaw1 a f)

(MonadStateLaws s m, TestEqual (m s)) => LawTest (MonadStatePutGet s m)

(MonadStateLaws s m, TestEqual (m ())) => LawTest (MonadStatePutPut s m)

(MonadPlusLaws m, TestEqual (m b)) => LawTest (MonadPlusLaw3 a b m)

(FunctorMonadLaws m, TestEqual (m b)) => LawTest (FunctorMonadLaw a b m)

(MonadLaws m, TestEqual (m b)) => LawTest (MonadLaw1 a b m)

(MonadStateLaws s m, TestEqual (m a)) => LawTest (MonadStateGetGet s a m)

(MonadLaws m, TestEqual (m d)) => LawTest (MonadLaw3 b c d m)

(FunctorLaws f, TestEqual (f c)) => LawTest (FunctorLaw2 a b c f)

blindlawtest :: LawTest t => t -> Blind (LawArgs t) -> Param (LawBody t) -> Property

Helper function to test laws where arguments lack a Show instance.

partiallawtest :: LawTest t => t -> Partial (LawArgs t -> Param (LawBody t) -> Property)

Helper function to test laws where we should care about partial values.

quickLawCheck :: (Show (LawArgs t), Arbitrary (LawArgs t), Show (Param (LawBody t)), Arbitrary (Param (LawBody t)), LawTest t) => t -> IO ()

Top level use of ClassLaws is often quickLawCheck someLaw

quickFLawCheck :: (Show (Param (LawBody t)), Arbitrary (LawArgs t), Arbitrary (Param (LawBody t)), LawTest t) => t -> IO ()

Variant not needing a Show instance for the LawArgs

quickLawCheckPartial :: (Show (Partial (Param (LawBody t))), Show (Partial (LawArgs t)), ArbitraryPartial (Param (LawBody t)), ArbitraryPartial (LawArgs t), LawTest t) => t -> IO ()

Checking laws in the precense of partial values