Finalised data pointers

The type ForeignPtr represents references to objects that are
maintained in a foreign language, i.e., that are not part of the
data structures usually managed by the Haskell storage manager.
The essential difference between ForeignPtrs and vanilla memory
references of type Ptr a is that the former may be associated
with finalizers. A finalizer is a routine that is invoked when
the Haskell storage manager detects that - within the Haskell heap
and stack - there are no more references left that are pointing to
the ForeignPtr. Typically, the finalizer will, then, invoke
routines in the foreign language that free the resources bound by
the foreign object.

Basic operations

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.

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.

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.

Low-level operations

This function ensures that the foreign object in
question is alive at the given place in the sequence of IO
actions. In particular withForeignPtr
does a touchForeignPtr after it
executes the user action.

Note that this function should not be used to express dependencies
between finalizers on ForeignPtrs. For example, if the finalizer
for a ForeignPtrF1 calls touchForeignPtr on a second
ForeignPtrF2, 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.

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 between
finalizers.

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.

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.