testing-feat-0.4.0.2: Functional Enumeration of Algebraic Types

Safe HaskellNone

Test.Feat

Contents

Description

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

Synopsis

Documentation

data Enumerate a Source

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

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 whereSource

A class of functionally enumerable types

Methods

enumerate :: Enumerate aSource

This is the interface for defining an instance. When combining enumerations use shared instead and when accessing the data of enumerations use optimal.

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 a_12 => Enumerable [a_12] 
(Infinite a, Enumerable a) => Enumerable (Ratio a)

Not injective

Enumerable a_a1aW => Enumerable (Maybe a_a1aW) 
(Infinite a, Enumerable a) => Enumerable (NonZero a) 
Infinite a => Enumerable (Nat a) 
Enumerable a => Enumerable (NonEmpty a) 
(Enumerable a_acKx, Enumerable b_acKy) => Enumerable (Either a_acKx b_acKy) 
(Enumerable a_12, Enumerable b_13) => Enumerable (a_12, b_13) 
(Enumerable a, Enumerable b) => Enumerable (FreePair a b) 
(Enumerable a_12, Enumerable b_13, Enumerable c_14) => Enumerable (a_12, b_13, c_14) 
(Enumerable a_12, Enumerable b_13, Enumerable c_14, Enumerable d_15) => Enumerable (a_12, b_13, c_14, d_15) 
(Enumerable a_12, Enumerable b_13, Enumerable c_14, Enumerable d_15, Enumerable e_16) => Enumerable (a_12, b_13, c_14, d_15, e_16) 
(Enumerable a_12, Enumerable b_13, Enumerable c_14, Enumerable d_15, Enumerable e_16, Enumerable f_17) => Enumerable (a_12, b_13, c_14, d_15, e_16, f_17) 
(Enumerable a_12, Enumerable b_13, Enumerable c_14, Enumerable d_15, Enumerable e_16, Enumerable f_17, Enumerable g_18) => Enumerable (a_12, b_13, c_14, d_15, e_16, f_17, g_18) 

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

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.

Constructors

Free 

Fields

free :: (a, b)
 

Instances

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

featCheck :: (Enumerable a, Show a) => Int -> (a -> Bool) -> IO ()Source

Check a property for all values up to a given size. featCheck p prop = ioAll p (inputRep prop)

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.

ioAll :: Enumerable a => Int -> Report a -> IO ()Source

Defined as ioAll p = ioFeat (take p values)

ioBounded :: Enumerable a => Integer -> Int -> Report a -> IO ()Source

Defined as ioBounded n p = ioFeat (take p $ bounded n)

type Report a = a -> IO ()Source

Functions that test a property and reports the result.

inputRep :: Show a => (a -> Bool) -> Report aSource

Reports counterexamples to the given predicate by printing them