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.
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO bbase Foreign.ForeignPtr This is a way to look at the pointer living inside a foreign object. This function takes a function which is applied to that pointer. The resulting IO action is then executed. The foreign object is kept alive at least during the whole action, even if it is not used directly inside. Note that it is not safe to return the pointer from the action and use it after the action completes. All uses of the pointer should be inside the withForeignPtr bracket. The reason for this unsafeness is the same as for unsafeForeignPtrToPtr below: the finalizer may run earlier than expected, because the compiler can only track usage of the ForeignPtr object, not a Ptr object made from it. This function is normally used for marshalling data to or from the object pointed to by the ForeignPtr, using the operations from the Storable class.
addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()base Foreign.ForeignPtr.Safe This function adds a finalizer to the given foreign object. The finalizer will run before all other finalizers for the same object which have already been registered.
addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()base Foreign.ForeignPtr.Safe Like addForeignPtrFinalizer but the finalizer is passed an additional environment parameter.
castForeignPtr :: ForeignPtr a -> ForeignPtr bbase Foreign.ForeignPtr.Safe This function casts a ForeignPtr parameterised by one type into another type.
finalizeForeignPtr :: ForeignPtr a -> IO ()base Foreign.ForeignPtr.Safe 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 Foreign.ForeignPtr.Safe 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 Foreign.ForeignPtr.Safe 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 Foreign.ForeignPtr.Safe 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 Foreign.ForeignPtr.Safe 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 Foreign.ForeignPtr.Safe 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.