Hoogle Search
Within LTS Haskell 24.40 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
castForeignPtr :: ForeignPtr a -> ForeignPtr bbase-compat Foreign.ForeignPtr.Safe.Compat This function casts a ForeignPtr parameterised by one type into another type.
finalizeForeignPtr :: ForeignPtr a -> IO ()base-compat Foreign.ForeignPtr.Safe.Compat Causes the finalizers associated with a foreign pointer to be run immediately. The foreign pointer must not be used again after this function is called. If the foreign pointer does not support finalizers, this is a no-op.
mallocForeignPtr :: Storable a => IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat Allocate some memory and return a ForeignPtr to it. The memory will be released automatically when the ForeignPtr is discarded. mallocForeignPtr is equivalent to
do { p <- malloc; newForeignPtr finalizerFree p }although it may be implemented differently internally: you may not assume that the memory returned by mallocForeignPtr has been allocated with malloc. GHC notes: mallocForeignPtr has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, so the ForeignPtr does not require a finalizer to free the memory. Use of mallocForeignPtr and associated functions is strongly recommended in preference to newForeignPtr with a finalizer.mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat This function is similar to mallocArray, but yields a memory area that has a finalizer attached that releases the memory area. As with mallocForeignPtr, it is not guaranteed that the block of memory was allocated by malloc.
mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat This function is similar to mallocArray0, but yields a memory area that has a finalizer attached that releases the memory area. As with mallocForeignPtr, it is not guaranteed that the block of memory was allocated by malloc.
mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat This function is similar to mallocForeignPtr, except that the size of the memory required is given explicitly as a number of bytes.
newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat Turns a plain memory reference into a foreign pointer, and associates a finalizer with the reference. The finalizer will be executed after the last reference to the foreign object is dropped. There is no guarantee of promptness, however the finalizer will be executed before the program exits.
newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat This variant of newForeignPtr adds a finalizer that expects an environment in addition to the finalized pointer. The environment that will be passed to the finalizer is fixed by the second argument to newForeignPtrEnv.
newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)base-compat Foreign.ForeignPtr.Safe.Compat Turns a plain memory reference into a foreign pointer that may be associated with finalizers by using addForeignPtrFinalizer.
touchForeignPtr :: ForeignPtr a -> IO ()base-compat Foreign.ForeignPtr.Safe.Compat 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.