h*(&+      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy0.2.0 Safe-Inferred'16=%"znothunksCheck that type a! has all record fields listed in s9This exists to catch mismatches between the arguments to  and the fields of a record. If any of the symbols is not the name of a field then this constraint won't be satisfied.nothunks9Generic infrastructure for checking for unexpected thunksThe a argument records which record fields are allowed to contain thunks; see  and {, below.nothunks>Check that the argument does not contain any unexpected thunks&Precondition: the argument is in WHNF.nothunks Variant on  that does not depend on |. deriving via InspectHeapNamed "T" T instance NoUnexpecedThunks TnothunksNewtype wrapper for use with  deriving via to inspect the heap directlyThis 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  instances are not available.Since the primary use case for  then is to give instances for > from third party libraries, we also don't want to rely on a } instance, which may likewise not be available. Instead, we will rely on |, which is available for all types. However, as  explains, requiring |+ may not always be suitable; if it isn't,  can be used.Example: .deriving via InspectHeap T instance NoThunks TnothunksNewtype wrapper for records where some of the fields are allowed to be thunks.Example: ?deriving via AllowThunksIn '["foo","bar"] T instance NoThunks TThis will create an instance that skips the thunk checks for the "foo" and "bar" fields.nothunks?Newtype wrapper for values that should be allowed to be a thunkThis 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. nothunks Variant on   that does not depend on }Example: 9deriving via OnlyCheckWhnfNamed "T" T instance NoThunks T nothunksNewtype wrapper for use with  deriving via to check for WHNF onlyFor 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)9 for detailed discussion. This should be used sparingly.Example: 0deriving via OnlyCheckWhnf T instance NoThunks Tnothunks#Information about unexpected thunks"ThunkInfo contains either precise  about the thunk location or * to make it easier to debug space leaks.  is available ifGHC-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 pair6Note: prior to `ghc-9.6` a list was indicated by `[]`.nothunksBinding name, type and location information about the thunk, e.g. 8fromModel :: Int @ test/Test/NoThunks/Class.hs:198:53-84nothunksContext where a thunk was foundThis 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.nothunks#Check a value for unexpected thunksnothunksIs the argument a thunk, or does it (recursively) contain any?nothunksCheck if the given  is a thunk.-Indirections are not considered to be thunks.#nothunksIf the field is allowed to contain thunks, don't check anything.&nothunks Instance for  checks elements onlyThe internal fingertree in  might have thunks, which is essential for its asymptotic complexity.'nothunks$Unboxed vectors can't contain thunks8Implementation note: defined manually rather than using   due to ghc limitation in deriving via, making it impossible to use with it with data families.:nothunksInstance for lazy bytestringsDefined manually so that it piggy-backs on the one for strict bytestrings.FnothunksIf  fieldName' is allowed to contain thunks, skip it.KnothunksSince CallStacks can't retain application data, we don't want to check them for thunks at allLnothunks9We do not check IO actions for captured thunks by defaultSee instance for (a -> b) for detailed discussion.MnothunksWe do NOT check function closures for captured thunks by defaultSince we have no type information about the values captured in a thunk, the only check we could possibly do is : we can't recursively call  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 ).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  (a -> b) instead.PnothunksInstance for short bytestringsWe 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.QnothunksInstance for string bytestringsStrict 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.               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|z}~zz$nothunks-0.2.0-KgiALe7av1OqUPrbWn6ugNoThunks.Classnothunks Data.SequenceSequence GWNoThunks gwNoThunksInspectHeapNamed InspectHeap AllowThunksIn AllowThunkOnlyCheckWhnfNamed OnlyCheckWhnf ThunkInfo thunkInfoInfoContextNoThunksnoThunks wNoThunks showTypeOfunsafeNoThunks allNoThunksnoThunksInValuesnoThunksInKeysAndValues$fGWNoThunksaV1$fGWNoThunksaU1$fGWNoThunksa:+:$fGWNoThunksa:*:$fGWNoThunksaM1$fGWNoThunksaM10$fGWNoThunksaM11$fGWRecordFieldfFalse$fGWRecordFieldfTrue$fGShowTypeOfM1$fNoThunksRatio $fNoThunksSeq$fNoThunksVector$fNoThunksVector0$fNoThunksIntMap $fNoThunksSet $fNoThunksMap$fNoThunksEither$fNoThunksNonEmpty$fNoThunksMaybe$fNoThunksIdentity$fNoThunksList $fNoThunks()$fNoThunksVoid$fNoThunks(,,,,,,)$fNoThunks(,,,,,)$fNoThunks(,,,,)$fNoThunks(,,,)$fNoThunks(,,) $fNoThunks(,)$fNoThunksText$fNoThunksByteString$fNoThunksTVar$fNoThunksMVar$fNoThunksIORef$fNoThunksSolo $fNoThunksArg$fGWNoThunksaK1$fNoThunksInspectHeapNamed$fNoThunksInspectHeap$fNoThunksAllowThunk$fNoThunksOnlyCheckWhnfNamed$fNoThunksOnlyCheckWhnf$fGWNoThunksaM12 $fHasFields:a$fHasFields[]a$fNoThunksAllowThunksIn$fShowThunkInfo$fNoThunksCallStack $fNoThunksIO $fNoThunksFUN$fNoThunksThreadId$fNoThunksText0$fNoThunksShortByteString$fNoThunksByteString0$fNoThunksZonedTime$fNoThunksUTCTime$fNoThunksUniversalTime$fNoThunksTimeZone$fNoThunksTimeOfDay$fNoThunksTimeLocale$fNoThunksNominalDiffTime$fNoThunksLocalTime$fNoThunksDiffTime $fNoThunksDay $fNoThunksAp $fNoThunksAlt$fNoThunksLast$fNoThunksFirst$fNoThunksWrappedMonoid$fNoThunksProduct $fNoThunksSum $fNoThunksAny $fNoThunksAll$fNoThunksDual$fNoThunksLast0$fNoThunksFirst0 $fNoThunksMax $fNoThunksMin$fNoThunksWord64$fNoThunksWord32$fNoThunksWord16$fNoThunksWord8$fNoThunksWord$fNoThunksInt64$fNoThunksInt32$fNoThunksInt16$fNoThunksInt8 $fNoThunksInt$fNoThunksChar$fNoThunksDouble$fNoThunksFloat$fNoThunksInteger$fNoThunksNatural$fNoThunksBool HasFields GWRecordFieldbaseData.Typeable.InternalTypeable GHC.GenericsGeneric GHC.InfoProv whereFromcheckContainsThunks GHC.IO.UnsafeunsafePerformIO inspectHeap checkIsThunkclosureIsThunkghc-heap-9.6.3GHC.Exts.Heap.ClosuresClosurecontainers-0.6.7Data.Sequence.InternalSeq