NoThunks.Class

Check a value for unexpected thunks

class NoThunks a where

Check a value for unexpected thunks

Minimal complete definition

Nothing

Methods

noThunks :: Context -> a -> IO (Maybe ThunkInfo)

Check if the argument does not contain any unexpected thunks

For most datatypes, we should have that

noThunks ctxt x == Nothing

if and only if

checkContainsThunks x

For some datatypes however, some thunks are expected. For example, the internal fingertree Sequence might contain thunks (this is important for the asymptotic complexity of this data structure). However, we should still check that the values in the sequence don't contain any unexpected thunks.

This means that we need to traverse the sequence, which might force some of the thunks in the tree. In general, it is acceptable for noThunks to force such "expected thunks", as long as it always reports the unexpected thunks.

The default implementation of noThunks checks that the argument is in WHNF, and if so, adds the type into the context (using showTypeOf or whereFrom if available), and calls wNoThunks. See ThunkInfo for a detailed discussion of the type context.

See also discussion of caveats listed for checkContainsThunks.

wNoThunks :: Context -> a -> IO (Maybe ThunkInfo)

Check that the argument is in normal form, assuming it is in WHNF.

The context will already have been extended with the type we're looking at, so all that's left is to look at the thunks inside the type. The default implementation uses GHC Generics to do this.

