

Safe HaskellSafe-Infered




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



data Enumerate a Source

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.




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).


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 whereSource

A class of functionally enumerable types


enumerate :: Enumerate aSource

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 aSource

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.

nullary :: a -> Constructor aSource

For nullary constructors such as True and [].

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

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 -> cSource

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

consts :: [Constructor a] -> Enumerate aSource

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]Source

Derive an instance of Enumberable with Template Haskell.

newtype FreePair a b Source

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




free :: (a, b)


Accessing data

optimised :: Enumerable a => Enumerate aSource

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 -> aSource






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





Defined as ioAll = ioFeat values


Defined as ioBounded n = ioFeat (bounded n)