NoThunks.Class

Check a value for unexpected thunks

Information about unexpected thunks

ThunkInfo contains either precise Info about the thunk location or Context to make it easier to debug space leaks. Info is available if

• GHC-9.4 or newer is used,

• the code is compiled with -finfo-table-map and is improved if -fdistinct-constructor-tables is used as well.

The Context argument is intended to give a clue to add debugging. For example, suppose we have something of type (Int, [Int]). The various contexts we might get are

Context                  The thunk is..
---------------------------------------------------------------------
["(,)"]                  the pair itself
["Int","(,)"]            the Int in the pair
["List","(,)"]           the [Int] in the pair
["Int","List","(,)"]     an Int in the [Int] in the pair

Note: prior to `ghc-9.6` a list was indicated by `[]`.

Construct ThunkInfo either from Context or information provided by GHC about a (see whereFrom).

Context where a thunk was found

This is intended to give a hint about which thunk was found. For example, a thunk might be reported with context

["Int", "(,)", "Map", "AppState"]

telling you that you have an AppState containing a Map containing a pair, all of which weren't thunks (were in WHNF), but that pair contained an Int which was a thunk.

Binding name, type and location information about the thunk, e.g.

fromModel :: Int @ test/Test/NoThunks/Class.hs:198:53-84

Call noThunks in a pure context (relies on unsafePerformIO).

Short-circuit a list of checks

Check that all elements in the list are thunk-free

Does not check the list itself. Useful for checking the elements of a container.

See also noThunksInKeysAndValues

Variant on noThunksInValues for keyed containers.

Neither the list nor the tuples are checked for thunks.

Newtype wrapper for use with deriving via to check for WHNF only

For some types we don't want to check for nested thunks, and we only want check if the argument is in WHNF, not in NF. A typical example are functions; see the instance of (a -> b) for detailed discussion. This should be used sparingly.

Example:

deriving via OnlyCheckWhnf T instance NoThunks T

Variant on OnlyCheckWhnf that does not depend on Generic

Example:

deriving via OnlyCheckWhnfNamed "T" T instance NoThunks T

Newtype wrapper for use with deriving via to inspect the heap directly

This bypasses the class instances altogether, and inspects the GHC heap directly, checking that the value does not contain any thunks anywhere. Since we can do this without any type classes instances, this is useful for types that contain fields for which NoThunks instances are not available.

Since the primary use case for InspectHeap then is to give instances for NoThunks from third party libraries, we also don't want to rely on a Generic instance, which may likewise not be available. Instead, we will rely on Typeable, which is available for all types. However, as showTypeOf explains, requiring Typeable may not always be suitable; if it isn't, InspectHeapNamed can be used.

Example:

deriving via InspectHeap T instance NoThunks T

Variant on InspectHeap that does not depend on Typeable.

deriving via InspectHeapNamed "T" T instance NoUnexpecedThunks T

Newtype wrapper for values that should be allowed to be a thunk

This should be used VERY sparingly, and should ONLY be used on values (or, even rarer, types) which you are SURE cannot retain any data that they shouldn't. Bear in mind allowing a value of type T to be a thunk might cause a value of type S to be retained if T was computed from S.

Newtype wrapper for records where some of the fields are allowed to be thunks.

Example:

deriving via AllowThunksIn '["foo","bar"] T instance NoThunks T

This will create an instance that skips the thunk checks for the "foo" and "bar" fields.

Generic infrastructure for checking for unexpected thunks

The a argument records which record fields are allowed to contain thunks; see AllowThunksIn and GWRecordField, below.