default wNoThunks :: (Generic a, GWNoThunks '[] (Rep a)) => Context -> a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy a -> String

Show type a (to add to the context)

We try hard to avoid Typeable constraints in this module: there are types with no Typeable instance but with a NoThunks instance (most important example are types such as ST s which rely on parametric polymorphism). By default we should therefore only show the "outer layer"; for example, if we have a type

Seq (ST s ())

then showTypeOf should just give Seq, leaving it up to the instance for ST to decide how to implement showTypeOf; this keeps things compositional. The default implementation does precisely this using the metadata that GHC Generics provides.

For convenience, however, some of the deriving via newtype wrappers we provide do depend on Typeable; see below.

default showTypeOf :: (Generic a, GShowTypeOf (Rep a)) => Proxy a -> String

Instances

NoThunks All

Defined in NoThunks.Class

Methods

noThunks :: Context -> All -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> All -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy All -> String

NoThunks Any

Defined in NoThunks.Class

Methods

noThunks :: Context -> Any -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Any -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Any -> String

NoThunks Void

Defined in NoThunks.Class

Methods

noThunks :: Context -> Void -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Void -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Void -> String

NoThunks ThreadId

Defined in NoThunks.Class

Methods

noThunks :: Context -> ThreadId -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> ThreadId -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy ThreadId -> String

NoThunks Int16

Defined in NoThunks.Class

Methods

noThunks :: Context -> Int16 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Int16 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Int16 -> String

NoThunks Int32

Defined in NoThunks.Class

Methods

noThunks :: Context -> Int32 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Int32 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Int32 -> String

NoThunks Int64

Defined in NoThunks.Class

Methods

noThunks :: Context -> Int64 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Int64 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Int64 -> String

NoThunks Int8

Defined in NoThunks.Class

Methods

noThunks :: Context -> Int8 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Int8 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Int8 -> String

NoThunks CallStack

Since CallStacks can't retain application data, we don't want to check them for thunks at all

Defined in NoThunks.Class

Methods

noThunks :: Context -> CallStack -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> CallStack -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy CallStack -> String

NoThunks Word16

Defined in NoThunks.Class

Methods

noThunks :: Context -> Word16 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Word16 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Word16 -> String

NoThunks Word32

Defined in NoThunks.Class

Methods

noThunks :: Context -> Word32 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Word32 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Word32 -> String

NoThunks Word64

Defined in NoThunks.Class

Methods

noThunks :: Context -> Word64 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Word64 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Word64 -> String

NoThunks Word8

Defined in NoThunks.Class

Methods

noThunks :: Context -> Word8 -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Word8 -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Word8 -> String

NoThunks ByteString

Instance for string bytestrings

Strict bytestrings shouldn't contain any thunks, but could, due to https://gitlab.haskell.org/ghc/ghc/issues/17290. However, such thunks can't retain any data that they shouldn't, and so it's safe to ignore such thunks.

Defined in NoThunks.Class

Methods

noThunks :: Context -> ByteString -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> ByteString -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy ByteString -> String

NoThunks ByteString

Instance for lazy bytestrings

Defined manually so that it piggy-backs on the one for strict bytestrings.

Defined in NoThunks.Class

Methods

noThunks :: Context -> ByteString -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> ByteString -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy ByteString -> String

NoThunks ShortByteString

Instance for short bytestrings

We have

data ShortByteString = SBS ByteArray#

Values of this type consist of a tag followed by an _unboxed_ byte array, which can't contain thunks. Therefore we only check WHNF.

Defined in NoThunks.Class

Methods

noThunks :: Context -> ShortByteString -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> ShortByteString -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy ShortByteString -> String

NoThunks Text

Defined in NoThunks.Class

Methods

noThunks :: Context -> Text -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Text -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Text -> String

NoThunks Text

Defined in NoThunks.Class

Methods

noThunks :: Context -> Text -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Text -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Text -> String

NoThunks Day

Defined in NoThunks.Class

Methods

noThunks :: Context -> Day -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Day -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Day -> String

NoThunks DiffTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> DiffTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> DiffTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy DiffTime -> String

NoThunks NominalDiffTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> NominalDiffTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> NominalDiffTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy NominalDiffTime -> String

NoThunks UTCTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> UTCTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> UTCTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy UTCTime -> String

NoThunks UniversalTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> UniversalTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> UniversalTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy UniversalTime -> String

NoThunks TimeLocale

Defined in NoThunks.Class

Methods

noThunks :: Context -> TimeLocale -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> TimeLocale -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy TimeLocale -> String

NoThunks LocalTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> LocalTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> LocalTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy LocalTime -> String

NoThunks TimeOfDay

Defined in NoThunks.Class

Methods

noThunks :: Context -> TimeOfDay -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> TimeOfDay -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy TimeOfDay -> String

NoThunks TimeZone

Defined in NoThunks.Class

Methods

noThunks :: Context -> TimeZone -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> TimeZone -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy TimeZone -> String

NoThunks ZonedTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> ZonedTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> ZonedTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy ZonedTime -> String

NoThunks Integer

Defined in NoThunks.Class

Methods

noThunks :: Context -> Integer -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Integer -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Integer -> String

NoThunks Natural

Defined in NoThunks.Class

Methods

noThunks :: Context -> Natural -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Natural -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Natural -> String

NoThunks ()

Defined in NoThunks.Class

Methods

noThunks :: Context -> () -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> () -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy () -> String

NoThunks Bool

Defined in NoThunks.Class

Methods

noThunks :: Context -> Bool -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Bool -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Bool -> String

NoThunks Char

Defined in NoThunks.Class

Methods

noThunks :: Context -> Char -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Char -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Char -> String

NoThunks Double

Defined in NoThunks.Class

Methods

noThunks :: Context -> Double -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Double -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Double -> String

NoThunks Float

Defined in NoThunks.Class

Methods

noThunks :: Context -> Float -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Float -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Float -> String

NoThunks Int

Defined in NoThunks.Class

Methods

noThunks :: Context -> Int -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Int -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Int -> String

NoThunks Word

Defined in NoThunks.Class

Methods

noThunks :: Context -> Word -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Word -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy Word -> String

NoThunks a => NoThunks (Identity a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Identity a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Identity a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Identity a) -> String

NoThunks a => NoThunks (First a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> First a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> First a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (First a) -> String

NoThunks a => NoThunks (Last a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Last a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Last a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Last a) -> String

NoThunks a => NoThunks (First a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> First a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> First a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (First a) -> String

NoThunks a => NoThunks (Last a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Last a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Last a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Last a) -> String

NoThunks a => NoThunks (Max a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Max a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Max a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Max a) -> String

NoThunks a => NoThunks (Min a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Min a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Min a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Min a) -> String

NoThunks a => NoThunks (WrappedMonoid a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> WrappedMonoid a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> WrappedMonoid a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (WrappedMonoid a) -> String

NoThunks a => NoThunks (Dual a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Dual a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Dual a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Dual a) -> String

NoThunks a => NoThunks (Product a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Product a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Product a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Product a) -> String

NoThunks a => NoThunks (Sum a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Sum a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Sum a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Sum a) -> String

NoThunks a => NoThunks (NonEmpty a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> NonEmpty a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> NonEmpty a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (NonEmpty a) -> String

NoThunks a => NoThunks (TVar a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> TVar a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> TVar a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (TVar a) -> String

NoThunks a => NoThunks (IORef a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> IORef a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> IORef a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (IORef a) -> String

NoThunks a => NoThunks (MVar a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> MVar a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> MVar a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (MVar a) -> String

NoThunks a => NoThunks (Ratio a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Ratio a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Ratio a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Ratio a) -> String

NoThunks a => NoThunks (IntMap a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> IntMap a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> IntMap a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (IntMap a) -> String

NoThunks a => NoThunks (Seq a)

Instance for Seq checks elements only

The internal fingertree in Seq might have thunks, which is essential for its asymptotic complexity.

Defined in NoThunks.Class

Methods

noThunks :: Context -> Seq a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Seq a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Seq a) -> String

NoThunks a => NoThunks (Set a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Set a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Set a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Set a) -> String

NoThunks (IO a)

We do not check IO actions for captured thunks by default

See instance for (a -> b) for detailed discussion.

Defined in NoThunks.Class

Methods

noThunks :: Context -> IO a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> IO a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (IO a) -> String

NoThunks (AllowThunk a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> AllowThunk a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> AllowThunk a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (AllowThunk a) -> String

Typeable a => NoThunks (InspectHeap a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> InspectHeap a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> InspectHeap a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (InspectHeap a) -> String

Typeable a => NoThunks (OnlyCheckWhnf a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> OnlyCheckWhnf a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> OnlyCheckWhnf a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (OnlyCheckWhnf a) -> String

NoThunks a => NoThunks (Vector a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Vector a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Vector a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Vector a) -> String

NoThunks (Vector a)

Unboxed vectors can't contain thunks

Implementation note: defined manually rather than using OnlyCheckWhnf due to ghc limitation in deriving via, making it impossible to use with it with data families.

Defined in NoThunks.Class

Methods

noThunks :: Context -> Vector a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Vector a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Vector a) -> String

NoThunks a => NoThunks (Maybe a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Maybe a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Maybe a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Maybe a) -> String

NoThunks a => NoThunks (a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a) -> String

NoThunks a => NoThunks [a]

Defined in NoThunks.Class

Methods

noThunks :: Context -> [a] -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> [a] -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy [a] -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> Either a b -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Either a b -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Either a b) -> String

(NoThunks a, NoThunks b) => NoThunks (Arg a b)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Arg a b -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Arg a b -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Arg a b) -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> Map k v -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Map k v -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Map k v) -> String

(HasFields s a, Generic a, Typeable a, GWNoThunks s (Rep a)) => NoThunks (AllowThunksIn s a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> AllowThunksIn s a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> AllowThunksIn s a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (AllowThunksIn s a) -> String

KnownSymbol name => NoThunks (InspectHeapNamed name a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> InspectHeapNamed name a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> InspectHeapNamed name a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (InspectHeapNamed name a) -> String

KnownSymbol name => NoThunks (OnlyCheckWhnfNamed name a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> OnlyCheckWhnfNamed name a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> OnlyCheckWhnfNamed name a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (OnlyCheckWhnfNamed name a) -> String

(NoThunks a, NoThunks b) => NoThunks (a, b)

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a, b) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a, b) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a, b) -> String

NoThunks (a -> b)

We do NOT check function closures for captured thunks by default

Since we have no type information about the values captured in a thunk, the only check we could possibly do is checkContainsThunks: we can't recursively call noThunks on those captured values, which is problematic if any of those captured values requires a custom instance (for example, data types that depend on laziness, such as Seq).

By default we therefore only check if the function is in WHNF, and don't check the captured values at all. If you want a stronger check, you can use InspectHeap (a -> b) instead.

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a -> b) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a -> b) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a -> b) -> String

NoThunks (f a) => NoThunks (Ap f a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Ap f a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Ap f a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Ap f a) -> String

NoThunks (f a) => NoThunks (Alt f a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> Alt f a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> Alt f a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (Alt f a) -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a, b, c) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a, b, c) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a, b, c) -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a, b, c, d) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a, b, c, d) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a, b, c, d) -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a, b, c, d, e) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a, b, c, d, e) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a, b, c, d, e) -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a, b, c, d, e, f) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a, b, c, d, e, f) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a, b, c, d, e, f) -> String

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

