remove old lib docs
authorSimon Marlow <marlowsd@gmail.com>
Tue, 29 Jun 2010 12:47:27 +0000 (12:47 +0000)
committerSimon Marlow <marlowsd@gmail.com>
Tue, 29 Jun 2010 12:47:27 +0000 (12:47 +0000)
16 files changed:
report/lib-cerror.verb [deleted file]
report/lib-cforeign.verb [deleted file]
report/lib-cstring.verb [deleted file]
report/lib-ctypes.verb [deleted file]
report/lib-data-bits.verb [deleted file]
report/lib-data-intword.verb [deleted file]
report/lib-foreign.verb [deleted file]
report/lib-foreignptr.verb [deleted file]
report/lib-marshal.verb [deleted file]
report/lib-marshalalloc.verb [deleted file]
report/lib-marshalarray.verb [deleted file]
report/lib-marshalerror.verb [deleted file]
report/lib-marshalutils.verb [deleted file]
report/lib-ptr.verb [deleted file]
report/lib-stableptr.verb [deleted file]
report/lib-storable.verb [deleted file]

diff --git a/report/lib-cerror.verb b/report/lib-cerror.verb
deleted file mode 100644 (file)
index 4352a6c..0000000
+++ /dev/null
@@ -1,100 +0,0 @@
-\section{@Foreign.C.Error@}
-\label{sec:CError}
-
-The module @Foreign.C.Error@ facilitates C-specific error handling of @errno@.  In
-Haskell, we represent values of @errno@ by
-%
-\begin{quote}
-\begin{verbatim}
-newtype Errno = Errno CInt
-\end{verbatim}
-\end{quote}
-%
-which has an instance for the type class @Eq@.  The implementation of
-@Errno@ is disclosed on purpose.  Different operating systems and/or C
-libraries often support different values of @errno@.  This module defines
-the common values, but due to the open definition of @Errno@ users may
-add definitions which are not predefined.  The predefined values are the
-following:
-%
-\begin{quote}
-\begin{verbatim}
-
-eOK, e2BIG, eACCES, eADDRINUSE, eADDRNOTAVAIL, eADV,
-  eAFNOSUPPORT, eAGAIN, eALREADY, eBADF, eBADMSG, eBADRPC,
-  eBUSY, eCHILD, eCOMM, eCONNABORTED, eCONNREFUSED,
-  eCONNRESET, eDEADLK, eDESTADDRREQ, eDIRTY, eDOM, eDQUOT,
-  eEXIST, eFAULT, eFBIG, eFTYPE, eHOSTDOWN, eHOSTUNREACH,
-  eIDRM, eILSEQ, eINPROGRESS, eINTR, eINVAL, eIO, eISCONN,
-  eISDIR, eLOOP, eMFILE, eMLINK, eMSGSIZE, eMULTIHOP,
-  eNAMETOOLONG, eNETDOWN, eNETRESET, eNETUNREACH, eNFILE,
-  eNOBUFS, eNODATA, eNODEV, eNOENT, eNOEXEC, eNOLCK,
-  eNOLINK, eNOMEM, eNOMSG, eNONET, eNOPROTOOPT, eNOSPC,
-  eNOSR, eNOSTR, eNOSYS, eNOTBLK, eNOTCONN, eNOTDIR,
-  eNOTEMPTY, eNOTSOCK, eNOTTY, eNXIO, eOPNOTSUPP, ePERM,
-  ePFNOSUPPORT, ePIPE, ePROCLIM, ePROCUNAVAIL,
-  ePROGMISMATCH, ePROGUNAVAIL, ePROTO, ePROTONOSUPPORT,
-  ePROTOTYPE, eRANGE, eREMCHG, eREMOTE, eROFS, eRPCMISMATCH,
-  eRREMOTE, eSHUTDOWN, eSOCKTNOSUPPORT, eSPIPE, eSRCH,
-  eSRMNT, eSTALE, eTIME, eTIMEDOUT, eTOOMANYREFS, eTXTBSY,
-  eUSERS, eWOULDBLOCK, eXDEV
-  :: Errno
-\end{verbatim}
-\end{quote}
-%
-The meaning of these values corresponds to that of the C constants of the same
-name with the leading "e" converted to upper-case.
-
-The module @Foreign.C.Error@ provides the following functions:
-%
-\begin{codedesc}
-\item[isValidErrno ::\ Errno -> Bool] Yield @True@ if the given
-  @Errno@ value is valid on the system.  This implies that the @Eq@
-  instance of @Errno@ is also system dependent as it is only defined for
-  valid values of @Errno@.
-
-\item[getErrno ::\ IO Errno] Get the current value of @errno@.
-
-\item[resetErrno ::\ IO ()] Reset @errno@ to @eOK@.
-  
-\item[errnoToIOError ::\ String -> Errno -> Maybe Handle -> Maybe String]
-\item[~~~~~~~~~~~~~~~-> Maybe String -> IOError]\combineitems
-  Compute a Haskell I/O error based on the given @Errno@
-  value.  The first argument to the function should specify the location where
-  the error occurred and the third and fourth can be used to specify a file
-  handle and filename in the course of whose manipulation the error occurred.
-  This is optional information, which can be used to improve the accuracy of
-  error messages.
-  
-\item[throwErrno ::\ String -> IO a] Apply @errnoToIOError@ to the value
-  currently returned by @getErrno@.  Its first argument specifies the
-  location---no extra information about a file handle or filename can be
-  provided in this case.
-
-\item[throwErrnoIf~~:: (a -> Bool) -> String -> IO a -> IO a]
-\item[throwErrnoIf\_~:: (a -> Bool) -> String -> IO a -> IO ()]\combineitems
-  Behave like @throwErrno@ in case that the result of the @IO@
-  action fulfils the predicate passed as a first argument.  The second variant
-  discards the result after error handling.
-
-\item[throwErrnoIfRetry~~:: (a -> Bool) -> String -> IO a -> IO a]
-\item[throwErrnoIfRetry\_~:: (a -> Bool) -> String -> IO a -> IO ()]%
-\combineitems Like @throwErrnoIf@ and @throwErrnoIf_@, but retry
-the @IO@ action when it yields the error code @eINTR@---this amounts
-to the standard retry loop for interrupted POSIX system calls.
-
-\item[throwErrnoIfMinus1~~:: Num a => String -> IO a -> IO a]
-\item[throwErrnoIfMinus1\_~:: Num a => String -> IO a -> IO ()]\combineitems
-  Instantiate @throwErrnoIf@ and @throwErrnoIf_@ with the predicate
-  @(== -1)@.
-
-\item[throwErrnoIfMinus1Retry~~:: Num a => String -> IO a -> IO a]
-\item[throwErrnoIfMinus1Retry\_~:: Num a => String -> IO a -> IO ()]%
-  \combineitems Instantiate @throwErrnoIfRetry@ and
-  @throwErrnoIfRetry_@ with the predicate @(== -1)@.
-
-\item[throwErrnoIfNull~~~~~~:: String -> IO (Ptr a) -> IO (Ptr a)]
-\item[throwErrnoIfNullRetry~:: String -> IO (Ptr a) -> IO (Ptr a)]%
-  \combineitems Instantiate @throwErrnoIf@ and @throwErrnoIfRetry@
-  with the predicate @(== Ptr.nullPtr)@.
-\end{codedesc}
diff --git a/report/lib-cforeign.verb b/report/lib-cforeign.verb
deleted file mode 100644 (file)
index cb89a7d..0000000
+++ /dev/null
@@ -1,283 +0,0 @@
-\section{@Foreign.C@}
-\label{sec:CForeign}
-
-The module @Foreign.C@ combines the interfaces of all modules providing
-C-specific marshalling support.  The modules are @Foreign.C.Types@,
-@Foreign.C.String@, and @Foreign.C.Error@.
-
-\begin{table}
-  \begin{center}
-    \begin{tabular}{|l|l|l|}
-      \hline
-      C symbol          & Haskell symbol & Constraint on concrete C type\\
-      \hline\hline
-      @HsChar@     & @Char@    
-      & integral type\\
-      \hline
-      @HsInt@      & @Int@
-      & signed integral type, $\geq30$ bit\\
-      \hline
-      @HsInt8@     & @Int8@
-      & signed integral type, 8 bit; @int8_t@ if available\\
-      \hline
-      @HsInt16@    & @Int16@
-      & signed integral type, 16 bit; @int16_t@ if available\\
-      \hline
-      @HsInt32@    & @Int32@
-      & signed integral type, 32 bit; @int32_t@ if available\\
-      \hline
-      @HsInt64@    & @Int64@
-      & signed integral type, 64 bit; @int64_t@ if available\\ 
-      \hline
-      @HsWord8@    & @Word8@
-      & unsigned integral type, 8 bit; @uint8_t@ if available\\
-      \hline
-      @HsWord16@   & @Word16@
-      & unsigned integral type, 16 bit; @uint16_t@ if available\\
-      \hline
-      @HsWord32@   & @Word32@
-      & unsigned integral type, 32 bit; @uint32_t@ if available\\
-      \hline
-      @HsWord64@   & @Word64@
-      & unsigned integral type, 64 bit; @uint64_t@ if available\\
-      \hline
-      @HsFloat@    & @Float@
-      & floating point type\\
-     \hline
-      @HsDouble@   & @Double@
-      & floating point type\\
-     \hline
-      @HsBool@     & @Bool@
-      & @int@\\
-     \hline
-      @HsPtr@      & @Ptr a@
-      & @(void *)@\\
-     \hline
-      @HsFunPtr@   & @FunPtr a@
-      & @(void (*)(void))@\\
-     \hline
-      @HsStablePtr@& @StablePtr a@
-      & @(void *)@\\
-     \hline
-    \end{tabular}
-    \caption{C Interface to Basic Haskell Types}
-    \label{tab:c-haskell-types}
-  \end{center}
-\end{table}
-%
-\begin{table}
-  \begin{center}
-%    \begin{tabular}{|l|l|l|}
-    \begin{tabular}{|l|l|p{30ex}|}
-      \hline
-      CPP symbol           & Haskell value & Description\\
-      \hline\hline
-      @HS_CHAR_MIN@ & @minBound :: Char@
-      & \\
-      \hline
-      @HS_CHAR_MAX@ & @maxBound :: Char@
-      & \\
-      \hline
-      @HS_INT_MIN@ & @minBound :: Int@
-      & \\
-      \hline
-      @HS_INT_MAX@ & @maxBound :: Int@
-      & \\
-      \hline
-      @HS_INT8_MIN@ & @minBound :: Int8@
-      & \\
-      \hline
-      @HS_INT8_MAX@ & @maxBound :: Int8@
-      & \\
-      \hline
-      @HS_INT16_MIN@ & @minBound :: Int16@
-      & \\
-      \hline
-      @HS_INT16_MAX@ & @maxBound :: Int16@
-      & \\
-      \hline
-      @HS_INT32_MIN@ & @minBound :: Int32@
-      & \\
-      \hline
-      @HS_INT32_MAX@ & @maxBound :: Int32@
-      & \\
-      \hline
-      @HS_INT64_MIN@ & @minBound :: Int64@
-      & \\
-      \hline
-      @HS_INT64_MAX@ & @maxBound :: Int64@
-      & \\
-      \hline
-      @HS_WORD8_MAX@ & @maxBound :: Word8@
-      & \\
-      \hline
-      @HS_WORD16_MAX@ & @maxBound :: Word16@
-      & \\
-      \hline
-      @HS_WORD32_MAX@ & @maxBound :: Word32@
-      & \\
-      \hline
-      @HS_WORD64_MAX@ & @maxBound :: Word64@
-      & \\
-      \hline
-      @HS_FLOAT_RADIX@ & @floatRadix :: Float@
-      & \\
-      \hline
-      @HS_FLOAT_ROUND@ & n/a
-      & rounding style as per~\cite{C99}\\
-      \hline
-      @HS_FLOAT_EPSILON@ & n/a
-      & difference between 1 and the least value greater
-      than 1 as per~\cite{C99}\\
-      \hline
-      @HS_DOUBLE_EPSILON@ & n/a
-      & (as above)\\
-      \hline
-      @HS_FLOAT_DIG@ & n/a
-      & number of decimal digits as per~\cite{C99}\\
-      \hline
-      @HS_DOUBLE_DIG@ & n/a
-      & (as above)\\
-      \hline
-      @HS_FLOAT_MANT_DIG@ & @floatDigits :: Float@
-      & \\
-      \hline
-      @HS_DOUBLE_MANT_DIG@ & @floatDigits :: Double@
-      & \\
-      \hline
-      @HS_FLOAT_MIN@ & n/a
-      & minimum floating point number as per~\cite{C99}\\
-      \hline
-      @HS_DOUBLE_MIN@ & n/a
-      & (as above)\\
-      \hline
-      @HS_FLOAT_MIN_EXP@ & @fst . floatRange :: Float@
-      & \\
-      \hline
-      @HS_DOUBLE_MIN_EXP@ & @fst . floatRange :: Double@
-      & \\
-      \hline
-      @HS_FLOAT_MIN_10_EXP@ & n/a
-      & minimum decimal exponent as per~\cite{C99}\\
-      \hline
-      @HS_DOUBLE_MIN_10_EXP@ & n/a
-      & (as above)\\
-      \hline
-      @HS_FLOAT_MAX@ & n/a
-      & maximum floating point number as per~\cite{C99}\\
-      \hline
-      @HS_DOUBLE_MAX@ & n/a
-      & (as above)\\
-      \hline
-      @HS_FLOAT_MAX_EXP@ & @snd . floatRange :: Float@
-      & \\
-      \hline
-      @HS_DOUBLE_MAX_EXP@ & @snd . floatRange :: Double@
-      & \\
-      \hline
-      @HS_FLOAT_MAX_10_EXP@ & n/a
-      & maximum decimal exponent as per~\cite{C99}\\
-      \hline
-      @HS_DOUBLE_MAX_10_EXP@ & n/a
-      & (as above)\\
-      \hline
-      @HS_BOOL_FALSE@ & False
-      & \\
-      \hline
-      @HS_BOOL_TRUE@ & True
-      & \\
-      \hline
-    \end{tabular}
-    \caption{C Interface to Range and Precision of Basic Types}
-    \label{tab:c-haskell-values}
-  \end{center}
-\end{table}
-%
-Every Haskell system that implements the FFI needs to provide a C header file
-named @HsFFI.h@ that defines the C symbols listed in
-Tables~\ref{tab:c-haskell-types} and~\ref{tab:c-haskell-values}.
-Table~\ref{tab:c-haskell-types} table lists symbols that represent types
-together with the Haskell type that they represent and any constraints that
-are placed on the concrete C types that implement these symbols.  When a C
-type @HsT@ represents a Haskell type @T@, the occurrence of @T@
-in a foreign function declaration should be matched by @HsT@ in the
-corresponding C function prototype.  Indeed, where the Haskell system
-translates Haskell to C code that invokes @foreign@ @import@ed C
-routines, such prototypes need to be provided and included via the header that
-can be specified in external entity strings for foreign C functions (cf.\ 
-Section~\ref{sec:ccall}); otherwise, the system behaviour is undefined.  It is
-guaranteed that the Haskell value @nullPtr@ is mapped to @(HsPtr) NULL@ in C and @nullFunPtr@ is mapped to @(HsFunPtr) NULL@ and
-vice versa.
-
-Table~\ref{tab:c-haskell-values} contains symbols characterising the range and
-precision of the types from Table~\ref{tab:c-haskell-types}.  Where available,
-the table states the corresponding Haskell values.  All C symbols, with the
-exception of @HS_FLOAT_ROUND@ are constants that are suitable for use in
-@#if@ preprocessing directives.  Note that there is only one rounding
-style (@HS_FLOAT_ROUND@) and one radix (@HS_FLOAT_RADIX@), as
-this is all that is supported by ISO C~\cite{C99}.
-
-Moreover, an implementation that does not support 64 bit integral types on the
-C side should implement @HsInt64@ and @HsWord64@ as a structure.  In
-this case, the bounds @HS_INT64_MIN@, @HS_INT64_MAX@, and
-@HS_WORD64_MAX@ are undefined.
-
-In addition, to the symbols from Table~\ref{tab:c-haskell-types}
-and~\ref{tab:c-haskell-values}, the header @HsFFI.h@ must also contain
-the following prototypes:
-%
-\begin{quote}
-\begin{verbatim}
-void hs_init     (int *argc, char **argv[]);
-void hs_exit     (void);
-void hs_set_argv (int argc, char *argv[]);
-
-void hs_perform_gc (void);
-
-void hs_free_stable_ptr (HsStablePtr sp);
-void hs_free_fun_ptr    (HsFunPtr fp);
-\end{verbatim}
-\end{quote}
-%
-These routines are useful for mixed language programs, where the main
-application is implemented in a foreign language that accesses routines
-implemented in Haskell.  The function @hs_init()@ initialises the
-Haskell system and provides it with the available command line arguments.
-Upon return, the arguments solely intended for the Haskell runtime system are
-removed (i.e., the values that @argc@ and @argv@ point to may have
-changed).  This function must be called during program startup before any
-Haskell function is invoked; otherwise, the system behaviour is undefined.
-Conversely, the Haskell system is deinitialised by a call to
-@hs_exit()@.  Multiple invocations of @hs_init()@ are permitted,
-provided that they are followed by an equal number of calls to
-@hs_exit()@ and that the first call to @hs_exit()@ is after the
-last call to @hs_init()@.  In addition to nested calls to
-@hs_init()@, the Haskell system may be de-initialised with
-@hs_exit()@ and be re-initialised with @hs_init()@ at a later
-point in time.  This ensures that repeated initialisation due to multiple
-libraries being implemented in Haskell is covered.
-
-The Haskell system will ignore the command line arguments passed to the second
-and any following calls to @hs_init()@.  Moreover, @hs_init()@ may
-be called with @NULL@ for both @argc@ and @argv@, signalling
-the absence of command line arguments.
-
-The function @hs_set_argv()@ sets the values returned by the functions
-@getProgName@ and @getArgs@ of the module @System@ (Section~\ref{System}).  This function may only be invoked after
-@hs_init()@.  Moreover, if @hs_set_argv()@ is called at all, this
-call must precede the first invocation of @getProgName@ and
-@getArgs@.  Note that the separation of @hs_init()@ and
-@hs_set_argv()@ is essential in cases where in addition to the Haskell
-system other libraries that process command line arguments during
-initialisation are used.
-
-The function @hs_perform_gc()@ advises the Haskell storage manager to
-perform a garbage collection, where the storage manager makes an effort to
-releases all unreachable objects.  This function must not be invoked from C
-functions that are imported @unsafe@ into Haskell code nor may it be used
-from a finalizer.
-
-Finally, @hs_free_stable_ptr()@ and @hs_free_fun_ptr()@ are
-the C counterparts of the Haskell functions @freeStablePtr@ and
-@freeHaskellFunPtr@.
-
diff --git a/report/lib-cstring.verb b/report/lib-cstring.verb
deleted file mode 100644 (file)
index fccf85b..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-\section{@Foreign.C.String@}
-\label{sec:CString}
-
-The module @Foreign.C.String@ provides routines marshalling Haskell into C strings
-and vice versa.  The marshalling converts each Haskell character, representing
-a Unicode code point, to one or more bytes in a manner that, by default, is
-determined by the current locale.  As a consequence, no guarantees can be made
-about the relative length of a Haskell string and its corresponding C string,
-and therefore, all routines provided by @Foreign.C.String@ combine memory
-allocation and marshalling.  The translation between Unicode and the encoding
-of the current locale may be lossy.  The function @charIsRepresentable@
-identifies the characters that can be accurately translated; unrepresentable
-characters are converted to `?'.
-%
-\begin{codedesc}
-\item[type CString = Ptr CChar] A C string is a reference to an array of C
-  characters terminated by NUL.
-  
-\item[type CStringLen = (Ptr CChar, Int)] In addition to NUL-terminated
-  strings, the module @Foreign.C.String@ also supports strings with explicit
-  length information in bytes.
-
-\item[peekCString~~~~::\ CString~~~~-> IO String]
-\item[peekCStringLen~::\ CStringLen~-> IO String]\combineitems
-  Marshal a C string to Haskell.  There are two variants of the routine, one
-  for each supported string representation.
-
-\item[newCString~~~~::\ String -> IO CString]
-\item[newCStringLen~::\ String -> IO CStringLen] \combineitems Allocate a
-  memory area for a Haskell string and marshal the string into its C
-  representation.  There are two variants of the routine, one for each
-  supported string representation.  The memory area allocated by these
-  routines may be deallocated using @Foreign.Marshal.Alloc.free@.
-
-\item[withCString~~~~::\ String -> (CString~~~~-> IO a) -> IO a]
-\item[withCStringLen~::\ String -> (CStringLen~-> IO a) -> IO a] \combineitems
-  These two routines operate as @newCString@ and @newCStringLen@,
-  respectively, but handle memory allocation and deallocation like
-  @Foreign.Marshal.Alloc.alloca@ (Section~\ref{sec:MarshalAlloc}).
-  
-\item[charIsRepresentable ::\ Char -> IO Bool] Determine whether the argument
-  can be represented in the current locale.
-
-\end{codedesc}
-
-Some C libraries require to ignore the Unicode capabilities of Haskell and
-treat values of type @Char@ as single byte characters.  Hence, the module
-@CString@ provides a variant of the above marshalling routines that
-truncates character sets correspondingly.  These functions should be used with
-care, as a loss of information can occur.
-%
-\begin{codedesc}
-\item[castCharToCChar ::\ Char -> CChar]
-\item[castCCharToChar ::\ CChar -> Char] \combineitems These two functions cast
-  Haskell characters to C characters and vice versa while ignoring the Unicode
-  encoding of the Haskell character.  More precisely, only the first 256
-  character points are preserved.
-
-\item[peekCAString~~~~::\ CString~~~~-> IO String]
-\item[peekCAStringLen~::\ CStringLen~-> IO String]\combineitems
-\item[newCAString~~~~~::\ String -> IO CString]\combineitems
-\item[newCAStringLen~~::\ String -> IO CStringLen] \combineitems
-\item[withCAString~~~~::\ String -> (CString~~~~-> IO a) -> IO a]\combineitems
-\item[withCAStringLen~::\ String -> (CStringLen~-> IO a) -> IO a]
-  \combineitems These functions for whole-string marshalling cast Haskell
-  characters to C characters and vice versa while ignoring the Unicode
-  encoding of Haskell characters.
-\end{codedesc}
-
-To simplify bindings to C libraries that use @wchar_t@ for character
-sets that cannot be encoded in byte strings, the module @Foreign.C.String@ also
-exports a variant of the above string marshalling routines for wide
-characters---i.e., for the C @wchar_t@ type.\footnote{Note that if the
-  platform defines @__STDC_ISO_10646__@ then @wchar_t@
-  characters are Unicode code points, and thus, the conversion between Haskell
-  @Char@ and @CWchar@ is a simple cast.  On other platforms, the
-  translation is locale-dependent, just as for @CChar@.}
-%
-\begin{codedesc}
-\item[type CWString~~~~= Ptr CWchar]
-\item[type CWStringLen~= (Ptr CWchar, Int)] \combineitems
-  Wide character strings in a NUL-terminated version and a variant with
-  explicit length information in number of wide characters.
-
-\item[peekCWString~~~~::\ CWString~~~~-> IO String]
-\item[peekCWStringLen~::\ CWStringLen~-> IO String]\combineitems
-\item[newCWString~~~~~::\ String -> IO CWString]\combineitems
-\item[newCWStringLen~~::\ String -> IO CWStringLen] \combineitems
-\item[withCWString~~~~::\ String -> (CWString~~~~-> IO a) -> IO a]\combineitems
-\item[withCWStringLen~::\ String -> (CWStringLen~-> IO a) -> IO a]
-  \combineitems String marshalling for wide character strings.  The interface
-  is the same as for byte strings.
-\end{codedesc}
diff --git a/report/lib-ctypes.verb b/report/lib-ctypes.verb
deleted file mode 100644 (file)
index 5a657d1..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-\section{@Foreign.C.Types@}
-\label{sec:CTypes}
-
-The modules @Foreign.C.Types@ provide Haskell types that represent basic C types.
-They are needed to accurately represent C function prototypes, and so, to
-access C library interfaces in Haskell.  The Haskell system is not required to
-represent those types exactly as C does, but the following guarantees are
-provided concerning a Haskell type @CT@ representing a C type @t@:
-%
-\begin{itemize}
-\item If a C function prototype has @t@ as an argument or result type,
-  the use of @CT@ in the corresponding position in a foreign declaration
-  permits the Haskell program to access the full range of values encoded by
-  the C type; and conversely, any Haskell value for @CT@ has a valid
-  representation in C.
-\item @Foreign.Storable.sizeOf (undefined :: CT)@ will yield the same value as
-  @sizeof (t)@ in C.
-\item @Foreign.Storable.alignment (undefined :: CT)@ matches the alignment
-  constraint enforced by the C implementation for @t@.
-\item @Foreign.Storable.peek@ and @Foreign.Storable.poke@ map all values of
-  @CT@ to the corresponding value of @t@ and vice versa.
-\item When an instance of @Bounded@ is defined for @CT@, the values
-  of @minBound@ and @maxBound@ coincide with @t_MIN@ and
-  @t_MAX@ in C.
-\item When an instance of @Eq@ or @Ord@ is defined for @CT@,
-  the predicates defined by the type class implement the same relation as the
-  corresponding predicate in C on @t@.
-\item When an instance of @Num@, @Read@, @Integral@,
-  @Fractional@, @Floating@, @RealFrac@, or @RealFloat@ is
-  defined for @CT@, the arithmetic operations defined by the type class
-  implement the same function as the corresponding arithmetic operations (if
-  available) in C on @t@.
-\item When an instance of @Bits@ is defined for @CT@, the bitwise
-  operation defined by the type class implement the same function as the
-  corresponding bitwise operation in C on @t@.
-\end{itemize}
-%
-All types exported by @Foreign.C.Types@ must be represented as @newtype@s of
-basic foreign types as defined in Section~\ref{sec:foreign-types} and the
-export must be abstract.
-
-The module @Foreign.C.Types@ provides the following integral types, including
-instances for @Eq@, @Ord@, @Num@, @Read@, @Show@,
-@Enum@, @Storable@, @Bounded@, @Real@, @Integral@,
-and @Bits@:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    @CChar@     & @char@\\\hline
-    @CSChar@    & @signed char@\\\hline
-    @CUChar@    & @unsigned char@\\\hline
-    @CShort@    & @short@\\\hline
-    @CUShort@   & @unsigned short@\\\hline
-    @CInt@      & @int@\\\hline
-    @CUInt@     & @unsigned int@\\\hline
-    @CLong@     & @long@\\\hline
-    @CULong@    & @unsigned long@\\\hline
-    @CLLong@    & @long long@\\\hline
-    @CULLong@   & @unsigned long long@\\\hline
-  \end{tabular}
-\end{quote}
-%
-Moreover, it provides the following floating point types, including instances
-for @Eq@, @Ord@, @Num@, @Read@, @Show@, @Enum@,
-@Storable@, @Real@, @Fractional@, @Floating@,
-@RealFrac@, and @RealFloat@:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    @CFloat@    & @float@\\\hline
-    @CDouble@   & @double@\\\hline
-    @CLDouble@  & @long double@\\\hline
-  \end{tabular}
-\end{quote}
-%
-The module provides the following integral types, including instances for
-@Eq@, @Ord@, @Num@, @Read@, @Show@, @Enum@,
-@Storable@, @Bounded@, @Real@, @Integral@, and
-@Bits@:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    @CPtrdiff@  & @ptrdiff_t@\\\hline
-    @CSize@     & @size_t@\\\hline
-    @CWchar@    & @wchar_t@\\\hline
-    @CSigAtomic@& @sig_atomic_t@\\\hline
-  \end{tabular}
-\end{quote}
-%
-Moreover, it provides the following numeric types, including instances for
-@Eq@, @Ord@, @Num@, @Read@, @Show@, @Enum@, and
-@Storable@:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    @CClock@    & @clock_t@\\\hline
-    @CTime@     & @time_t@\\\hline
-  \end{tabular}
-\end{quote}
-%
-And finally, the following types, including instances for @Eq@ and
-@Storable@, are provided:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    @CFile@     & @FILE@\\\hline
-    @CFpos@     & @fpos_t@\\\hline
-    @CJmpBuf@   & @jmp_buf@\\\hline
-  \end{tabular}
-\end{quote}
-
diff --git a/report/lib-data-bits.verb b/report/lib-data-bits.verb
deleted file mode 100644 (file)
index 5e0c1e9..0000000
+++ /dev/null
@@ -1,78 +0,0 @@
-\section{@Data.Bits@}
-
-This module provides functions implementing typical bit operations overloaded
-for the standard integral types @Int@ and @Integer@ as well as the
-types provided by the modules @Int@ and @Word@ in
-Section~\ref{sec:Int-Word}.  The overloading is implemented via a new type
-class @Bits@, which is a subclass of @Num@ and has the following
-member functions:
-%
-\begin{codedesc}
-\item[(.\&.), (.|.), xor ::\ Bits a => a -> a -> a]  Implement bitwise
-  conjunction, disjunction, and exclusive or.  The infix operators have the
-  following precedences:
-  %
-  \begin{quote}
-\begin{verbatim}
-infixl 7 .&.
-infixl 6 `xor`
-infixl 5 .|.
-\end{verbatim}
-  \end{quote}
-  
-\item[complement ::\ Bits a => a -> a] Calculate the bitwise complement of the
-  argument.
-
-\item[shift, rotate ::\ Bits a => a -> Int -> a] Shift or rotate the bit
-  pattern to the left for a positive second argument and to the right for a
-  negative argument.  The function @shift@ performs sign extension on
-  signed number types; i.e., right shifts fill the top bits with 1 if the
-  number is negative and with 0 otherwise.  These operators have the following
-  precedences as infix operators:
-  %
-  \begin{quote}
-\begin{verbatim}
-infixl 8 `shift`, `rotate`
-\end{verbatim}
-  \end{quote}
-  %
-  For unbounded types (e.g., @Integer@), @rotate@ is equivalent to
-  @shift@.  An instance can define either this unified @rotate@ or
-  @rotateL@ and @rotateR@, depending on which is more convenient for
-  the type in question.
-
-\item[bit ::\ Bits a => Int -> a] Obtain a value where only the $n$th bit
-  is set.
-  
-\item[setBit, clearBit, complementBit ::\ a -> Int -> a] Set, clear, or
-  complement the bit at the given position.
-  
-\item[testBit ::\ Bits a => a -> Int -> Bool] Check whether the $n$th bit of
-  the first argument is set.
-
-\item[bitSize~~::\ Bits a => a -> Int]
-\item[isSigned~::\ Bits a => a -> Bool]\combineitems Respectively, query the
-  number of bits of values of type @a@ and whether these values are
-  signed.  These functions never evaluate their argument.  The function
-  @bitSize@ is undefined for unbounded types (e.g., @Integer@).
-
-\item[shiftL,~~shiftR~~::\ Bits a => a -> Int -> a]
-\item[rotateL,~rotateR~::\ Bits a => a -> Int -> a]\combineitems The functions
-  @shiftR@ and @rotateR@ are synonyms for @shift@ and
-  @rotate@; @shiftL@ and @rotateL@ negate the second argument.
-  These operators have the following precedences as infix operators:
-  %
-  \begin{quote}
-\begin{verbatim}
-infixl 8 `shiftL`, `shiftR`, `rotateL`, `rotateR`
-\end{verbatim}
-  \end{quote}
-
-\end{codedesc}
-%
-Bits are numbered from 0 with bit 0 being the least significant bit.  A
-minimal complete definition of the type class @Bits@ must include
-definitions for the following functions: @(.&.)@, @(.|.)@,
-@xor@, @complement@, @shift@, @rotate@, @bitSize@,
-and @isSigned@. 
-
diff --git a/report/lib-data-intword.verb b/report/lib-data-intword.verb
deleted file mode 100644 (file)
index 9d538c9..0000000
+++ /dev/null
@@ -1,25 +0,0 @@
-\subsubsection{@Int@ and @Word@}
-\label{sec:Int-Word}
-
-The two modules @Int@ and @Word@ provide the following signed and
-unsigned integral types of fixed size:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Size in bits & Signed       & Unsigned\\\hline\hline
-    8            & @Int8@  & @Word8@\\
-    16           & @Int16@ & @Word16@\\
-    32           & @Int32@ & @Word32@\\
-    64           & @Int64@ & @Word64@\\
-    \hline
-  \end{tabular}
-\end{quote}
-%
-For these integral types, the modules @Int@ and @Word@ export class
-instances for the class @Bits@ and all type classes for which @Int@
-has an instance in the @Prelude@ and standard libraries.  The
-constraints on the implementation of these instances are also the same as
-those for @Int@ (Section~\ref{standard-numeric-types}).  There is, however, the
-additional constraint that all arithmetic on the fixed-sized types is
-performed modulo \(2^n\).
diff --git a/report/lib-foreign.verb b/report/lib-foreign.verb
deleted file mode 100644 (file)
index eda202a..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-\section{@Foreign@}
-\label{sec:Foreign}
-
-The module @Foreign@ combines the interfaces of all modules providing
-language-independent marshalling support, namely
-\begin{itemize}
-\item @Data.Bits@
-\item @Data.Int@
-\item @Data.Word@
-\item @Foreign.Ptr@
-\item @Foreign.ForeignPtr@
-\item @Foreign.StablePtr@
-\item @Foreign.Storable@
-\item @Foreign.Marshal.Alloc@
-\item @Foreign.Marshal.Array@
-\item @Foreign.Marshal.Error@
-\item @Foreign.Marshal.Utils@
-\end{itemize}
-
-% Removed from the FFI spec in favor of
-% Foreign.Marshal.unsafeLocalState in Haskell 2010:
-
-% Sometimes an external entity is a pure function, except that it passes
-% arguments and/or results via pointers.  To permit the packaging of
-% such entities as pure functions, @Foreign@ provides the following
-% primitive:
-% %
-% \begin{codedesc}
-% \item[unsafePerformIO ::\ IO a -> a] Return the value resulting from executing
-%   the @IO@ action.  This value should be independent of the environment;
-%   otherwise, the system behaviour is undefined.
-%   
-%   If the @IO@ computation wrapped in @unsafePerformIO@ performs side
-%   effects, then the relative order in which those side effects take place
-%   (relative to the main @IO@ trunk, or other calls to
-%   @unsafePerformIO@) is indeterminate.  Moreover, the side effects may be
-%   performed several times or not at all, depending on lazy evaluation and
-%   whether the compiler unfolds an enclosing definition.
-%   
-%   Great care should be exercised in the use of this primitive.  Not only
-%   because of the danger of introducing side effects, but also because
-%   @unsafePerformIO@ may compromise typing; to avoid this, the programmer
-%   should ensure that the result of @unsafePerformIO@ has a monomorphic
-%   type.
-% \end{codedesc}
diff --git a/report/lib-foreignptr.verb b/report/lib-foreignptr.verb
deleted file mode 100644 (file)
index 2b5d3e8..0000000
+++ /dev/null
@@ -1,174 +0,0 @@
-\section{@Foreign.ForeignPtr@}
-\label{sec:ForeignPtr}
-
-The type @ForeignPtr@ represents references to objects that are
-maintained in a foreign language, i.e., objects that are not part of the data
-structures usually managed by the Haskell storage manager.  The type
-@ForeignPtr@ is parameterised in the same way as @Ptr@ (cf.\ 
-Section~\ref{sec:Ptr}), but in contrast to vanilla memory references of type
-@Ptr@, @ForeignPtr@s 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
-free the resources bound by the foreign object.  Finalizers are generally
-implemented in the foreign language\footnote{Finalizers in Haskell cannot be
-  safely realised without requiring support for
-  concurrency~\cite{boehm:finalizers}.} and have either of the following two
-Haskell types:
-%
-\bprog
-@
-type FinalizerPtr        a = FunPtr (           Ptr a -> IO ())
-type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ())
-@
-\eprog
-%
-A foreign finalizer is represented as a pointer to a C function of type
-@Ptr a -> IO ()@ or a C function of type @Ptr env -> Ptr a -> IO ()@, where @Ptr env@ represents an optional environment passed to the
-finalizer on invocation.  That is, a foreign finalizer attached to a finalized
-pointer @ForeignPtr a@ gets the finalized pointer in the form of a raw
-pointer of type @Ptr a@ as an argument when it is invoked.  In addition,
-a foreign finalizer of type @FinalizerEnvPtr env a@ also gets an
-environment pointer of type @Ptr env@.  There is no guarantee on how soon
-the finalizer is executed after the last reference to the associated foreign
-pointer was dropped; this depends on the details of the Haskell storage
-manager.  The only guarantee is that the finalizer runs before the program
-terminates.  Whether a finalizer may call back into the Haskell system is
-system dependent.  Portable code may not rely on such callbacks.
-
-Foreign finalizers that expect an environment are a means to model closures in
-languages that do not support them natively, such as C.  They recover part of
-the convenience lost by requiring finalizers to be defined in the foreign
-languages rather than in Haskell.
-
-The data type @ForeignPtr@ and associated operations have the following
-signature and purpose:
-%
-\begin{codedesc}
-\item[data ForeignPtr a] A value of type @ForeignPtr a@ represents a
-  pointer to an object, or an array of objects, which may be marshalled to or
-  from Haskell values of type @a@.  The type @a@ will normally be an
-  instance of class @Storable@ (see Section~\ref{sec:Storable}), which
-  provides the marshalling operations.
-  
-  Instances for the classes @Eq@, @Ord@, and @Show@ are
-  provided.  Equality and ordering of two foreign pointers are the same as for
-  the plain pointers obtained with @unsafeForeignPtrToPtr@ from those
-  foreign pointers.
-  
-\item[newForeignPtr\_ ::\ Ptr a -> IO (ForeignPtr a)]
-  Turn a plain memory reference into a foreign pointer that may be associated
-  with finalizers by using @addForeignPtrFinalizer@.
-  
-\item[newForeignPtr ::\ FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)] This is
-  a convenience function that turns a plain memory reference into a foreign
-  pointer and immediately adds a finalizer.  It is defined as
-  %
-\bprog
-@
-newForeignPtr finalizer ptr = 
-  do
-    fp <- newForeignPtr_ ptr
-    addForeignPtrFinalizer finalizer fp
-    return fp
-@
-\eprog
-   
-\item[newForeignPtrEnv ::\ FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO
-  (ForeignPtr a)] 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@.
-
-\item[addForeignPtrFinalizer ::\ FinalizerPtr a -> ForeignPtr a -> IO
-  ()] Add a finalizer to the given foreign pointer.  All finalizers
-  associated with a single foreign pointer are executed in the opposite order
-  of their addition---i.e., the finalizer added last will be executed first.
-  
-\item[addForeignPtrFinalizerEnv ::\ FinalizerEnvPtr env a -> Ptr env ->
-  ForeignPtr a]
-\item[~~~~~~~~~~~~~~~~~~~~~~~~~~-> IO ()]\combineitems Add a finalizer that
-  expects an environment to an existing foreign pointer.
-
-\item[mallocForeignPtr ::\ Storable a => IO (ForeignPtr a)] Allocate a block
-  of memory that is sufficient to hold values of type @a@.  The size of
-  the memory area is determined by the function @Storable.sizeOf@
-  (Section~\ref{sec:Storable}).  This corresponds to
-  @Foreign.Marshal.Alloc.malloc@ (Section~\ref{sec:MarshalAlloc}), but
-  automatically attaches a finalizer that frees the block of memory as soon as
-  all references to that block of of memory have been dropped.  It is
-  \emph{not} guaranteed that the block of memory was allocated by
-  @Foreign.Marshal.Alloc.malloc@; so, @Foreign.Marshal.Alloc.realloc@ must not be
-  applied to the resulting pointer.
-
-\item[mallocForeignPtrBytes ::\ Int -> IO (ForeignPtr a)] Allocate a block of
-  memory of the given number of bytes with a finalizer attached that frees the
-  block of memory as soon as all references to that block of memory have
-  been dropped.  As for @mallocForeignPtr@, @Foreign.Marshal.Alloc.realloc@
-  must not be applied to the resulting pointer.
-
-\item[mallocForeignPtrArray~ ::\ Storable a => Int -> IO (ForeignPtr a)]
-\item[mallocForeignPtrArray0 ::\ Storable a => Int -> IO (ForeignPtr a)]%
-  \combineitems These functions correspond to @Foreign.Marshal.Array@'s
-  @mallocArray@ and @mallocArray0@, respectively, but yield a memory
-  area that has a finalizer attached that releases the memory area.  As with
-  the previous two functions, it is not guaranteed that the block of memory
-  was allocated by @Foreign.Marshal.Alloc.malloc@.
-  
-\item[withForeignPtr ::\ ForeignPtr a -> (Ptr a -> IO b) -> IO b]
-  This is a way to obtain the pointer living inside a foreign pointer. This
-  function takes a function which is applied to that pointer. The resulting
-  @IO@ action is then executed. The foreign pointer 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.
-
-  More precisely, the foreign pointer may be finalized after
-  @withForeignPtr@ is finished if the first argument was the last
-  occurrence of that foreign pointer.  Finalisation of the foreign pointer
-  might render the pointer that is passed to the function useless.
-  Consequently, this pointer cannot be used safely anymore after the
-  @withForeignPtr@ is finished, unless the function
-  @touchForeignPtr@ is used to explicitly keep the foreign pointer alive.
-  
-  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.
-
-\item[unsafeForeignPtrToPtr ::\ ForeignPtr a -> Ptr a]
-  Extract the pointer component of a foreign pointer. This is a potentially
-  dangerous operation.  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.
-  
-  It should be noticed that this function does not need to be monadic when
-  used in combination with @touchForeignPtr@.  Until the
-  @unsafeForeignPtrToPtr@ is executed, the thunk representing the
-  suspended call keeps the foreign pointer alive.  Afterwards, the
-  @touchForeignPtr@ keeps the pointer alive.
-  
-  To avoid subtle coding errors, hand written marshalling code should
-  preferably use the function @withForeignPtr@ rather than
-  @unsafeForeignPtrToPtr@ and @touchForeignPtr@. However, the later
-  routines are occasionally preferred in tool-generated marshalling code.
-  
-\item[touchForeignPtr ::\ ForeignPtr a -> IO ()] Ensure that the foreign
-  pointer 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.
-  
-  This function can be used to express liveness dependencies between
-  @ForeignPtr@s: For example, if the finalizer for one @ForeignPtr@
-  touches a second @ForeignPtr@, then it is ensured that the second
-  @ForeignPtr@ will stay alive at least as long as the first. This can be
-  useful when you want to manipulate interior pointers to a foreign structure:
-  You can use @touchForeignPtr@ to express the requirement that the
-  exterior pointer must not be finalized until the interior pointer is no
-  longer referenced.
-    
-\item[castForeignPtr ::\ ForeignPtr a -> ForeignPtr b] Cast a
-  @ForeignPtr@ parameterised by one type into another type.
-\end{codedesc}
diff --git a/report/lib-marshal.verb b/report/lib-marshal.verb
deleted file mode 100644 (file)
index fc6974e..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-\section{@Foreign.Marshal@}
-\label{sec:ForeignMarshal}
-
-\begin{outlineenv}
-@
-module Foreign.Marshal
-        ( module Foreign.Marshal.Alloc
-        , module Foreign.Marshal.Array
-        , module Foreign.Marshal.Error
-        , module Foreign.Marshal.Utils
-        , unsafeLocalState
-        ) where
-
-import Foreign.Marshal.Alloc
-import Foreign.Marshal.Array
-import Foreign.Marshal.Error
-import Foreign.Marshal.Utils
-
-unsafeLocalState :: IO a -> a
-@
-\end{outlineenv}
-
-% Sometimes an external entity is a pure function, except that it passes
-% arguments and/or results via pointers.  To permit the packaging of
-% such entities as pure functions, @Foreign@ provides the following
-% primitive:
-% %
-% \begin{codedesc}
-% \item[unsafePerformIO ::\ IO a -> a] Return the value resulting from executing
-%   the @IO@ action.  This value should be independent of the environment;
-%   otherwise, the system behaviour is undefined.
-%   
-%   If the @IO@ computation wrapped in @unsafePerformIO@ performs side
-%   effects, then the relative order in which those side effects take place
-%   (relative to the main @IO@ trunk, or other calls to
-%   @unsafePerformIO@) is indeterminate.  Moreover, the side effects may be
-%   performed several times or not at all, depending on lazy evaluation and
-%   whether the compiler unfolds an enclosing definition.
-%   
-%   Great care should be exercised in the use of this primitive.  Not only
-%   because of the danger of introducing side effects, but also because
-%   @unsafePerformIO@ may compromise typing; to avoid this, the programmer
-%   should ensure that the result of @unsafePerformIO@ has a monomorphic
-%   type.
-% \end{codedesc}
-
-The module @Foreign.Marshal@ re-exports the other modules in the
-@Foreign.Marshal@ hierarchy, and defines one function:
-
-
-\begin{codedesc}
-\item[unsafeLocalState ::\ IO a -> a]
-Sometimes an external entity is a pure function, except that it passes
-arguments and/or results via pointers.  The function
-@unsafeLocalState@ permits the packaging of such entities as pure
-functions.  
-
-The only IO operations allowed in the IO action passed to
-@unsafeLocalState@ are (a) local allocation (@alloca@, @allocaBytes@
-and derived operations such as @withArray@ and @withCString@), and (b)
-pointer operations (@Foreign.Storable@ and @Foreign.Ptr@) on the
-pointers to local storage, and (c) foreign functions whose only
-observable effect is to read and/or write the locally allocated
-memory.  Passing an IO operation that does not obey these rules
-results in undefined behaviour.
-
-It is expected that this operation will be
-replaced in a future revision of Haskell.
-\end{codedesc}
diff --git a/report/lib-marshalalloc.verb b/report/lib-marshalalloc.verb
deleted file mode 100644 (file)
index aab0cf7..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-\section{@Foreign.Marshal.Alloc@}
-\label{sec:MarshalAlloc}
-
-The module @Foreign.Marshal.Alloc@ provides operations to allocate and deallocate
-blocks of raw memory (i.e., unstructured chunks of memory outside of the area
-maintained by the Haskell storage manager).  These memory blocks are commonly
-used to pass compound data structures to foreign functions or to provide space
-in which compound result values are obtained from foreign functions.  For
-example, Haskell lists are typically passed as C arrays to C functions; the
-storage space for such an array can be allocated by the following functions:
-%
-\begin{codedesc}
-\item[malloc ::\ Storable a => IO (Ptr a)] Allocate a block of memory that is
-  sufficient to hold values of type @a@.  The size of the memory area is
-  determined by the function @Storable.sizeOf@
-  (Section~\ref{sec:Storable}).
-
-\item[mallocBytes ::\ Int -> IO (Ptr a)] Allocate a block of memory of the
-  given number of bytes.  The block of memory is sufficiently aligned for any
-  of the basic foreign types (see Section~\ref{sec:foreign-types}) that fits
-  into a memory block of the allocated size.
-  
-\item[alloca ::\ Storable a => (Ptr a -> IO b) -> IO b] Allocate a block of
-  memory of the same size as @malloc@, but the reference is passed to a
-  computation instead of being returned.  When the computation terminates,
-  free the memory area again.  The operation is exception-safe; i.e.,
-  allocated memory is freed if an exception is thrown in the marshalling
-  computation.
-
-\item[allocaBytes ::\ Int -> (Ptr a -> IO b) -> IO b] As @alloca@, but
-  allocate a memory area of the given size.  The same alignment constraint as
-  for @mallocBytes@ holds.
-  
-\item[realloc ::\ Storable b => Ptr a -> IO (Ptr b)] Resize a memory area that
-  was allocated with @malloc@ or @mallocBytes@ to the size needed to
-  store values of type @b@.  The returned pointer may refer to an
-  entirely different memory area, but will be suitably aligned to hold values
-  of type @b@.  The contents of the referenced memory area will be the
-  same as of the original pointer up to the minimum of the size of values of
-  type @a@ and @b@.  If the argument to @realloc@ is
-  @Ptr.nullPtr@, @realloc@ behaves like @malloc@.
-  
-\item[reallocBytes ::\ Ptr a -> Int -> IO (Ptr a)] As @realloc@, but
-  allocate a memory area of the given size.  In addition, if the requested size
-  is 0, @reallocBytes@ behaves like @free@.
-  
-\item[free ::\ Ptr a -> IO ()] Free a block of memory that was allocated with
-  @malloc@, @mallocBytes@, @realloc@, @reallocBytes@, or
-  any of the allocation functions from @Foreign.Marshal.Array@ (see
-  Section~\ref{sec:MarshalArray}).
-
-\item[finalizerFree ::\ FinalizerPtr a] Foreign finalizer that performs the
-  same operation as @free@.
-\end{codedesc}
-%
-If any of the allocation functions fails, a value of @Ptr.nullPtr@ is
-produced.  If @free@ or @reallocBytes@ is applied to a memory area
-that has been allocated with @alloca@ or @allocaBytes@, the
-behaviour is undefined.  Any further access to memory areas allocated with
-@alloca@ or @allocaBytes@, after the computation that was passed to
-the allocation function has terminated, leads to undefined behaviour.  Any
-further access to the memory area referenced by a pointer passed to
-@realloc@, @reallocBytes@, or @free@ entails undefined
-behaviour.
diff --git a/report/lib-marshalarray.verb b/report/lib-marshalarray.verb
deleted file mode 100644 (file)
index 3dc1a21..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-\section{@Foreign.Marshal.Array@}
-\label{sec:MarshalArray}
-
-The module @Foreign.Marshal.Array@ provides operations for marshalling Haskell
-lists into monolithic arrays and vice versa.  Most functions come in two
-flavours: one for arrays terminated by a special termination element and one
-where an explicit length parameter is used to determine the extent of an
-array.  The typical example for the former case are C's NUL terminated
-strings.  However, please note that C strings should usually be marshalled
-using the functions provided by @Foreign.C.String@ (Section~\ref{sec:CString}) as
-the Unicode encoding has to be taken into account.  All functions specifically
-operating on arrays that are terminated by a special termination element have
-a name ending on @0@---e.g., @mallocArray@ allocates space for an
-array of the given size, whereas @mallocArray0@ allocates space for one
-more element to ensure that there is room for the terminator.
-
-The following functions are provided by the module:
-%
-\begin{codedesc}
-\item[mallocArray~~::\ Storable a => Int -> IO (Ptr a)]
-\item[allocaArray~~::\ Storable a => Int -> (Ptr a -> IO b) -> IO b]
-  \combineitems
-\item[reallocArray~::\ Storable a => Ptr a -> Int -> IO (Ptr a)]\combineitems
-  The functions behave like the functions @malloc@, @alloca@, and
-  @realloc@ provided by the module @Foreign.Marshal.Alloc@
-  (Section~\ref{sec:MarshalAlloc}), respectively, except that they allocate a
-  memory area that can hold an array of elements of the given length, instead
-  of storage for just a single element.
-
-\item[mallocArray0~~::\ Storable a => Int -> IO (Ptr a)]
-\item[allocaArray0~~::\ Storable a => Int -> (Ptr a -> IO b) -> IO b]\combineitems
-\item[reallocArray0~::\ Storable a => Ptr a -> Int -> IO (Ptr a)]\combineitems
-  These functions are like the previous three functions, but reserve storage
-  space for one additional array element to allow for a termination indicator.
-  
-\item[peekArray ::\ Storable a => Int -> Ptr a -> IO {[a]}] Marshal an array of
-  the given length and starting at the address indicated by the pointer
-  argument into a Haskell list using @Storable.peekElemOff@ to obtain the
-  individual elements.  The order of elements in the list matches the order in
-  the array.
-  
-\item[pokeArray ::\ Storable a => Ptr a -> {[a]} -> IO ()] Marshal the elements
-  of the given list into an array whose start address is determined by the
-  first argument using @Storable.pokeElemOff@ to write the individual
-  elements.  The order of elements in the array matches that in the list.
-  
-\item[peekArray0 ::\ (Storable a, Eq a) => a -> Ptr a -> IO {[a]}] Marshal an
-  array like @peekArray@, but instead of the length of the array a
-  terminator element is specified by the first argument.  All elements of the
-  array, starting with the first element, up to, but excluding the first
-  occurrence of an element that is equal (as determined by @==@) to the
-  terminator are marshalled.
-
-\item[pokeArray0 ::\ Storable a => a -> Ptr a -> {[a]} -> IO ()]
-  Marshal an array like @pokeArray@, but write a terminator value
-  (determined by the first argument) after the last element of the list.  Note
-  that the terminator must not occur in the marshalled list if it should be
-  possible to extract the list with @peekArray0@.
-
-\item[newArray~~::\ Storable a => {[a]} -> IO (Ptr a)]
-\item[withArray~::\ Storable a => {[a]} -> (Ptr a -> IO b) -> IO b]\combineitems
-  These two functions combine @mallocArray@ and @allocaArray@,
-  respectively, with @pokeArray@; i.e., they allocate a memory area for
-  an array whose length matches that of the list, and then, marshal the list
-  into that memory area.
-
-\item[newArray0~~::\ Storable a => a -> {[a]} -> IO (Ptr a)]
-\item[withArray0~::\ Storable a => a -> {[a]} -> (Ptr a -> IO b) -> IO b]\combineitems
-  These two functions combine @mallocArray0@ and @allocaArray0@,
-  respectively, with the function @pokeArray0@; i.e., they allocate a
-  memory area for 
-  an array whose length matches that of the list, and then, marshal the list
-  into that memory area.  The first argument determines the terminator.
-
-\item[copyArray ::\ Storable a => Ptr a -> Ptr a -> Int -> IO ()]
-\item[moveArray ::\ Storable a => Ptr a -> Ptr a -> Int -> IO ()]\combineitems
-  These two functions copy entire arrays and behave like the routines
-  @Foreign.Marshal.Utils.copyBytes@ and @Foreign.Marshal.Utils.moveBytes@,
-  respectively (Section~\ref{sec:MarshalUtils}).  In particular,
-  @moveArray@ allows the source and destination array to overlap, whereas
-  @copyArray@ does not allow overlapping arrays.  Both functions take a
-  reference to the destination array as their first, and a reference to the
-  source as their second argument.  However, in contrast to the routines from
-  @Foreign.Marshal.Utils@ the third argument here specifies the number of array
-  elements (whose type is specified by the parametrised pointer arguments)
-  instead of the number of bytes to copy.
-  
-\item[lengthArray0 ::\ (Storable a, Eq a) => a -> Ptr a -> IO Int] Determine
-  the length of an array whose end is marked by the first occurrence of the
-  given terminator (first argument). The length is measured in array elements
-  (not bytes) and does not include the terminator.
-  
-\item[advancePtr ::\ Storable a => Ptr a -> Int -> Ptr a] Advance a reference
-  to an array by as many array elements (not bytes) as specified.
-\end{codedesc}
-
diff --git a/report/lib-marshalerror.verb b/report/lib-marshalerror.verb
deleted file mode 100644 (file)
index e9cf47d..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-\section{@Foreign.Marshal.Error@}
-\label{sec:MarshalError}
-
-The module @Foreign.Marshal.Error@ provides language independent routines for
-converting error conditions of external functions into Haskell @IO@ monad
-exceptions.  It consists out of two parts.  The first part extends the I/O
-error facilities of the @IO@ module (Section~\ref{IO}) with
-functionality to construct I/O errors.  The second part provides a set of
-functions that ease turning exceptional result values into I/O errors.
-
-\paragraph{I/O Errors}
-%
-The following functions can be used to construct values of type
-@IOError@.
-%
-\begin{codedesc}
-\item[data IOErrorType] This is an abstract type that contains a value for
-  each variant of @IOError@.
-
-\item[mkIOError ::\ IOErrorType -> String -> Maybe Handle -> Maybe FilePath
-  -> IOError] Construct an @IOError@ of the given type where the second
-  argument describes the error location and the third and fourth argument
-  contain the file handle and file path of the file involved in the error if
-  applicable. 
-  
-\item[alreadyExistsErrorType ::\ IOErrorType] I/O error where the operation
-  failed because one of its arguments already exists.
-  
-\item[doesNotExistErrorType ::\ IOErrorType] I/O error where the operation
-  failed because one of its arguments does not exist.
-  
-\item[alreadyInUseErrorType ::\ IOErrorType] I/O error where the operation
-  failed because one of its arguments is a single-use resource, which is
-  already being used.
-  
-\item[fullErrorType ::\ IOErrorType] I/O error where the operation failed
-  because the device is full.
-  
-\item[eofErrorType ::\ IOErrorType] I/O error where the operation failed
-  because the end of file has been reached.
-  
-\item[illegalOperationType ::\ IOErrorType] I/O error where the operation is
-  not possible.
-  
-\item[permissionErrorType ::\ IOErrorType] I/O error where the operation failed
-  because the user does not have sufficient operating system privilege to
-  perform that operation.
-
-\item[userErrorType ::\ IOErrorType] I/O error that is programmer-defined.
-
-\item[annotateIOError ::\ IOError -> String -> Maybe Handle -> Maybe
-  FilePath -> IOError] Adds a location description and maybe a file path and
-  file handle to an I/O error.  If any of the file handle or file path is not
-  given the corresponding value in the I/O error remains unaltered.
-\end{codedesc}
-
-\paragraph{Result Value Checks}
-
-The following routines are useful for testing return values and raising an I/O
-exception in case of values indicating an error state.
-%
-\begin{codedesc}
-\item[throwIf ::\ (a -> Bool) -> (a -> String) -> IO a -> IO a] Execute the
-  computation determined by the third argument.  If the predicate provided in
-  the first argument yields @True@ when applied to the result of that
-  computation, raise an @IO@ exception that includes an error message
-  obtained by applying the second argument to the result of the computation.
-  If no exception is raised, the result of the computation is the result of
-  the whole operation.
-
-\item[throwIf\_ ::\ (a -> Bool) -> (a -> String) -> IO a -> IO ()]
-  Operate as @throwIf@ does, but discard the result of the computation
-  in any case.
-
-\item[throwIfNeg~~::\ (Ord a, Num a) => (a -> String) -> IO a -> IO a]
-\item[throwIfNeg\_~::\ (Ord a, Num a) => (a -> String) -> IO a -> IO ()]\combineitems
-  These two functions are instances of @throwIf@ and @throwIf_@,
-  respectively, where the predicate is @(< 0)@.
-  
-\item[throwIfNull ::\ String -> IO (Ptr a) -> IO (Ptr a)] This is an instance
-  of @throwIf@, where the predicate is @(== Ptr.nullPtr)@ and the
-  error message is constant.
-
-\item[void ::\ IO a -> IO ()]
-  Discard the result of a computation.
-\end{codedesc}
-
diff --git a/report/lib-marshalutils.verb b/report/lib-marshalutils.verb
deleted file mode 100644 (file)
index df56f13..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-\section{@Foreign.Marshal.Utils@}
-\label{sec:MarshalUtils}
-
-Finally, the module @Foreign.Marshal.Utils@ provides a set of useful auxiliary
-routines. 
-%
-\begin{codedesc}
-\item[new ::\ Storable a => a -> IO (Ptr a)] This function first applies
-  @Foreign.Marshal.Alloc.malloc@ (Section~\ref{sec:MarshalAlloc}) to its
-  argument, and then, stores the argument in the newly allocated memory area
-  using @Foreign.Storable.poke@ (Section~\ref{sec:Storable}).
-  
-\item[with ::\ Storable a => a -> (Ptr a -> IO b) -> IO b] This function is
-  like @new@, but uses @Foreign.Marshal.Alloc.alloca@ instead of
-  @Foreign.Marshal.Alloc.malloc@.
-
-\item[fromBool~::\ Num a => Bool -> a]
-\item[toBool~~~::\ Num a => a -> Bool]\combineitems These two functions
-  implement conversions between Haskell Boolean values and numeric
-  representations of Boolean values, where @False@ is represented by
-  @0@ and @True@ by any non-zero value.
-
-\item[maybeNew ::\ (a -> IO (Ptr a)) -> (Maybe a -> IO (Ptr a))]
-  Lift a function that marshals a value of type @a@ to a function that
-  marshals a value of type @Maybe a@.  In case, where the latter is
-  @Nothing@, return @Ptr.nullPtr@ (Section~\ref{sec:Ptr})
-
-\item[maybeWith ::\ (a -> (Ptr b -> IO c) -> IO c)%
-  -> (Maybe a -> (Ptr b -> IO c) -> IO c)] This function lifts a
-  @Foreign.Marshal.Alloc.alloca@ based marshalling function for @a@ to
-  @Maybe a@.  It marshals values @Nothing@ in the same way as
-  @maybeNew@. 
-  
-\item[maybePeek ::\ (Ptr a -> IO b) -> (Ptr a -> IO (Maybe b))] Given a
-  function that marshals a value stored in the referenced memory area to a
-  value of type @b@, lift it to producing a value of type @Maybe b@.
-  If the pointer is @Ptr.nullPtr@, produce @Nothing@.
-  
-% Move to `Data.List.withMany' in new library spec.
-%\item[withMany ::\ (a -> (b -> res) -> res) -> {[a]} -> ({[b]} -> res) -> res]
-%  Lift a marshalling function of the @with@ family to operate on a list
-%  of values.
-
-\item[copyBytes ::\ Ptr a -> Ptr a -> Int -> IO ()]
-\item[moveBytes ::\ Ptr a -> Ptr a -> Int -> IO ()]\combineitems These two
-  functions are Haskell variants of the standard C library routines
-  @memcpy()@ and @memmove()@, respectively.  As with their C
-  counterparts, @moveBytes@ allows the source and destination array to
-  overlap, whereas @copyBytes@ does not allow overlapping areas.  Both
-  functions take a reference to the destination area as their first, and a
-  reference to the source as their second argument---i.e., the argument order
-  is as in an assignment.
-\end{codedesc}
diff --git a/report/lib-ptr.verb b/report/lib-ptr.verb
deleted file mode 100644 (file)
index 5936dd8..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-\section{@Foreign.Ptr@}
-\label{sec:Ptr}
-
-The module @Foreign.Ptr@ provides typed pointers to foreign entities.  We
-distinguish two kinds of pointers: pointers to data and pointers to functions.
-It is understood that these two kinds of pointers may be represented
-differently as they may be references to data and text segments, respectively.
-
-\paragraph{Data Pointers}
-
-The interface defining data pointers and associated operations is as follows:
-%
-\begin{codedesc}
-\item[data Ptr a] A value of type @Ptr a@ represents a pointer to an
-  object, or an array of objects, which may be marshalled to or from Haskell
-  values of type @a@.  The type @a@ will normally be an instance of
-  class @Storable@ (see Section~\ref{sec:Storable}), which provides the
-  necessary marshalling operations.
-
-  Instances for the classes @Eq@, @Ord@, and @Show@ are
-  provided. 
-\item[nullPtr ::\ Ptr a] The constant @nullPtr@ contains a distinguished
-  value of @Ptr@ that is not associated with a valid memory location.
-\item[castPtr ::\ Ptr a -> Ptr b] The @castPtr@ function casts a pointer
-  from one type to another.
-\item[plusPtr ::\ Ptr a -> Int -> Ptr b] Advances the given address by the
-  given offset in bytes.
-\item[alignPtr ::\ Ptr a -> Int -> Ptr a] Given an arbitrary address and an
-  alignment constraint, @alignPtr@ yields an address, the same or next
-  higher, that fulfills the alignment constraint. An alignment constraint
-  @x@ is fulfilled by any address divisible by @x@. This operation
-  is idempotent.
-\item[minusPtr ::\ Ptr a -> Ptr b -> Int] Compute the offset required to get
-  from the first to the second argument.  We have
-  %
-  \begin{quote}
-\begin{verbatim}
-p2 == p1 `plusPtr` (p2 `minusPtr` p1)
-\end{verbatim}
-  \end{quote}
-\end{codedesc}
-%
-It should be noted that the use of @Int@ for pointer differences
-essentially forces any implementation to represent @Int@ in as many bits
-as used in the representation of pointer values.
-
-\paragraph{Function Pointers}
-
-The interface defining function pointers and associated operations is as
-follows:
-%
-\begin{codedesc}
-\item[data FunPtr a] A value of type @FunPtr a@ is a pointer to a piece
-  of code.  It may be the pointer to a C function or to a Haskell function
-  created using a wrapper stub as outlined in Section~\ref{sec:ccall}. For
-  example,
-  %
-  \begin{quote}
-\begin{verbatim}
-type Compare = Int -> Int -> Bool
-foreign import ccall "wrapper" 
-  mkCompare :: Compare -> IO (FunPtr Compare)
-\end{verbatim}
-  \end{quote}
-  
-  Instances for the classes @Eq@, @Ord@, and @Show@ are
-  provided.
-\item[nullFunPtr ::\ FunPtr a] The constant @nullFunPtr@ contains a
-  distinguished value of @FunPtr@ that is not associated with a valid
-  memory location.
-\item[castFunPtr ::\ FunPtr a -> FunPtr b] Cast a @FunPtr@ to a
-  @FunPtr@ of a different type.
-\item[freeHaskellFunPtr ::\ FunPtr a -> IO ()] 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.
-\end{codedesc}
-
-Moreover, there are two functions that are only valid on architectures where
-data and function pointers range over the same set of addresses.  Only where
-bindings to external libraries are made whose interface already relies on this
-assumption, should the use of @castFunPtrToPtr@ and
-@castPtrToFunPtr@ be considered; otherwise, it is recommended to avoid
-using these functions.
-%
-\begin{codedesc}
-\item[castFunPtrToPtr ::\ FunPtr a -> Ptr b]
-\item[castPtrToFunPtr ::\ Ptr a -> FunPtr b] \combineitems These two functions
-  cast @Ptr@s to @FunPtr@s and vice versa.
-\end{codedesc}
diff --git a/report/lib-stableptr.verb b/report/lib-stableptr.verb
deleted file mode 100644 (file)
index a5aef9e..0000000
+++ /dev/null
@@ -1,59 +0,0 @@
-\section{@Foreign.StablePtr@}
-\label{sec:StablePtr}
-
-A \emph{stable pointer} is a reference to a Haskell expression that is
-guaranteed not to be affected by garbage collection, i.e., it will neither be
-deallocated nor will the value of the stable pointer itself change during
-garbage collection (ordinary references may be relocated during garbage
-collection).  Consequently, stable pointers can be passed to foreign code,
-which can treat it as an opaque reference to a Haskell value.
-
-The data type and associated operations have the following signature and
-purpose:
-%
-\begin{codedesc}
-\item[data StablePtr a] Values of this type represent a stable reference to a
-  Haskell value of type @a@.
-  
-\item[newStablePtr ::\ a -> IO (StablePtr a)] Create a stable pointer
-  referring to the given Haskell value.
-  
-\item[deRefStablePtr ::\ StablePtr a -> IO a] Obtain the Haskell value
-  referenced by a stable pointer, i.e., the same value that was passed to the
-  corresponding call to @makeStablePtr@.  If the argument to
-  @deRefStablePtr@ has already been freed using @freeStablePtr@, the
-  behaviour of @deRefStablePtr@ is undefined.
-  
-\item[freeStablePtr ::\ StablePtr a -> IO ()] 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 @Ptr ()@ value returned by
-  @castStablePtrToPtr@, in this case, is undefined (in particular, it may
-  be @Ptr.nullPtr@).  Nevertheless, the call to @castStablePtrToPtr@
-  is guaranteed not to diverge.
-  
-\item[castStablePtrToPtr ::\ StablePtr a -> Ptr ()] Coerce a stable pointer to
-  an address. No guarantees are made about the resulting value, except that
-  the original stable pointer can be recovered by @castPtrToStablePtr@.
-  In particular, the address may not refer to an accessible memory location and
-  any attempt to pass it to the member functions of the class @Storable@
-  (Section~\ref{sec:Storable}) leads to undefined behaviour.
-  
-\item[castPtrToStablePtr ::\ Ptr () -> StablePtr a] The inverse of
-  @castStablePtrToPtr@, i.e., we have the identity
-  %
-  \begin{quote}
-\begin{verbatim}
-sp == castPtrToStablePtr (castStablePtrToPtr sp)
-\end{verbatim}
-  \end{quote}
-  %
-  for any stable pointer @sp@ on which @freeStablePtr@ has not been
-  executed yet.  Moreover, @castPtrToStablePtr@ may only be applied to
-  pointers that have been produced by @castStablePtrToPtr@.
-\end{codedesc}
-
-It is important to free stable pointers that are no longer required by using
-@freeStablePtr@.  Otherwise, the object referenced by the stable pointer
-will be retained in the heap.
diff --git a/report/lib-storable.verb b/report/lib-storable.verb
deleted file mode 100644 (file)
index 13f932c..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-\section{@Foreign.Storable@}
-\label{sec:Storable}
-
-To code marshalling in Haskell, Haskell data structures need to be translated
-into the binary representation of a corresponding data structure of the
-foreign language and vice versa.  To this end, the module @Foreign.Storable@
-provides routines that manipulate primitive data types stored in unstructured
-memory blocks.  The class @Storable@ is instantiated for all primitive
-types that can be stored in raw memory.  Reading and writing these types to
-arbitrary memory locations is implemented by the member functions of the
-class.  The member functions, furthermore, encompass support for computing the
-storage requirements and alignment restrictions of storable types.
-
-Memory addresses are represented as values of type @Ptr a@
-(Section~\ref{sec:Ptr}), where @a@ is a storable type.  The type argument
-to @Ptr@ provides some type safety in marshalling code, as pointers to
-different types cannot be mixed without an explicit cast.  Moreover, it
-assists in resolving overloading.
-
-The class @Storable@ is instantiated for all standard basic types of
-Haskell, the fixed size integral types of the modules @Int@ and
-@Word@ (Section~\ref{sec:Int-Word}), data and function pointers
-(Section~\ref{sec:Ptr}), and stable pointers (Section~\ref{sec:StablePtr}).
-There is no instance of @Storable@ for foreign pointers.  The intention
-is to ensure that storing a foreign pointer requires an explicit cast to a
-plain @Ptr@, which makes it obvious that the finalizers of the foreign
-pointer may be invoked at this point if no other reference to the pointer
-exists anymore.
-
-The signatures and behaviour of the member functions of the class
-@Storable@ are as follows:
-%
-\begin{codedesc}
-\item[sizeOf~~~~::\ Storable a => a -> Int]
-\item[alignment~::\ Storable a => a -> Int]\combineitems The function
-  @sizeOf@ computes the storage requirements (in bytes) of the argument,
-  and alignment computes the alignment constraint of the argument.  An
-  alignment constraint @x@ is fulfilled by any address divisible by
-  @x@. Both functions do not evaluate their argument, but compute the
-  result on the basis of the type of the argument alone.  We require that the
-  size is divisible by the alignment.  (Thus each element of a contiguous
-  array of storable values will be properly aligned if the first one is.)
-
-\item[peekElemOff ::\ Storable a => Ptr a -> Int -> IO a] Read a value from a
-  memory area regarded as an array of values of the same kind. The first
-  argument specifies the start address of the array and the second the index
-  into the array (the first element of the array has index 0).
-  
-\item[pokeElemOff ::\ Storable a => Ptr a -> Int -> a -> IO ()] Write a value
-  to a memory area regarded as an array of values of the same kind.  The first
-  and second argument are as for @peekElemOff@.
-  
-\item[peekByteOff ::\ Storable a => Ptr b -> Int -> IO a] Read a value from a
-  memory location given by a base address and byte offset from that base
-  address.
-  
-\item[pokeByteOff ::\ Storable a => Ptr b -> Int -> a -> IO ()] Write a value
-  to a memory location given by a base address and offset from that base
-  address.
-  
-\item[peek ::\ Storable a => Ptr a -> IO a] Read a value from the given memory
-  location.
-  
-\item[poke ::\ Storable a => Ptr a -> a -> IO ()] Write the given value to the
-  given memory location.
-\end{codedesc}
-%
-On some architectures, the @peek@ and @poke@ functions might require
-properly aligned addresses to function correctly.  Thus, portable code should
-ensure that when peeking or poking values of some type @a@, the alignment
-constraint for @a@, as given by the function @alignment@ is
-fulfilled.
-
-A minimal complete definition of @Storable@ needs to define
-@sizeOf@, @alignment@, one of @peek@, @peekElemOff@, or
-@peekByteOff@, and one of @poke@, @pokeElemOff@, and
-@pokeByteOff@.