Hoogle Search
Within LTS Haskell 24.38 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)base GHC.ForeignPtr This function is similar to mallocForeignPtr, except that the size of the memory required is given explicitly as a number of bytes.
mallocPlainForeignPtr :: Storable a => IO (ForeignPtr a)base GHC.ForeignPtr Allocate some memory and return a ForeignPtr to it. The memory will be released automatically when the ForeignPtr is discarded. GHC notes: mallocPlainForeignPtr has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, as for mallocForeignPtr. Unlike mallocForeignPtr, a ForeignPtr created with mallocPlainForeignPtr carries no finalizers. It is not possible to add a finalizer to a ForeignPtr created with mallocPlainForeignPtr. This is useful for ForeignPtrs that will live only inside Haskell (such as those created for packed strings). Attempts to add a finalizer to a ForeignPtr created this way, or to finalize such a pointer, will throw an exception.
mallocPlainForeignPtrAlignedBytes :: Int -> Int -> IO (ForeignPtr a)base GHC.ForeignPtr This function is similar to mallocForeignPtrAlignedBytes, except that the internally an optimised ForeignPtr representation with no finalizer is used. Attempts to add a finalizer will cause an exception to be thrown.
mallocPlainForeignPtrBytes :: Int -> IO (ForeignPtr a)base GHC.ForeignPtr This function is similar to mallocForeignPtrBytes, except that the internally an optimised ForeignPtr representation with no finalizer is used. Attempts to add a finalizer will cause an exception to be thrown.
newConcForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a)base GHC.ForeignPtr Turns a plain memory reference into a foreign object by associating a finalizer - given by the monadic operation - with the reference. When finalization is triggered by GC, the storage manager will start the finalizer, in a separate thread, some time after the last reference to the ForeignPtr is dropped. There is no guarantee of promptness, and in fact there is no guarantee that the finalizer will eventually run at all for GC-triggered finalization. When finalization is triggered by explicitly calling finalizeForeignPtr, the finalizer will run immediately on the current Haskell thread. Note that references from a finalizer do not necessarily prevent another object from being finalized. If A's finalizer refers to B (perhaps using touchForeignPtr, then the only guarantee is that B's finalizer will never be started before A's. If both A and B are unreachable, then both finalizers will start together. See touchForeignPtr for more on finalizer ordering.
newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)base GHC.ForeignPtr Turns a plain memory reference into a foreign pointer that may be associated with finalizers by using addForeignPtrFinalizer.
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr bbase GHC.ForeignPtr Advances the given address by the given offset in bytes. The new ForeignPtr shares the finalizer of the original, equivalent from a finalization standpoint to just creating another reference to the original. That is, the finalizer will not be called before the new ForeignPtr is unreachable, nor will it be called an additional time due to this call, and the finalizer will be called with the same address that it would have had this call not happened, *not* the new address.
touchForeignPtr :: ForeignPtr a -> IO ()base GHC.ForeignPtr This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. However, this comes with a significant caveat: the contract above does not hold if GHC can demonstrate that the code preceding touchForeignPtr diverges (e.g. by looping infinitely or throwing an exception). For this reason, you are strongly advised to use instead withForeignPtr where possible. Also, note that this function should not be used to express dependencies between finalizers on ForeignPtrs. For example, if the finalizer for a ForeignPtr F1 calls touchForeignPtr on a second ForeignPtr F2, then the only guarantee is that the finalizer for F2 is never started before the finalizer for F1. They might be started together if for example both F1 and F2 are otherwise unreachable, and in that case the scheduler might end up running the finalizer for F2 first. In general, it is not recommended to use finalizers on separate objects with ordering constraints between them. To express the ordering robustly requires explicit synchronisation using MVars between the finalizers, but even then the runtime sometimes runs multiple finalizers sequentially in a single thread (for performance reasons), so synchronisation between finalizers could result in artificial deadlock. Another alternative is to use explicit reference counting.
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr abase GHC.ForeignPtr This function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to unsafeForeignPtrToPtr is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, touchForeignPtr must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence. To avoid subtle coding errors, hand written marshalling code should preferably use withForeignPtr rather than combinations of unsafeForeignPtrToPtr and touchForeignPtr. However, the latter routines are occasionally preferred in tool generated marshalling code.
unsafeWithForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO bbase GHC.ForeignPtr This is similar to withForeignPtr but comes with an important caveat: the user must guarantee that the continuation does not diverge (e.g. loop or throw an exception). In exchange for this loss of generality, this function offers the ability of GHC to optimise more aggressively. Specifically, applications of the form: unsafeWithForeignPtr fptr (forever something) See GHC issue #17760 for more information about the unsoundness behavior that this function can result in.