Defined in NoThunks.Class

Methods

noThunks :: Context -> (a, b, c, d, e, f, g) -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> (a, b, c, d, e, f, g) -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (a, b, c, d, e, f, g) -> String

newtype ThunkInfo

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 `[]`.

Constructors

ThunkInfo

Fields

• thunkInfo :: Either Context Info

Instances

Show ThunkInfo

Defined in NoThunks.Class

Methods

showsPrec :: Int -> ThunkInfo -> ShowS

show :: ThunkInfo -> String

showList :: [ThunkInfo] -> ShowS

type Context = [String]

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.

type Info = String

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

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

unsafeNoThunks :: NoThunks a => a -> Maybe ThunkInfo

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

Helpers for defining instances

allNoThunks :: [IO (Maybe ThunkInfo)] -> IO (Maybe ThunkInfo)

Short-circuit a list of checks

noThunksInValues :: NoThunks a => Context -> [a] -> IO (Maybe ThunkInfo)

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

noThunksInKeysAndValues :: (NoThunks k, NoThunks v) => Context -> [(k, v)] -> IO (Maybe ThunkInfo)

Variant on noThunksInValues for keyed containers.

Neither the list nor the tuples are checked for thunks.

Deriving-via wrappers

newtype OnlyCheckWhnf a

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

