free -package

free :: Ptr a -> IO ()
base Foreign.Marshal.Alloc
Free a block of memory that was allocated with malloc, mallocBytes, realloc, reallocBytes, Foreign.Marshal.Utils.new or any of the newX functions in Foreign.Marshal.Array or Foreign.C.String.
freeHaskellFunPtr :: FunPtr a -> IO ()
base Foreign.Ptr
Release the storage associated with the given FunPtr, which must have been obtained from a wrapper stub. This should be called whenever the return value from a foreign import wrapper function is no longer required; otherwise, the storage it uses will leak.
freePool :: Pool -> IO ()
base Foreign.Marshal.Pool
Deallocate a memory pool and everything which has been allocated in the pool itself.
freeStablePtr :: StablePtr a -> IO ()
base Foreign.StablePtr
Dissolve the association between the stable pointer and the Haskell value. Afterwards, if the stable pointer is passed to deRefStablePtr or freeStablePtr, the behaviour is undefined. However, the stable pointer may still be passed to castStablePtrToPtr, but the Foreign.Ptr.Ptr () value returned by castStablePtrToPtr, in this case, is undefined (in particular, it may be Foreign.Ptr.nullPtr). Nevertheless, the call to castStablePtrToPtr is guaranteed not to diverge.
freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
array Data.Array.MArray, array Data.Array.MArray.Safe
Converts a mutable array (any instance of MArray) to an immutable array (any instance of IArray) by taking a complete copy of it.
finalizerFree :: FinalizerPtr a
base Foreign.Marshal.Alloc
A pointer to a foreign function equivalent to free, which may be used as a finalizer (cf Foreign.ForeignPtr.ForeignPtr) for storage allocated with malloc, mallocBytes, realloc or reallocBytes.
oFFSET_bdescr_free :: Int
base GHC.Constants
unsafeFreeze :: MArray s -> ST s Array
text Data.Text.Array
Freeze a mutable array. Do not mutate the MArray afterwards!
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
array Data.Array.MArray, array Data.Array.Unsafe
Converts an mutable array into an immutable array. The implementation may either simply cast the array from one type to the other without copying the array, or it may take a full copy of the array. Note that because the array is possibly not copied, any subsequent modifications made to the mutable version of the array may be shared with the immutable version. It is safe to use, therefore, if the mutable version is never modified after the freeze operation. The non-copying implementation is supported between certain pairs of array types only; one constraint is that the array types must have identical representations. In GHC, The following pairs of array types have a non-copying O(1) implementation of unsafeFreeze. Because the optimised versions are enabled by specialisations, you will need to compile with optimisation (-O) to get them. * IOUArray -> UArray * STUArray -> UArray * IOArray -> Array * STArray -> Array