Test.QuickSpec.Prelude

The "prelude": a standard signature containing useful functions like ++, which can be used as background theory.

Documentation

newtype A

Just a type. You can instantiate your polymorphic functions at this type to include them in a signature.

Constructors

A Int

Instances

Eq A

Ord A

Show A

Typeable A

Arbitrary A

CoArbitrary A

Partial A

newtype B

Constructors

B Int

Instances

Eq B

Ord B

Show B

Typeable B

Arbitrary B

CoArbitrary B

Partial B

newtype C

Constructors

C Int

Instances

Eq C

Ord C

Show C

Typeable C

Arbitrary C

CoArbitrary C

Partial C

data Two

A type with two elements. Use this instead of A if testing doesn't work well because the domain of A is too large.

Constructors

One

Two

Instances

Eq Two

Ord Two

Show Two

Typeable Two

Arbitrary Two

CoArbitrary Two

bools :: Sig

A signature containing boolean functions: (||), (&&), not, True, False.

arith :: forall a. (Typeable a, Ord a, Num a, Arbitrary a) => a -> Sig

A signature containing arithmetic operations: 0, 1, (+), (*). Instantiate it with e.g. arith (undefined :: Int).

lists :: forall a. (Typeable a, Ord a, Arbitrary a) => a -> Sig

A signature containing list operations: [], (:), head, tail, (++). Instantiate it with e.g. lists (undefined :: A).

funs :: forall a. (Typeable a, Ord a, Arbitrary a, CoArbitrary a) => a -> Sig

A signature containing higher-order functions: (.), id, and some function variables. Useful for testing map.

prelude :: (Typeable a, Ord a, Arbitrary a) => a -> Sig

The QuickSpec prelude. Contains boolean, arithmetic and list functions, and some variables. Instantiate it as e.g. prelude (undefined :: A). For more precise control over what gets included, see bools, arith, lists, funs and without.