Constructors

OnlyCheckWhnf a

Instances

Typeable a => NoThunks (OnlyCheckWhnf a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> OnlyCheckWhnf a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> OnlyCheckWhnf a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (OnlyCheckWhnf a) -> String

newtype OnlyCheckWhnfNamed (name :: Symbol) a

Variant on OnlyCheckWhnf that does not depend on Generic

Example:

deriving via OnlyCheckWhnfNamed "T" T instance NoThunks T

Constructors

OnlyCheckWhnfNamed a

Instances

KnownSymbol name => NoThunks (OnlyCheckWhnfNamed name a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> OnlyCheckWhnfNamed name a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> OnlyCheckWhnfNamed name a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (OnlyCheckWhnfNamed name a) -> String

newtype InspectHeap a

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

Constructors

InspectHeap a

Instances

Typeable a => NoThunks (InspectHeap a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> InspectHeap a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> InspectHeap a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (InspectHeap a) -> String

newtype InspectHeapNamed (name :: Symbol) a

Variant on InspectHeap that does not depend on Typeable.

deriving via InspectHeapNamed "T" T instance NoUnexpecedThunks T

Constructors

InspectHeapNamed a

Instances

KnownSymbol name => NoThunks (InspectHeapNamed name a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> InspectHeapNamed name a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> InspectHeapNamed name a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (InspectHeapNamed name a) -> String

newtype AllowThunk a

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.

Constructors

AllowThunk a

Instances

NoThunks (AllowThunk a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> AllowThunk a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> AllowThunk a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (AllowThunk a) -> String

newtype AllowThunksIn (fields :: [Symbol]) a

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.

Constructors

AllowThunksIn a

Instances

(HasFields s a, Generic a, Typeable a, GWNoThunks s (Rep a)) => NoThunks (AllowThunksIn s a)

Defined in NoThunks.Class

Methods

noThunks :: Context -> AllowThunksIn s a -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> AllowThunksIn s a -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy (AllowThunksIn s a) -> String

Generic class

class GWNoThunks (a :: [Symbol]) f where

Generic infrastructure for checking for unexpected thunks

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

Methods

gwNoThunks :: proxy a -> Context -> f x -> IO (Maybe ThunkInfo)

Check that the argument does not contain any unexpected thunks

Precondition: the argument is in WHNF.

Instances

GWNoThunks a (U1 :: Type -> Type)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> U1 x -> IO (Maybe ThunkInfo)

GWNoThunks a (V1 :: Type -> Type)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> V1 x -> IO (Maybe ThunkInfo)

(GWNoThunks a f, GWNoThunks a g) => GWNoThunks a (f :*: g)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> (f :*: g) x -> IO (Maybe ThunkInfo)

(GWNoThunks a f, GWNoThunks a g) => GWNoThunks a (f :+: g)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> (f :+: g) x -> IO (Maybe ThunkInfo)

GWNoThunks a f => GWNoThunks a (C1 c f)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> C1 c f x -> IO (Maybe ThunkInfo)

GWNoThunks a f => GWNoThunks a (D1 c f)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> D1 c f x -> IO (Maybe ThunkInfo)

NoThunks c => GWNoThunks a (K1 i c :: Type -> Type)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> K1 i c x -> IO (Maybe ThunkInfo)

(GWRecordField f (Elem fieldName a), KnownSymbol fieldName) => GWNoThunks a (S1 ('MetaSel ('Just fieldName) su ss ds) f)

If fieldName is allowed to contain thunks, skip it.

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> S1 ('MetaSel ('Just fieldName) su ss ds) f x -> IO (Maybe ThunkInfo)

GWNoThunks a f => GWNoThunks a (S1 ('MetaSel ('Nothing :: Maybe Symbol) su ss ds) f)

Defined in NoThunks.Class

Methods

gwNoThunks :: proxy a -> Context -> S1 ('MetaSel 'Nothing su ss ds) f x -> IO (Maybe ThunkInfo)