Îõ³h$"¡ ~ç      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefNone/29<=>?ÀÁÂÉÖ×Ùì Fnothunks9Generic infrastructure for checking for unexpected thunksThe aÊ argument records which record fields are allowed to contain thunks; see  and g, 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 h. Àderiving via InspectHeapNamed "T" T instance NoUnexpecedThunks TnothunksNewtype 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  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 iÊ instance, which may likewise not be available. Instead, we will rely on h, which is available for all types. However, as  explains, requiring h+ may not always be suitable; if it isn't,  can be used.Example: .deriving via InspectHeap T instance NoThunks TnothunksÏ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.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 iExample: 9deriving via OnlyCheckWhnfNamed "T" T instance NoThunks T nothunksNewtype 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)9 for detailed discussion. This should be used sparingly.Example: 0deriving via OnlyCheckWhnf T instance NoThunks Tnothunks#Information about unexpected thunksðTODO: The ghc-debug work by Matthew Pickering includes some work that allows to get source spans from closures. If we could take advantage of that, we could not only show the type of the unexpected thunk, but also where it got allocated.nothunksContext 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.nothunks#Check a value for unexpected thunksnothunks b) for detailed discussion.InothunksÀ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 j: 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 l).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.KnothunksInstance 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.LnothunksInstance 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[\]^_`abcdefgehijeklmnoð%nothunks-0.1.2-1yoyWWQQ30R25A2eklY3acNoThunks.Class Data.SequenceSequence GWNoThunks gwNoThunksInspectHeapNamed InspectHeap AllowThunksIn AllowThunkOnlyCheckWhnfNamed OnlyCheckWhnf ThunkInfo thunkContextContextNoThunksnoThunks wNoThunks showTypeOfunsafeNoThunks allNoThunksnoThunksInValuesnoThunksInKeysAndValues$fGWNoThunksaV1$fGWNoThunksaU1$fGWNoThunksa:+:$fGWNoThunksa:*:$fGWNoThunksaM1$fGWNoThunksaM10$fGWNoThunksaM11$fGWRecordFieldfFalse$fGWRecordFieldfTrue$fGShowTypeOfM1$fNoThunksRatio $fNoThunksSeq$fNoThunksVector$fNoThunksVector0$fNoThunksIntMap $fNoThunksSet $fNoThunksMap$fNoThunksEither$fNoThunksNonEmpty$fNoThunksMaybe $fNoThunks[] $fNoThunks()$fNoThunksVoid$fNoThunks(,,,,,,)$fNoThunks(,,,,,)$fNoThunks(,,,,)$fNoThunks(,,,)$fNoThunks(,,) $fNoThunks(,)$fNoThunksText$fNoThunksByteString$fNoThunksTVar$fNoThunksMVar$fNoThunksIORef$fGWNoThunksaK1$fNoThunksInspectHeapNamed$fNoThunksInspectHeap$fNoThunksAllowThunk$fNoThunksOnlyCheckWhnfNamed$fNoThunksOnlyCheckWhnf$fGWNoThunksaM12 $fHasFields:a$fHasFields[]a$fNoThunksAllowThunksIn$fShowThunkInfo$fNoThunksCallStack $fNoThunksIO $fNoThunks->$fNoThunksText0$fNoThunksShortByteString$fNoThunksByteString0$fNoThunksZonedTime$fNoThunksUTCTime$fNoThunksUniversalTime$fNoThunksTimeZone$fNoThunksTimeOfDay$fNoThunksTimeLocale$fNoThunksNominalDiffTime$fNoThunksLocalTime$fNoThunksDiffTime $fNoThunksDay$fNoThunksWord64$fNoThunksWord32$fNoThunksWord16$fNoThunksWord8$fNoThunksWord$fNoThunksInt64$fNoThunksInt32$fNoThunksInt16$fNoThunksInt8 $fNoThunksInt$fNoThunksChar$fNoThunksDouble$fNoThunksFloat$fNoThunksInteger$fNoThunksNatural$fNoThunksBool GWRecordFieldbaseData.Typeable.InternalTypeable GHC.GenericsGenericcheckContainsThunks GHC.IO.UnsafeunsafePerformIOcontainers-0.6.2.1Data.Sequence.InternalSeq