| Safe Haskell | None |
|---|
Test.Feat
Description
This module contains a (hopefully) manageable subset of the functionality of Feat. The rest resides only in the Test.Feat.* modules.
- data Enumerate a
- class Typeable a => Enumerable a where
- shared :: Enumerable a => Enumerate a
- nullary :: a -> Constructor a
- unary :: Enumerable a => (a -> b) -> Constructor b
- newtype FreePair a b = Free {
- free :: (a, b)
- funcurry :: (a -> b -> c) -> FreePair a b -> c
- consts :: [Constructor a] -> Enumerate a
- deriveEnumerable :: Name -> Q [Dec]
- optimal :: Enumerable a => Enumerate a
- index :: Enumerable a => Integer -> a
- select :: Enumerable a => Int -> Index -> a
- values :: Enumerable a => [(Integer, [a])]
- bounded :: Enumerable a => Integer -> [(Integer, [a])]
- uniform :: Enumerable a => Int -> Gen a
- featCheck :: (Enumerable a, Show a) => Int -> (a -> Bool) -> IO ()
- ioFeat :: [(Integer, [a])] -> Report a -> IO ()
- ioAll :: Enumerable a => Int -> Report a -> IO ()
- ioBounded :: Enumerable a => Integer -> Int -> Report a -> IO ()
- type Report a = a -> IO ()
- inputRep :: Show a => (a -> Bool) -> Report a
Documentation
A functional enumeration of type t is a partition of
t into finite numbered sets called Parts. Each parts contains values
of a certain cost (typically the size of the value).
The type class
class Typeable a => Enumerable a whereSource
A class of functionally enumerable types
Methods
Instances
shared :: Enumerable a => Enumerate aSource
Version of enumerate that ensures that the enumeration is shared
between all accesses. Should always be used when
combining enumerations.
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).
A free pair constructor. The cost of constructing a free pair is equal to the sum of the costs of its components.
Instances
| Typeable2 FreePair | |
| (Show a, Show b) => Show (FreePair a b) | |
| (Enumerable a, Enumerable b) => Enumerable (FreePair a b) |
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.
Automatic derivation
deriveEnumerable :: Name -> Q [Dec]Source
Derive an instance of Enumberable with Template Haskell. To derive
an instance for Enumerable A, just put this as a top level declaration
in your module (with the TemplateHaskell extension enabled):
deriveEnumerable ''A
Accessing data
optimal :: Enumerable a => Enumerate aSource
An optimal version of enumerate. Used by all
library functions that access enumerated values (but not
by combining functions). Library functions should ensure that
optimal is not reevaluated.
index :: Enumerable a => Integer -> aSource
Mainly as a proof of concept we define a function to index into an enumeration. (If this is repeated multiple times it might be very inefficient, depending on whether the dictionary for the Enumerable is shared or not.)
select :: Enumerable a => Int -> Index -> aSource
A more fine grained version of index that takes a size and an
index into the values of that size. select p i is only defined for i
values :: Enumerable a => [(Integer, [a])]Source
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])]Source
A version of values with a limited number of values in each inner list. If the list corresponds to a Part which is larger than the bound it evenly distributes the values across the enumeration of the Part.
uniform :: Enumerable a => Int -> Gen aSource
Compatibility with QuickCheck. Distribution is uniform generator over
values bounded by the given size. Typical use: sized uniform.
Testing drivers
ioFeat :: [(Integer, [a])] -> Report a -> IO ()Source
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 its progress and the number of tests before each new part.