Test.StrictCheck.Consume

This module defines the Consume typeclass, used for incrementally destructing inputs to random non-strict functions.

Calling consume on some value lazily returns an abstract type of Input, which contains all the entropy present in the original value. Paired with Produce, these Input values can be used to generate random non-strict functions, whose strictness behavior is dependent on the values given to them.

Incrementally consuming input

data Input

A tree representing all possible destruction sequences for a value Unfolding the contained lists forces a particular random control path for destructing the datatype.

data Inputs

A list of inputs given to a function, in abstract form. This lazy structure is evaluated piecewise during the course of producing a function, thus triggering the partial evaluation of the original input to the function.

class Consume a where

Lazily monomorphize some input value, by converting it into an Input. This is an incremental version of QuickCheck's CoArbitrary typeclass. It can also be seen as a generalization of the NFData class.

Instances of Consume can be derived automatically for any type implementing the Generic class from GHC.Generics. Using the DeriveAnyClass extension, we can say:

import GHC.Generics as GHC
import Generics.SOP as SOP

data D x y
  = A
  | B (x, y)
  deriving (GHC.Generic, SOP.Generic, Consume)

This automatic derivation follows these rules, which you can follow too if you're manually writing an instance for some type which is not Generic:

For each distinct constructor, make a single call to constructor with a distinct Int, and a list of Inputs, each created by recursively calling consume on every field in that constructor. For abstract types (e.g. sets), the same procedure can be used upon an extracted list representation of the contents.

Methods

consume :: a -> Input

Convert an a into an Input by recursively destructing it using calls to consume

consume :: GConsume a => a -> Input

Convert an a into an Input by recursively destructing it using calls to consume

Instances

Consume Bool

Methods

consume :: Bool -> Input

Consume Char

Methods

consume :: Char -> Input

Consume Double

Methods

consume :: Double -> Input

Consume Float

Methods

consume :: Float -> Input

Consume Int

Methods

consume :: Int -> Input

Consume Integer

Methods

consume :: Integer -> Input

Consume Ordering

Methods

consume :: Ordering -> Input

Consume Rational

Methods

consume :: Rational -> Input

Consume Word

Methods

consume :: Word -> Input

Consume ()

Methods

consume :: () -> Input

Consume IntSet

Methods

consume :: IntSet -> Input

Consume Key

Methods

consume :: Key -> Input

Consume a => Consume [a]

Methods

consume :: [a] -> Input

Consume a => Consume (Maybe a)

Methods

consume :: Maybe a -> Input

(CoArbitrary a, RealFloat a) => Consume (Complex a)

Methods

consume :: Complex a -> Input

Consume a => Consume (NonEmpty a)

Methods

consume :: NonEmpty a -> Input

Consume v => Consume (IntMap v)

Methods

consume :: IntMap v -> Input

Consume a => Consume (Tree a)

Methods

consume :: Tree a -> Input

Consume v => Consume (Seq v)

Methods

consume :: Seq v -> Input

Consume v => Consume (Set v)

Methods

consume :: Set v -> Input

Consume (a -> b)

Methods

consume :: (a -> b) -> Input

(Consume a, Consume b) => Consume (Either a b)

Methods

consume :: Either a b -> Input

(Consume a, Consume b) => Consume (a, b)

Methods

consume :: (a, b) -> Input

Consume (Proxy k p)

Methods

consume :: Proxy k p -> Input

Consume v => Consume (Map k v)

Methods

consume :: Map k v -> Input

(Consume v, Consume k) => Consume (Map k v)

Methods

consume :: Map k v -> Input

(Consume a, Consume b, Consume c) => Consume (a, b, c)

Methods

consume :: (a, b, c) -> Input

(Consume a, Consume b, Consume c, Consume d) => Consume (a, b, c, d)

Methods

consume :: (a, b, c, d) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e) => Consume (a, b, c, d, e)

Methods

consume :: (a, b, c, d, e) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f) => Consume (a, b, c, d, e, f)

Methods

consume :: (a, b, c, d, e, f) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g) => Consume (a, b, c, d, e, f, g)

Methods

consume :: (a, b, c, d, e, f, g) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h) => Consume (a, b, c, d, e, f, g, h)

Methods

consume :: (a, b, c, d, e, f, g, h) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i) => Consume (a, b, c, d, e, f, g, h, i)

Methods

consume :: (a, b, c, d, e, f, g, h, i) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j) => Consume (a, b, c, d, e, f, g, h, i, j)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k) => Consume (a, b, c, d, e, f, g, h, i, j, k)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l) => Consume (a, b, c, d, e, f, g, h, i, j, k, l)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t, Consume u) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t, Consume u, Consume v) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t, Consume u, Consume v, Consume w) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t, Consume u, Consume v, Consume w, Consume x) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t, Consume u, Consume v, Consume w, Consume x, Consume y) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) -> Input

(Consume a, Consume b, Consume c, Consume d, Consume e, Consume f, Consume g, Consume h, Consume i, Consume j, Consume k, Consume l, Consume m, Consume n, Consume o, Consume p, Consume q, Consume r, Consume s, Consume t, Consume u, Consume v, Consume w, Consume x, Consume y, Consume z) => Consume (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)

Methods

consume :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) -> Input

Manually writing Consume instances

constructor :: Int -> [Input] -> Input

Reassemble pieces of input into a larger Input: this is to be called on the result of consume-ing subparts of input

normalize :: Consume a => a -> ()

Fully normalize something which can be consumed

consumeTrivial :: a -> Input

Consume a type which has no observable structure whatsoever

This should only be used for types for which there is only one inhabitant, or for which inhabitants cannot be distinguished at all.

consumePrimitive :: CoArbitrary a => a -> Input

Use the CoArbitrary instance for a type to consume it

This should only be used for "flat" types, i.e. those which contain no interesting consumable substructure, as it's fully strict (non-incremental)

Generically deriving Consume instances

type GConsume a = (Generic a, All2 Consume (Code a))

The constraints necessary to generically consume something

gConsume :: GConsume a => a -> Input

Generic consume