A Thunk a is either an a or a Thunk

When we interleave this type into the Shape of some type, we get the type of demands on that type.

Thunk a is isomorphic to a (strict) Maybe a.

A Demand on some type a is the same shape as that original a, but with possible Thunks interleaved into it

A PosDemand is a "strictly positive" demand, i.e. one where the topmost level of the demanded value has definitely been forced

This is the one-level unwrapping of Demand, and is useful to express some invariants in specifications

Pattern synonym to abbreviate demand manipulation: E a = Wrap (Eval a)

Pattern synonym to abbreviate demand manipulation: T = Wrap Thunk

Evaluate some value of type a to the degree specified by the given demand

If the demand and the value diverge (they pick a different side of a sum), evaluation will stop at this point. Usually, evaluateDemand is only called on demands which are known to be structurally-compatible with the accompanying value, although nothing really goes wrong if this is not true.

Shrink a non-zero demand (analogous to QuickCheck's shrink)

While QuickCheck's typical shrink instances reduce the size of a value by slicing off the top-most structure, shrinkDemand reduces the size of a demand by pruning it's deepest leaves. This ensures that all resultant shrunken demands are strict sub-demands of the original.

Pretty-print a demand for display

Print a demand to standard output

printDemand = putStrLn . prettyDemand

Determine if two demands are exactly equal

This relies on the match method from the Shaped instance for the two demands, and does not require the underlying types to have Eq instances. However, this means that types whose match methods are more coarse than their equality will be compared differently by eqDemand. In particular, the demand representations of functions will all be compared to be equal.

A very general showsPrec style function for printing demands

showPrettyFieldThunkS q t p r returns a function (String -> String) which appends its input to a pretty-printed representation of a demand.

Specifically: * q is a boolean flag determining if names should be printed as qualified * t is a string which is to be printed when a thunk is encountered * p is the precedence context of this function call * r is the 'Rendered Thunk' representing some demand

This is very general, but we expose it in its complexity just in case some person wants to build a different pretty-printer.

The precedence-aware pretty-printing algorithm used here is adapted from a solution given by Brian Huffman on StackOverflow: https://stackoverflow.com/questions/27471937/43639618#43639618.

A bottom value (inhabiting all types) which StrictCheck interprets as an unevaluated subpart of a data structure

toDemand thunk  ==  T
fromDemand T    ==  thunk

Tests if a particular value is an implicit thunk

In order to work, this function evaluates its input to weak-head normal form; keep this in mind if you care about laziness.

Given an a whose substructures may contain thunks (i.e. an implicit demand representation), convert it to an explicit Demand

Inverse to fromDemand.

Given an explicit Demand for some type a, convert it to a value of type a, substituting a thunk for each T found in the explicit demand

Inverse to toDemand.