Test.Feat

This module contains a (hopefully) manageable subset of the functionality of Feat. The rest resides only in the Test.Feat.* modules.

Documentation

data Enumerate a

A functional enumeration of type t is a partition of t into finite numbered sets called Parts. The number that identifies each part is called the cost of the values in that part.

Constructors

Enumerate

Fields

card :: Part -> Index

Computes the cardinality of a given part.

select :: Part -> Index -> a

Selects a value from the enumeration For select e p i, the index i should be less than card e p

optimal :: Sharing Tag (Enumerate a)

A self-optimising function (mainly for internal use).

Instances

Functor Enumerate

Only use fmap with bijective functions (e.g. data constructors)

Typeable1 Enumerate

Applicative Enumerate

Pure is singleton and <*> corresponds to cartesian product (as with lists)

Monoid (Enumerate a)

The mappend is (disjoint) union

The type class

class Typeable a => Enumerable a where

A class of functionally enumerable types

Methods

enumerate :: Enumerate a

This is the interface for defining an instance. Memoisation needs to be ensured e.g. using mempay but sharing is handled automatically by the default implementation of shared.

shared :: Enumerate a

Version of enumerate that ensures it is shared between all accessing functions. Should always be used when combining enumerations. Should typically be left to default behaviour.

Instances

Enumerable Bool

Enumerable Char

Contains only ASCII characters

Enumerable Double

Not injective

Enumerable Float

Not injective

Enumerable Int

Enumerable Int8

Enumerable Int16

Enumerable Int32

Enumerable Int64

Enumerable Integer

Enumerable Ordering

Enumerable Word

Enumerable Word8

Enumerable Word16

Enumerable Word32

Enumerable Word64

Enumerable ()

Enumerable Printable

Enumerable Unicode

Enumerable a0 => Enumerable [a0]

(Infinite a, Enumerable a) => Enumerable (Ratio a)

Not injective

Enumerable a0 => Enumerable (Maybe a0)

(Infinite a, Enumerable a) => Enumerable (NonZero a)

Infinite a => Enumerable (Nat a)

Enumerable a => Enumerable (NonEmpty a)

(Enumerable a0, Enumerable b0) => Enumerable (Either a0 b0)

(Enumerable a0, Enumerable b0) => Enumerable (a0, b0)

(Enumerable a, Enumerable b) => Enumerable (FreePair a b)

(Enumerable a0, Enumerable b0, Enumerable c0) => Enumerable (a0, b0, c0)

(Enumerable a0, Enumerable b0, Enumerable c0, Enumerable d0) => Enumerable (a0, b0, c0, d0)

(Enumerable a0, Enumerable b0, Enumerable c0, Enumerable d0, Enumerable e0) => Enumerable (a0, b0, c0, d0, e0)

(Enumerable a0, Enumerable b0, Enumerable c0, Enumerable d0, Enumerable e0, Enumerable f0) => Enumerable (a0, b0, c0, d0, e0, f0)

(Enumerable a0, Enumerable b0, Enumerable c0, Enumerable d0, Enumerable e0, Enumerable f0, Enumerable g0) => Enumerable (a0, b0, c0, d0, e0, f0, g0)

nullary :: a -> Constructor a

For nullary constructors such as True and [].

unary :: Enumerable a => (a -> b) -> Constructor b

For any non-nullary constructor. Apply funcurry until the type of the result is unary (i.e. n-1 times where n is the number of fields of the constructor).

funcurry :: (a -> b -> c) -> FreePair a b -> c

Uncurry a function (typically a constructor) to a function on free pairs.

consts :: [Constructor a] -> Enumerate a

Produces the enumeration of a type given the enumerators for each of its constructors. The result of unary should typically not be used directly in an instance even if it only has one constructor. So you should apply consts even in that case.

deriveEnumerable :: Name -> Q [Dec]

Derive an instance of Enumberable with Template Haskell.

newtype FreePair a b

A free pair constructor. The cost of constructing a free pair is equal to the sum of the costs of its components.

Constructors

Free

Fields

free :: (a, b)

Instances

Typeable2 FreePair

(Show a, Show b) => Show (FreePair a b)

(Enumerable a, Enumerable b) => Enumerable (FreePair a b)

Accessing data

optimised :: Enumerable a => Enumerate a

An optimised version of enumerate. Used by all library functions that access enumerated values (but not by combining functions). Library functions should ensure that optimised is not reevaluated.

index :: Enumerate a -> Integer -> a

Mainly as a proof of concept we can use the isomorphism between natural numbers and (Part,Index) pairs to index into a type. May not terminate for finite types. Might be slow the first time it is used with a specific enumeration because cardinalities need to be calculated. The computational complexity (after cardinalities are computed) is a polynomial in the size of the resulting value.

values :: Enumerable a => [(Integer, [a])]

All values of the enumeration by increasing cost (which is the number of constructors for most types). Also contains the cardinality of each list.

bounded :: Enumerable a => Integer -> [(Integer, [a])]

A version of vales that has a limited number of values in each inner list. If the list corresponds to a Part which is larger than the bound it evenly intersperses the values across the enumeration of the Part.

uniform :: Enumerable a => Int -> Gen a

Compatibility with QuickCheck. Distribution is uniform generator over values bounded by the given size. Typical use: sized uniform.

ioFeat :: [(Integer, [a])] -> (a -> IO ()) -> IO ()

A rather simple but general property testing driver. The property is an (funcurried) IO function that both tests and reports the error. The driver goes on forever or until the list is exhausted, reporting the coverage and the number of tests before each new part.

ioAll :: Enumerable a => (a -> IO ()) -> IO ()

Defined as ioAll = ioFeat values

ioBounded :: Enumerable a => Integer -> (a -> IO ()) -> IO ()

Defined as ioBounded n = ioFeat (bounded n)