At least in my experience, in order to get proper resource management for things like file or database handles, you need both a close operation and a finalizer registered with the garbage collector. The former is needed so that you can create resources faster than the garbage collector freeing them. The latter is a safety net in cases where proper resource management is not follwoed (perhaps in GHCi). When the explicit close operation or the finalizer has been invoked, the object must somehow be disabled, so that further operations on it fail (otherwise, you might dereference a dangling pointer). What's the idom for implementing this in Haskell (or GHC)? It seems that a ForeignPtr cannot be written to (otherwise I'd change it to a null pointer when the resource is freed). It's also not possible to check if the finalizers have been run. Can the finalizers hold a reference to the object which in turn holds the ForeignPtr to be finalized? Or would that prevent the finalizers from running at all? Is there a way to avoid the extra level of indirection (or is GHC sufficiently smart to optimize it away)?