A demand specification for some function f is itself a function which manipulates demand values for some function's arguments and results

A Spec for f wraps a function which takes, in order:

• a continuation predict which accepts all of f's argument types in order,
• an implicit representation of a demand on f's result (embedded in f's actual result type using special bottom values, see the documentation for Test.StrictCheck.Demand for details), and
• all of f's original arguments in order

The intention is that the Spec will call predict on some set of demands representing the demands it predicts that f will exert on its inputs, given the provided demand on f's outputs.

For example, here is a correct Spec for take:

take_spec :: Spec '[Int, [a]] [a]
take_spec =
 Spec $ \predict d n xs ->
   predict n (if n > length xs then d else d ++ thunk)

See the documentation for Test.StrictCheck.Demand for information about how to manipulate these implicit demand representations when writing Specs, and see the documentation for Test.StrictCheck.Examples.Lists for more examples of writing specifications.

Unwrap a Spec constructor, returning the contained CPS-ed specification

Conceptually, this is the inverse to the Spec constructor, but because Spec is variadic, getSpec . Spec and Spec . getSpec don't typecheck without additional type annotation.

A function can be checked against a specification if it meets the StrictCheck constraint

Check a function to see whether it exactly meets a strictness specification

If the function fails to meet the specification, a counterexample is pretty-printed in a box-drawn diagram illustrating how the specification failed to match the real observed behavior of the function.

The most general function for random strictness testing: all of the more convenient such functions can be derived from this one

Given some function f, this takes as arguments:

• A Args record describing arguments to pass to the underlying QuickCheck engine
• An NP n-ary product of Shrink shrinkers, one for each argument of f
• An NP n-ary product of Gen generators, one for each argument of f
• A Gen generator for strictnesses to be tested
• A predicate on Evaluations: if the Evaluation passes the predicate, it should return Nothing; otherwise, it should return Just some evidence representing the failure (when checking Specs, this evidence comes in the form of a Spec's (incorrect) prediction)
• the function f to be tested

If all tests succeed, (Nothing, result) is returned, where result is the underlying Result type from Test.QuickCheck. If there is a test failure, it also returns Just the failed Evaluation as well as whatever evidence was produced by the predicate.

The default way to generate inputs: via Produce

Newtype allowing us to construct NP n-ary products of shrinkers

The default way to shrink inputs: via shrink (from Test.QuickCheck's Arbitrary typeclass)

A Strictness represents (roughly) how strict a randomly generated function or evaluation context should be

An evaluation context generated with some strictness s (i.e. through evaluationForall) will consume at most s constructors of its input, although it might consume fewer.

The default way to generate random strictnesses: uniformly choose between 1 and the test configuration's size parameter

A snapshot of the observed strictness behavior of a function

An Evaluation contains the inputs at which a function was called, the inputDemands which were induced upon those inputs, and the resultDemand which induced that demand on the inputs.

Given a list of generators for a function's arguments and a generator for random strictnesses (measured in number of constructors evaluated), create a generator for random Evaluations of that function in random contexts

Given a shrinker for each of the arguments of a function, the function itself, and some Evaluation of that function, produce a list of smaller Evaluations of that function

A newtype for wrapping a comparison on demands

This is useful when constructing an NP n-ary product of such comparisons.

Given a list of ways to compare demands, a demand specification, and an evaluation of a particular function, determine if the function met the specification, as decided by the comparisons. If so, return the prediction of the specification.

Checks if a given Evaluation exactly matches the prediction of a given Spec, returning the prediction of that Spec if not

Note: In the case of success this returns Nothing; in the case of failure this returns Just the incorrect prediction.

An n-ary product.

The product is parameterized by a type constructor f and indexed by a type-level list xs. The length of the list determines the number of elements in the product, and if the i-th element of the list is of type x, then the i-th element of the product is of type f x.

The constructor names are chosen to resemble the names of the list constructors.

Two common instantiations of f are the identity functor I and the constant functor K. For I, the product becomes a heterogeneous list, where the type-level list describes the types of its components. For K a, the product becomes a homogeneous list, where the contents of the type-level list are ignored, but its length still specifies the number of elements.

In the context of the SOP approach to generic programming, an n-ary product describes the structure of the arguments of a single data constructor.

Examples:

I 'x'    :* I True  :* Nil  ::  NP I       '[ Char, Bool ]
K 0      :* K 1     :* Nil  ::  NP (K Int) '[ Char, Bool ]
Just 'x' :* Nothing :* Nil  ::  NP Maybe   '[ Char, Bool ]

The identity type functor.

Like Identity, but with a shorter name.

Require a constraint for every element of a list.

If you have a datatype that is indexed over a type-level list, then you can use All to indicate that all elements of that type-level list must satisfy a given constraint.

Example: The constraint

All Eq '[ Int, Bool, Char ]

is equivalent to the constraint

(Eq Int, Eq Bool, Eq Char)

Example: A type signature such as

f :: All Eq xs => NP I xs -> ...

means that f can assume that all elements of the n-ary product satisfy Eq.