remove obsolete sources
authorSimon Marlow <marlowsd@gmail.com>
Wed, 30 Jun 2010 14:22:24 +0000 (14:22 +0000)
committerSimon Marlow <marlowsd@gmail.com>
Wed, 30 Jun 2010 14:22:24 +0000 (14:22 +0000)
68 files changed:
ffi/COPYING.ffi [deleted file]
ffi/Makefile [deleted file]
ffi/Makefile.ffi [deleted file]
ffi/ffi.bib [deleted file]
ffi/ffi.cfg [deleted file]
ffi/ffi.tex [deleted file]
ffi/finalizers.txt [deleted file]
ffi/threads.tex [deleted file]
hierarchical-modules/Makefile [deleted file]
hierarchical-modules/hier.tex [deleted file]
hierarchical-modules/index.html [deleted file]
libraries/Makefile [deleted file]
libraries/README [deleted file]
libraries/array.verb [deleted file]
libraries/char.verb [deleted file]
libraries/code/Array.hs [deleted file]
libraries/code/Char.hs [deleted file]
libraries/code/Complex.hs [deleted file]
libraries/code/IO.hs [deleted file]
libraries/code/Ix.hs [deleted file]
libraries/code/List.hs [deleted file]
libraries/code/Locale.hs [deleted file]
libraries/code/Maybe.hs [deleted file]
libraries/code/Monad.hs [deleted file]
libraries/code/Numeric.hs [deleted file]
libraries/code/Random.hs [deleted file]
libraries/code/Ratio.hs [deleted file]
libraries/code/Time.hs [deleted file]
libraries/complex.verb [deleted file]
libraries/cputime.verb [deleted file]
libraries/directory.verb [deleted file]
libraries/h98-libs.gif [deleted file]
libraries/h98-libs.ppt [deleted file]
libraries/headers/Array.hs [deleted file]
libraries/headers/CPUTime.hs [deleted file]
libraries/headers/Char.hs [deleted file]
libraries/headers/Complex.hs [deleted file]
libraries/headers/Directory.hs [deleted file]
libraries/headers/IO.hs [deleted file]
libraries/headers/IO1.hs [deleted file]
libraries/headers/Ix.hs [deleted file]
libraries/headers/List.hs [deleted file]
libraries/headers/List1.hs [deleted file]
libraries/headers/Locale.hs [deleted file]
libraries/headers/Maybe.hs [deleted file]
libraries/headers/Monad.hs [deleted file]
libraries/headers/Numeric.hs [deleted file]
libraries/headers/Random.hs [deleted file]
libraries/headers/Ratio.hs [deleted file]
libraries/headers/System.hs [deleted file]
libraries/headers/Time.hs [deleted file]
libraries/headers/Time1.hs [deleted file]
libraries/html.config [deleted file]
libraries/index-intro.verb [deleted file]
libraries/index.html [deleted file]
libraries/introduction.verb [deleted file]
libraries/io.verb [deleted file]
libraries/ix.verb [deleted file]
libraries/library.verb [deleted file]
libraries/list.verb [deleted file]
libraries/locale.verb [deleted file]
libraries/maybe.verb [deleted file]
libraries/monad.verb [deleted file]
libraries/numeric.verb [deleted file]
libraries/random.verb [deleted file]
libraries/ratio.verb [deleted file]
libraries/system.verb [deleted file]
libraries/time.verb [deleted file]

diff --git a/ffi/COPYING.ffi b/ffi/COPYING.ffi
deleted file mode 100644 (file)
index cbfffb8..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-Copyright [2002..2003] Manuel M T Chakravarty
-
-The authors intend this Report to belong to the entire Haskell community, and
-so we grant permission to copy and distribute it for any purpose, provided
-that it is reproduced in its entirety, including this Notice.  Modified
-versions of this Report may also be copied and distributed for any purpose,
-provided that the modified version is clearly presented as such, and that it
-does not claim to be a definition of the Haskell 98 Foreign Function
-Interface. 
diff --git a/ffi/Makefile b/ffi/Makefile
deleted file mode 100644 (file)
index e7a0f1c..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-threads.ps: threads.tex
-       TEXINPUTS=../styles: latex threads.tex
-       dvips -f < threads.dvi > threads.ps
-
-ffi.ps: ffi.tex
-       TEXINPUTS=../styles: latex ffi.tex
-       dvips -f < ffi.dvi > ffi.ps
-
-# Requires TeX4ht
-ffi.html: ffi.tex ffi.cfg
-       xhlatex ffi.tex "ffi,2"
-
-# This is yucky, but there is not much choice as we need to subsitute a 
-# different Makefile for the tarball.
-#
-TMP=/tmp
-.PHONY: ffi.tar.gz
-ffi.tar.gz:
-       mkdir $(TMP)/ffi
-       cp ffi.tex $(TMP)/ffi/
-       cp ffi.bib $(TMP)/ffi/
-       cp ffi.cfg $(TMP)/ffi/
-       cp ../styles/grammar.sty $(TMP)/ffi/
-       cp COPYING.ffi $(TMP)/ffi/COPYING
-       cp Makefile.ffi $(TMP)/ffi/Makefile
-       cd $(TMP); tar -czf $(PWD)/ffi.tar.gz ffi
-       -rm -f $(TMP)/ffi/*
-       -rmdir $(TMP)/ffi
-
-TMP=/tmp
-.PHONY: ffi.html.tar.gz
-ffi.html.tar.gz:
-       mkdir $(TMP)/ffi
-       cp *.html *.png ffi.css $(TMP)/ffi/
-       cp COPYING.ffi $(TMP)/ffi/COPYING
-       cd $(TMP); tar -czf $(PWD)/ffi.html.tar.gz ffi
-       -rm -f $(TMP)/ffi/*
-       -rmdir $(TMP)/ffi
-
-.PHONY: clean
-clean:
-       -rm -f *.aux *.log *.blg *.dvi *.bbl *.toc *.ps *.html *.css *.png *.4ct *.4tc *.idv *.xref tex4ht.fls
diff --git a/ffi/Makefile.ffi b/ffi/Makefile.ffi
deleted file mode 100644 (file)
index be31e0c..0000000
+++ /dev/null
@@ -1,18 +0,0 @@
-# This Makefile needs GNU Make
-
-.PHONY: default
-default: ffi.ps
-
-ffi.dvi: ffi.tex grammar.sty
-       latex $< && bibtex $(basename $<) && latex $< && latex $<
-
-ffi.ps: ffi.dvi
-       dvips $< -o $@
-
-# Requires TeX4ht
-ffi.html: ffi.tex ffi.cfg
-       latex $< && bibtex $(basename $<) && latex $< && xhlatex $< "ffi"
-
-.PHONY: clean
-clean:
-       -rm -f *.aux *.log *.blg *.dvi *.bbl *.toc *.ps *.html *.css *.png *.4ct *.4tc *.idv *.xref tex4ht.fls
diff --git a/ffi/ffi.bib b/ffi/ffi.bib
deleted file mode 100644 (file)
index d27e259..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-@Article{haskell98,
-  author =      {Simon {Peyton Jones} and others},
-  title =       {Haskell 98 Language and Libraries: the Revised Report},
-  journal =     {Journal of Functional Programming},
-  year =        2003,
-  volume =      13,
-  number =      1,
-  URL =          "http://haskell.org/definition/",
-}
-
-@InProceedings{boehm:finalizers,
-  author =      {{Hans-J.} Boehm},
-  title =       {Destructors, Finalizers, and Synchronization},
-  booktitle =   {Proceedings of the 30th {ACM} {SIGPLAN}-{SIGACT} Symposium 
-                 on Principles of Programming Languages},
-  pages =       {262--272},
-  year =        2003,
-  publisher =   {ACM Press}
-}
-
-@Book{C,
-  author =      "Brian W. Kernighan and Dennis M. Ritchie",
-  title =       "The C Programming Language",
-  publisher =   "Prentice Hall",
-  edition   =    "second",
-  year =        1988
-}
-
-@Book{gosling-etal:Java,
-  author =      "James Gosling and Bill Joy and Guy Steele",
-  title =       "The {Java} Language Specification",
-  publisher =   "Addison-Wesley",
-  year =        1997,
-  series =      "The Java Series"
-}
-
-@Book{lindholm-etal:JVM,
-  author =      {Tim Lindholm and Frank Yellin},
-  title =       {The {Java} Virtual Machine Specification},
-  publisher =   {Addison-Wesley},
-  year =        1996
-}
-
-@Book{liang:JNI,
-  author =      {Sheng Liang},
-  title =       {The Java Native Interface: Programmer's Guide and 
-                Specification},
-  publisher =   {Addison Wesley},
-  year =        1999
-}
-
-@Misc{C99,
-  author =      {International Standard {ISO/IEC}},
-  title =       {Programming Languages -- {C}},
-  note =        {9899:1999 (E)}
-}
-
diff --git a/ffi/ffi.cfg b/ffi/ffi.cfg
deleted file mode 100644 (file)
index 093184f..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-\Preamble{xhtml}
-
-% Don't indent paragraphs in HTML
-\Configure{HtmlPar}{
-  \HCode{<p class="noindent">}
-}{
-  \HCode{<p class="noindent">}
-}{}{}
-
-% No pictures for math
-%
-\Configure{[]}{$$}{$$}
-\Configure{$$}{\begin{quote}\(}{\)\end{quote}}{}
-\Configure{()}{$}{$}
-
-% Formatting details of signatures descriptions
-%
-\ConfigureList{codedesc}{%
-  \HCode{<dl>}
-}{%
-  \HCode{</dl>}
-}{%
-  \HCode{<dt class="codedesc">}
-}{%
-  \HCode{<dd class="codedesc">}
-}
-
-%\ConfigureEnv{grammar}{\HCode{<div class="quote">}}{\HCode{</div>}}{}{}
-
-% The original definition of \gnterm is too hard for tex4ht to follow; hence, 
-% it misses the subscripting.
-%
-\renewcommand{\gnterm}[2][!*NEVER USED ARGUMENT*!]{%
-  \bgroup
-  \gntermfont#2%
-  \ifthenelse{\equal{#1}{!*NEVER USED ARGUMENT*!}}\relax{%
-    \HCode{<sub class="gnterm">}\({#1}\)\HCode{</sub>}%
-    }%
-  \egroup
-  }
-
-\begin{document}
-
-% Style sheet additions
-%
-\Css{
-  % We like a smaller sans font.
-  body { 
-    font-family: Bitstream Vera Sans, Arial, Helvetica, sans-serif;
-    font-size  : 14px; 
-  }
-  %
-  % Environment for library signature descriptions.
-  % - Signatures in dark red
-  dt.codedesc {
-    color: darkred;
-  }
-  % - Avoid too much space between items.
-  dd.codedesc {
-    padding-bottom: .2em;
-  }
-  % - Verbatim displays in item descriptions should not have too wide margins.
-  dd.codedesc table {
-    margin-bottom: -.8em;
-  }
-  % - Paragraph start margin should be smaller in items.
-  % - Shrink paragraph end margins to avoid gap to next item.
-  dd.codedesc p {
-    margin-top: .5em;
-    margin-bottom: 0;
-  }
-  % Otherwise, the font size get's reduced twice.
-  sub { 
-    font-size: 100\%; 
-  }
-  % Here we need to reduce, as tex4ht doesn't grok the subscript.
-  sub.gnterm { 
-    font-size: 70\%;
-  }
-  % We don't want tabular's centered;
-  table.tabular {
-    margin-left: 1em; 
-  }
-}
-
-\EndPreamble
diff --git a/ffi/ffi.tex b/ffi/ffi.tex
deleted file mode 100644 (file)
index 7991ea5..0000000
+++ /dev/null
@@ -1,2535 +0,0 @@
-% The Haskell 98 Foreign Function Interface
-% [An Addendum to the Definition of Haskell 98]
-%
-% Editor: Manuel M T Chakravarty
-%
-% Copyright [2002..2003] Manuel M T Chakravarty
-%
-% The authors intend this Report to belong to the entire Haskell community, and
-% so we grant permission to copy and distribute it for any purpose, provided
-% that it is reproduced in its entirety, including this Notice.  Modified
-% versions of this Report may also be copied and distributed for any purpose,
-% provided that the modified version is clearly presented as such, and that it
-% does not claim to be a definition of the Haskell 98 Foreign Function
-% Interface. 
-
-% Changes since RC15:
-% * 6.3: Footnote regarding __STDC_ISO_10646__ added to text introducing
-%        `CWString'.
-%
-% Changes since RC14:
-% * 6.2: CWChar -> CWchar
-% * 6.3: - CWChar -> CWchar
-%        - Stated explicitly that memory allocated by `newCString' and friends
-%          can be deallocated by `MarshalAlloc.free'
-%        - Improved documentation
-%
-% Changes since RC13:
-% * 5.3: Fixed typo
-% * 5.7: Fixed a mistake in the type of `peekByteOff' and `pokeByteOff' (the
-%        type variable constrained by `Storable' must be different from the
-%        parameter of the `Ptr')
-% * 6.3: Improved documentation
-%
-% Changes since RC12:
-% * Acks : Added John Meacham
-% * 4.1.5: Bug fix courtesy of Wolfgang Thaller
-% * 5.5  : Added `FinalizerEnvPtr', `newForeignPtrEnv', and
-%          `addForeignPtrFinalizerEnv'
-% * 6.3  : Added John Meacham proposal for `wchar_t' support as well localised
-%          string marshalling; in particular, this adds `CWString' and
-%          `CWStringLen' as well as the `CWString' and the `CAString' family
-%          of marshalling routines.  In addition, `charIsRepresentable' was
-%          added. 
-%
-% Changes since RC11:
-% * 5.5: Swapped argument order of `newForeignPtr' and `addForeignPtrFinalizer'
-%
-% Changes since RC10:
-% * 3.3  : Clarified use of foreign functions of pure type
-% * 4.1.1: Clarified the meaning of foreign imports without a "&" that have a
-%          non-functional type in Haskell
-% * 5.1  : Clarified the scope of safe use of unsafePerformIO
-% * 5.5  : "pre-emptive" dropped in footnote regarding finalizers; added
-%          `newForeignPointer_' and renamed `foreignPtrToPtr' to
-%          `unsafeForeignPtrToPtr'
-% * Typos throughout
-%
-% Changes since RC9:
-% * 1:     Mentioning interaction with foreign threads as an open problem.
-% * 2 & 3: Removed `threadsafe' again, as the proposal for thread support is
-%          still evolving and it is not yet clear whether a new safety level
-%          is required.
-% * 5.5:   Added the type synonym `FinalizerPtr' and rewrote the documentation
-%          of finalizers.
-% * 5.6:   Clarified the description of `StablePtr'
-% * 5.8:   Added `finalizerFree'
-% * 6.2:   All the types in CTypes must be newtypes that are exported
-%          abstractly. 
-%
-% Changes since RC8:
-% * 5.8: `MarshallAlloc.reallocBytes' is no longer permitted on memory
-%        allocated with `alloca' or `allocaBytes'. 
-% * 6.1: Deinitialisation of the RTS via `hs_exit()' followed by
-%        (re)initialisation with `hs_init()' must be supported.
-%
-% Changes since RC7:
-% * Clarified the lexis of C identifiers and C header file names
-% * In `ForeignPtr', added `mallocForeignPtrArray' and `mallocForeignPtrArray0'
-% * Clarified spec of allocations functions adding constraints taken from the
-%   corresponding C routines
-% * `mallocBytes' and `allocaBytes' must align memory sufficiently for any
-%   basic foreign type that fits into the allocated block
-% * Removed typos in the description of the module `ForeignPtr'
-% * Added Peter Gammie to the list of acknowledged people
-% * `addForeignPtrFinalizer' guarantees that finalizers for a single foreign
-%   pointer are executed in the opposite order as they were added.
-% * `Storable': Require that the size is divisible by the alignment
-% * Added Ross Paterson to the list of acknowledged people
-% * Added hs_free_fun_ptr() and hs_free_stable_ptr()
-% * Changed order of arguments of `mkIOError' and `annotateIOError' to match
-%   with the current implementation in GHC's FFI libraries.
-%
-% Changes since RC6:
-% * Fixed typos
-%
-% Changes since RC5:
-% * Author list: changed Alastair Reid's institution
-% * 1.4:   Clarified the wording
-% * 4.1:   Explicitly stated that access to pre-processor symbols is not
-%          provided by the FFI
-% * 4.1.1: Removed [lib] from impent syntax and discussion
-% * 4.1.3: Added parentheses round FunPtr ft to make it easier to 
-%          understand a tolerably complex type.
-% * 4.1.4: Removed all mention of library objects; clarified that header files
-%          do not impact the semantics of foreign calls, but may be required
-%          for correct code generation by some systems
-% * 5.2:   Clarified that all operations in Bits are member functions of the
-%          type class.  Reverse the meaning of the sign of the second argument
-%          for `rotate' and `shift' (this makes it the same as GHC used all
-%          the time).  `bitSize' on `Integer' etc is now undefined.
-% * 5.5:   Finalisers must be external functions to facilitate the
-%          implementation on Haskell systems that do not support pre-emptive
-%          concurrency.
-%          Added mallocForeignPtr and mallocForeignPtrBytes.
-% * 6:     Specified that HsBool==int in table2
-%          Relabelled column 1 in table 3 (C symbol -> CPP symbol)
-%          Replaced 0 and 1 with HS_BOOL_FALSE/TRUE
-% * 6.1:   Clarified that nullPtr (nullFunPtr) coincides with (HsPtr) NULL and
-%          (HsFunPtr) NULL, respectively.
-%          Allowing multiple calls to hs_init() and clarified the constraints
-%          on the relative timing between hs_set_argv() and
-%          getProgName/getArgs. 
-%          Added hs_perform_gc().
-%
-% Changes since RC4:
-% * 5.6: Clarified documentation of `StablePtr's (RC 5)
-%
-% Changes between RC2 and RC4:
-%
-% * 5.8: Clarified documentation for `MarshalAlloc.free'.
-% * 5.8: Added `MarshalAlloc.realloc'.
-% * 3: Added the new safety level `threadsafe' with an explanation at the end
-%   of 3.3.
-% * 3: Replaced the nontermional `entity' by `impent' and `expent' to
-%   distinguish between import and export entities (as they are defined
-%   differently in later sections).
-% * 3.2: Clarified the description of foreign types; so far, `IO ()' was
-%   strictly speaking not included as a valid return type.  Currently,
-%   functions of type `a -> ()' are included.  Do we want this?  Their use
-%   might not be portable if they include side effects.
-% * 4.1.5: New section discussing the traps & pitfalls of type promotion with
-%   C bindings.
-
-% TODO:
-% * Implement HTMLization.  (Malcolm suggests using
-%   <http://pauillac.inria.fr/~maranget/hevea/>)
-
-% TODO after Version 1.0:
-%
-% * Review suggestions by Antony Courtney <antony@apocalypse.org> re FFI
-%   support for Java.
-
-\documentclass[a4paper,twoside]{article}
-
-\usepackage{a4wide}
-\usepackage{grammar}  % Get it from 
-                      %   http://www.cse.unsw.edu.au/~chak/haskell/grammar.sty
-\usepackage{version}
-\usepackage{url}
-\usepackage[fleqn]{amsmath}
-
-
-% version control
-%
-%\includeversion{DRAFT}
-\excludeversion{DRAFT}
-\excludeversion{FUTURE}  % material for future extensions
-
-\def\Version{\relax}
-%\def\Version{\\(Release Candidate 16)}
-\begin{DRAFT}%
-{
-  \gdef\Version{%
-    \\
-    \textbf{--- DRAFT ---}\\[1ex]
-    \ttfamily\scriptsize
-    $\relax$Id: ffi.tex,v 1.55 2005/04/23 14:27:04 chak Exp $\relax$%
-    \ignorespaces}
-  }
-\end{DRAFT}
-
-% setting of code
-%
-\newcommand{\code}[1]{\texttt{#1}}      % inline code fragment
-\makeatletter
-\newenvironment{codedesc}{%             % description of code pieces
-  \list{}{\labelwidth\z@
-    \let\makelabel\codedesclabel}
-  }{%
-  \endlist
-  }
-\newcommand*{\codedesclabel}[1]{%
-  \hspace{-\leftmargin}
-  \parbox[b]{\labelwidth}{\makebox[0pt][l]{\code{#1}}\\}\hfil\relax
-  }
-\makeatother
-\newcommand{\combineitems}{\vspace*{-\itemsep}\vspace*{-\parsep}\vspace*{-1em}}
-\newcommand{\us}{\char"5F}
-
-% general
-%
-\newcommand{\clearemptydoublepage}{%
-  \newpage{\pagestyle{empty}\cleardoublepage}}
-
-
-\begin{document}
-\pagestyle{headings}
-
-\title{%
-  The Haskell 98 Foreign Function Interface 1.0\\
-  An Addendum to the Haskell 98 Report%
-  \Version}
-\author{
-  Manuel Chakravarty [editor], University of New South Wales\\
-  Sigbjorn Finne, Galois Connections, Inc.\\
-  Fergus Henderson, University of Melbourne\\
-  Marcin Kowalczyk, Warsaw University\\
-  Daan Leijen, University of Utrecht\\
-  Simon Marlow, Microsoft Research, Cambridge\\
-  Erik Meijer, Microsoft Corporation\\
-  Sven Panne, BetaResearch GmbH\\
-  Simon Peyton Jones, Microsoft Research, Cambridge\\
-  Alastair Reid, Reid Consulting (UK) Ltd.\\
-  Malcolm Wallace, University of York\\
-  Michael Weber, University of Aachen
-  }
-\date{}
-\maketitle
-\par\vfill
-\noindent
-Copyright (c) [2002..2003] Manuel M. T. Chakravarty
-\par\noindent
-\emph{The authors intend this Report to belong to the entire Haskell
-  community, and so we grant permission to copy and distribute it for any
-  purpose, provided that it is reproduced in its entirety, including this
-  Notice.  Modified versions of this Report may also be copied and distributed
-  for any purpose, provided that the modified version is clearly presented as
-  such, and that it does not claim to be a definition of the Haskell 98
-  Foreign Function Interface.}
-\par\bigskip\noindent
-The master version of the Haskell FFI Report is at \url{haskell.org}. Any
-corrections or changes in the report are found there.
-\thispagestyle{empty}
-
-
-\clearemptydoublepage
-\pagenumbering{roman}
-\tableofcontents
-
-\clearemptydoublepage
-\section*{Preface}
-
-The definition of Haskell 98~\cite{haskell98}, while being comprehensive with
-respect to the functional core language, does lack a range of features of more
-operational flavour, such as a foreign language interface, concurrency
-support, and fully fledged exception handling.  As these features are of
-central importance to many real world applications of the language, there is a
-danger that different implementations become de facto incompatible for such
-applications due to system-specific extensions of the core language.  The
-present FFI specification is aimed at reducing this risk by defining a simple,
-yet comprehensive extension to Haskell 98 for the purpose of interfacing to
-program components implemented in a language other than Haskell.
-
-The goal behind this foreign function interface (FFI) specification is
-twofold: It enables (1) to describe in Haskell the interface to foreign
-functionality and (2) to use from foreign code Haskell routines.  More
-precisely, its aim is to support the implementation of programs in a mixture
-of Haskell and other languages such that the source code is portable across
-different implementations of Haskell and non-Haskell systems as well as
-independent of the architecture and operating system.
-
-The design as presented in this report builds on experiences with a number of
-foreign function interfaces that, over time, have been provided by the major
-Haskell implementations.  Central in the final design was the goal to be
-comprehensive while being simple and minimising changes with respect to
-Haskell 98; the latter includes to avoid pollution of the name space with new
-keywords.  Consequently, as much as possible of the FFI functionality is
-realised in the form of libraries.  Simplicity generally overruled maximum
-convenience for the programmer as a design goal.  Thus, support for more
-convenient interface specifications is the domain of system-independent tools
-that generate code following the present specification.
-
-\subsection*{Acknowledgements}
-
-We heartily thank the kind people who assisted us with their comments and
-suggestions on the \code{ffi@haskell.org} and \code{haskell@haskell.org}
-mailing lists as well as all the users of previous versions of the FFI who
-helped to shape the development by their feedback.  We thank Olaf Chitil,
-Peter Gammie, Wolfram Kahl, Martin D. Kealey, Ian Lynagh, John Meacham, Ross
-Paterson, George Russell, and Wolfgang Thaller for errata and additions to
-previous versions of this report.
-
-
-\clearemptydoublepage
-\pagenumbering{arabic}
-\section{Introduction}
-
-The extension of Haskell 98 defined in this report facilitates the use of
-non-Haskell code from Haskell and vice versa in a portable manner.  Intrusion
-into Haskell 98 has been kept to a minimum and the defined facilities have
-been extensively tested with large libraries.
-
-The present Version 1.0 of the FFI report does only fully specify the
-interaction between Haskell code with code that follows the C calling
-convention.  However, the design of the FFI is such that it enables the
-modular extension of the present definition to include the calling conventions
-of other programming languages, such as C++ and Java.  A precise definition of
-the support for those languages is expected to be included in later versions
-of this report.  The second major omission from the present report is the
-definition of the interaction with multithreading in the foreign language and,
-in particular, the treatment of thread-local state.  Work on this problem is
-not sufficiently mature to be included into Version 1.0 of the report.
-
-\subsection{Embedding Into Haskell 98}
-
-The present report is to be regarded as an addendum to the Haskell 98
-Report~\cite{haskell98}.  As such, syntactic and semantic definitions refer to
-names and definitions in the Haskell 98 Report where appropriate without
-further explanation.  Care has been taken to invalidate as few as possible
-legal Haskell 98 programs in the process of adding FFI support.  In
-particular, only a single addition to the set of reserved identifiers, namely
-\code{foreign}, has been made.
-
-Moreover, it is expected that the present FFI specification will be considered
-for inclusion into future revisions of the Haskell standard.
-
-\subsection{Language-Specific FFI Support}
-
-The core of the present specification is independent of the foreign language
-that is used in conjunction with Haskell.  However, there are two areas where
-FFI specifications must become language specific: (1) the specification of
-external names and (2) the marshalling of the basic types of a foreign
-language.  As an example of the former, consider that in C~\cite{C} a simple
-identifier is sufficient to identify an object, while
-Java~\cite{gosling-etal:Java}, in general, requires a qualified name in
-conjunction with argument and result types to resolve possible overloading.
-Regarding the second point, consider that many languages do not specify the
-exact representation of some basic types.  For example the type \code{int} in
-C may be 16, 32, or 64 bits wide.  Similarly, the Haskell report guarantees
-only that \code{Int} covers at least the range \([-2^{29}, 2^{29} - 1]\).  As
-a consequence, to reliably represent values of C's \code{int} in Haskell, we
-have to introduce a new type \code{CInt}, which is guaranteed to match the
-representation of \code{int}.
-
-The specification of external names, dependent on a calling convention, is
-described in Section~\ref{sec:extent}, whereas the marshalling of the basic
-types in dependence on a foreign language is described in
-Section~\ref{sec:marshalling}.
-
-\subsection{Contexts}
-
-For a given Haskell system, we define the \emph{Haskell context} to be the
-execution context of the abstract machine on which the Haskell system is
-based.  This includes the heap, stacks, and the registers of the abstract
-machine and their mapping onto a concrete architecture.  We call any other
-execution context an \emph{external context.}  Generally, we cannot assume any
-compatibility between the data formats and calling conventions between the
-Haskell context and a given external context, except where the Haskell 98
-report explicitly prescribes a specific data format.
-
-The principal goal of a foreign function interface is to provide a
-programmable interface between the Haskell context and external contexts.  As
-a result Haskell threads can access data in external contexts and invoke
-functions that are executed in an external context as well as vice versa.  In
-the rest of this report, external contexts are usually identified by a calling
-convention. 
-
-\subsection{Cross Language Type Consistency}
-
-Given that many external languages support static types, the question arises
-whether the consistency of Haskell types with the types of the external
-language can be enforced for foreign functions.  Unfortunately, this is, in
-general, not possible without a significant investment on the part of the
-implementor of the Haskell system (i.e., without implementing a dedicated type
-checker).  For example, in the case of the C calling convention, the only
-other approach would be to generate a C prototype from the Haskell type and
-leave it to the C compiler to match this prototype with the prototype that is
-specified in a C header file for the imported function.  However, the Haskell
-type is lacking some information that would be required to pursue this route.
-In particular, the Haskell type does not contain any information as to when
-\code{const} modifiers have to be emitted.  
-
-As a consequence, this report does not require the Haskell system to check
-consistency with foreign types.  Nevertheless, Haskell systems are encouraged
-to provide any cross language consistency checks that can be implemented with
-reasonable effort.
-
-
-\newpage
-\section{Lexical Structure}
-
-In the following, all formal grammatical definitions are based on the same
-notation as that defined in the Haskell 98
-Report~\cite[Section~2.1]{haskell98} and we make free use of all nonterminals
-defined in the Haskell 98 Report.  The only addition to the lexical structure
-of Haskell 98~\cite[Section~2]{haskell98} is a single new reserved identifier
-(namely, \code{foreign}) and a set of special identifiers.  The latter have a
-special meaning only within foreign declarations, but may be used as ordinary
-identifiers elsewhere.
-
-The following productions are added:
-%
-\begin{grammar}
-  \grule{reservedid}{%
-    foreign}
-  \grule{specialid}{%
-    export \galt\ safe \galt\ unsafe \galt\ ccall}
-  \gor{%
-     cplusplus \galt\ dotnet \galt\ jvm \galt\ stdcall}
-  \gor{%
-    \gverbal{system-specific calling conventions}}
-\end{grammar}
-%
-The special identifiers \code{ccall}, \code{cplusplus}, \code{dotnet},
-\code{jvm}, and \code{stdcall} are defined to denote calling conventions.
-However, a concrete implementation of the FFI is free to support additional,
-system-specific calling conventions whose name is not explicitly listed here.
-
-To refer to objects of an external C context, we introduce the following
-phrases:
-%
-\begin{grammar}
-  \grule[C header filename]{chname}{%
-    \grepeat{\gnterm{chchar}} .\ h}
-  \grule[C identifier]{cid}{%
-    \gnterm{letter} \grepeat{\gnterm{letter} \galt\ \gnterm{ascDigit}}}
-  \grule{chchar}{%
-    \gnterm{letter} \galt\ \gnterm{ascSymbol}\gminus{\&}}
-  \grule{letter}{%
-    \gnterm{ascSmall} \galt\ \gnterm{ascLarge} \galt\ \_}
-\end{grammar}
-%
-The range of lexemes that are admissible for \gnterm{chname} is a subset of
-those permitted as arguments to the \code{\#{}include} directive in C.  In
-particular, a file name \gnterm{chname} must end in the suffix \code{.h}.  The
-lexemes produced by \gnterm{cid} coincide with those allowed as C identifiers,
-as specified in~\cite{C}.
-
-\newpage
-\section{Foreign Declarations}
-
-This section describes the extension of Haskell 98 by foreign declarations.
-The following production for the nonterminal \gnterm{topdecl} extends the same
-nonterminal from the Haskell 98 Report.  All other nonterminals are new.
-%
-\begin{grammar}
-  \grule{topdecl}{%
-    foreign \gnterm{fdecl}}
-  \grule[define variable]{fdecl}{%
-    import \gnterm{callconv} \gopt{\gnterm{safety}} \gnterm{impent}
-    \gnterm{var} {::}\ \gnterm{ftype}}
-  \gor[expose variable]{%
-    export \gnterm{callconv} \gnterm{expent}
-    \gnterm{var} {::}\ \gnterm{ftype}}
-  \grule[calling convention]{callconv}{%
-    ccall \galt\ stdcall \galt\ cplusplus \galt\ jvm \galt\ dotnet}
-  \gor{%
-    \gverbal{system-specific calling conventions}}
-  \grule[imported external entity]{impent}{%
-    \gopt{\gnterm{string}}}
-  \grule[exported entity]{expent}{%
-    \gopt{\gnterm{string}}}
-  \grule{safety}{%
-    unsafe \galt\ safe}
-\end{grammar}
-%
-There are two flavours of foreign declarations: import and export
-declarations.  An import declaration makes an \emph{external entity,} i.e., a
-function or memory location defined in an external context, available in the
-Haskell context.  Conversely, an export declaration defines a function of the
-Haskell context as an external entity in an external context.  Consequently,
-the two types of declarations differ in that an import declaration defines a
-new variable, whereas an export declaration uses a variable that is already
-defined in the Haskell module.
-
-The external context that contains the external entity is determined by the
-calling convention given in the foreign declaration.  Consequently, the exact
-form of the specification of the external entity is dependent on both the
-calling convention and on whether it appears in an import declaration (as
-\gnterm{impent}) or in an export declaration (as \gnterm{expent}).  To provide
-syntactic uniformity in the presence of different calling conventions, it is
-guaranteed that the description of an external entity lexically appears as a
-Haskell string lexeme.  The only exception is where this string would be the
-empty string (i.e., be of the form \code{""}); in this case, the string may be
-omitted in its entirety.
-
-\subsection{Calling Conventions}
-\label{sec:call-conv}
-
-The binary interface to an external entity on a given architecture is
-determined by a calling convention.  It often depends on the programming
-language in which the external entity is implemented, but usually is more
-dependent on the system for which the external entity has been compiled.
-
-As an example of how the calling convention is dominated by the system rather
-than the programming language, consider that an entity compiled to byte code
-for the Java Virtual Machine (JVM)~\cite{lindholm-etal:JVM} needs to be
-invoked by the rules of the JVM rather than that of the source language in
-which it is implemented (the entity might be implemented in Oberon, for
-example).
-
-Any implementation of the Haskell 98 FFI must at least implement the C calling
-convention denoted by \code{ccall}.  All other calling conventions are
-optional.  Generally, the set of calling conventions is open, i.e., individual
-implementations may elect to support additional calling conventions.  In
-addition to \code{ccall}, Table~\ref{tab:callconv} specifies a range of
-identifiers for common calling conventions.
-%
-\begin{table}[tbp]
-  \begin{center}
-    \begin{tabular}{|l|l|}
-      \hline
-      Identifier & Represented calling convention\\
-      \hline\hline
-      \code{ccall} 
-      & Calling convention of the standard C compiler on a system\\
-      \code{cplusplus}
-      & Calling convention of the standard C{+}{+} compiler on a system\\
-      \code{dotnet}
-      & Calling convention of the \textsc{.net} platform\\
-      \code{jvm} 
-      & Calling convention of the Java Virtual Machine\\
-      \code{stdcall}
-      & Calling convention of the Win32 API (matches Pascal conventions)\\
-      \hline
-    \end{tabular}
-    \caption{Calling conventions}
-    \label{tab:callconv}
-  \end{center}
-\end{table}
-%
-Implementations need not implement all of these conventions, but if any is
-implemented, it must use the listed name.  For any other calling convention,
-implementations are free to choose a suitable name.
-
-The present report does only define the semantics of the calling conventions
-\code{ccall} and \code{stdcall}.  Later versions of the report are expected to
-cover more calling conventions.
-
-It should be noted that the code generated by a Haskell system to implement a
-particular calling convention may vary widely with the target code of that
-system.  For example, the calling convention \code{jvm} will be trivial to
-implement for a Haskell compiler generating Java code, whereas for a Haskell
-compiler generating C code, the Java Native Interface (JNI)~\cite{liang:JNI}
-has to be targeted.
-
-\subsection{Foreign Types}
-\label{sec:foreign-types}
-
-The following types constitute the set of \emph{basic foreign types}:
-%
-\begin{itemize}
-\item \code{Char}, \code{Int}, \code{Double}, \code{Float}, and \code{Bool} as
-  exported by the Haskell 98 \code{Prelude} as well as
-\item \code{Int8}, \code{Int16}, \code{Int32}, \code{Int64}, \code{Word8},
-  \code{Word16}, \code{Word32}, \code{Word64}, \code{Ptr a}, \code{FunPtr a},
-  and \code{StablePtr a}, for any type \code{a}, as exported by \code{Foreign}
-  (Section~\ref{sec:Foreign}).
-\end{itemize}
-%
-A Haskell system that implements the FFI needs to be able to pass these types
-between the Haskell and the external context as function arguments and
-results.
-
-Foreign types are produced according to the following grammar:
-%
-\begin{grammar}
-  \grule{ftype}{%
-    \gnterm{frtype}}
-  \gor{%
-    \gnterm{fatype} -> \gnterm{ftype}}
-  \grule{frtype}{%
-    \gnterm{fatype}}
-  \gor{%
-    ()}
-  \grule[$k\geq0$]{fatype}{%
-    \gnterm{qtycon} \gnterm[1]{atype} \gellipse\ \gnterm[k]{atype}}
-\end{grammar}
-%
-A foreign type is the Haskell type of an external entity.  Only a subset of
-Haskell's types are permissible as foreign types, as only a restricted set of
-types can be canonically transferred between the Haskell context and an
-external context.  A foreign type generally has the form
-\[
-\textit{at}_1\code{ -> }\cdots\code{ -> }\textit{at}_n\code{ -> }\textit{rt}
-\]
-where \(n\geq0\).  It implies that the arity of the external entity is $n$.
-
-The argument types \(\textit{at}_i\) produced by \gnterm{fatype} must be
-\emph{marshallable foreign types;} that is, each \(\textit{at}_i\) is either
-(1) a basic foreign type or (2) a type synonym or renamed datatype of a
-marshallable foreign type.  Moreover, the result type \textit{rt} produced by
-\gnterm{frtype} must be a \emph{marshallable foreign result type;} that is, it
-is either a marshallable foreign type, the type \code{()}, or a type matching
-\code{Prelude.IO }$t$, where $t$ is a marshallable foreign type or \code{()}.
-
-External functions are generally strict in all arguments.
-
-\subsection{Import Declarations}
-\label{sec:import}
-
-Generally, an import declaration has the form
-%
-\[
-\code{foreign}~\code{import}~c~e~v~\code{{::}}~t
-\]
-%
-which declares the variable $v$ of type $t$ to be defined externally.
-Moreover, it specifies that $v$ is evaluated by executing the external entity
-identified by the string $e$ using calling convention $c$.  The precise form
-of $e$ depends on the calling convention and is detailed in
-Section~\ref{sec:extent}.  If a variable $v$ is defined by an import
-declaration, no other top-level declaration for $v$ is allowed in the same
-module.  For example, the declaration
-%
-\begin{quote}
-\begin{verbatim}
-foreign import ccall "string.h strlen" cstrlen :: Ptr CChar -> IO CSize
-\end{verbatim}
-\end{quote}
-%
-introduces the function \code{cstrlen}, which invokes the external function
-\code{strlen} using the standard C calling convention.  Some external entities
-can be imported as pure functions; for example,
-%
-\begin{quote}
-\begin{verbatim}
-foreign import ccall "math.h sin" sin :: CDouble -> CDouble.
-\end{verbatim}
-\end{quote}
-%
-Such a declaration asserts that the external entity is a true function; i.e.,
-when applied to the same argument values, it always produces the same result.
-
-Whether a particular form of external entity places a constraint on the
-Haskell type with which it can be imported is defined in
-Section~\ref{sec:extent}.  Although, some forms of external entities restrict
-the set of Haskell types that are permissible, the system can generally not
-guarantee the consistency between the Haskell type given in an import
-declaration and the argument and result types of the external entity.  It is
-the responsibility of the programmer to ensure this consistency.
-
-Optionally, an import declaration can specify, after the calling convention,
-the safety level that should be used when invoking an external entity.  A
-\code{safe} call is less efficient, but guarantees to leave the Haskell system
-in a state that allows callbacks from the external code.  In contrast, an
-\code{unsafe} call, while carrying less overhead, must not trigger a callback
-into the Haskell system.  If it does, the system behaviour is undefined.  The
-default for an invocation is to be \code{safe}.  Note that a callback into
-the Haskell system implies that a garbage collection might be triggered after
-an external entity was called, but before this call returns.  Consequently,
-objects other than stable pointers (cf.\ Section~\ref{sec:StablePtr}) may be
-moved or garbage collected by the storage manager.
-
-\subsection{Export Declarations}
-
-The general form of export declarations is
-%
-\[
-\code{foreign}~\code{export}~c~e~v~\code{{::}}~t
-\]
-%
-Such a declaration enables external access to $v$, which may be a value, field
-name, or class method that is declared on the top-level of the same module or
-imported.  Moreover, the Haskell system defines the external entity described
-by the string $e$, which may be used by external code using the calling
-convention $c$; an external invocation of the external entity $e$ is
-translated into evaluation of $v$.  The type $t$ must be an instance of the
-type of $v$.  For example, we may have
-%
-\begin{quote}
-\begin{verbatim}
-foreign export ccall "addInt"   (+) :: Int   -> Int   -> Int
-foreign export ccall "addFloat" (+) :: Float -> Float -> Float
-\end{verbatim}
-\end{quote}
-
-If an evaluation triggered by an external invocation of an exported Haskell
-value returns with an exception, the system behaviour is undefined.  Thus,
-Haskell exceptions have to be caught within Haskell and explicitly marshalled
-to the foreign code.
-
-
-\section{Specification of External Entities}
-\label{sec:extent}
-
-Each foreign declaration has to specify the external entity that is accessed
-or provided by that declaration.  The syntax and semantics of the notation
-that is required to uniquely determine an external entity depends heavily on
-the calling convention by which this entity is accessed.  For example, for the
-calling convention \code{ccall}, a global label is sufficient.  However, to
-uniquely identify a method in the calling convention \code{jvm}, type
-information has to be provided.  For the latter, there is a choice between the
-Java source-level syntax of types and the syntax expected by JNI---but,
-clearly, the syntax of the specification of an external entity depends on the
-calling convention and may be non-trivial.
-
-Consequently, the FFI does not fix a general syntax for denoting external
-entities, but requires both \gnterm{impent} and \gnterm{expent} to take the
-form of a Haskell \gnterm{string} literal.  The formation rules for the values
-of these strings depend on the calling convention and a Haskell system
-implementing a particular calling convention will have to parse these strings
-in accordance with the calling convention.
-
-Defining \gnterm{impent} and \gnterm{expent} to take the form of a
-\gnterm{string} implies that all information that is needed to statically
-analyse the Haskell program is separated from the information needed to
-generate the code interacting with the foreign language.  This is, in
-particular, helpful for tools processing Haskell source code.  When ignoring
-the entity information provided by \gnterm{impent} or \gnterm{expent}, foreign
-import and export declarations are still sufficient to infer identifier
-definition and use information as well as type information.
-
-For more complex calling conventions, there is a choice between the user-level
-syntax for identifying entities (e.g., Java or C{+}{+}) and the system-level
-syntax (e.g., the type syntax of JNI or mangled C{+}{+}, respectively).  If
-such a choice exists, the user-level syntax is preferred.  Not only because it
-is more user friendly, but also because the system-level syntax may not be
-entirely independent of the particular implementation of the foreign language.
-
-The following defines the syntax for specifying external entities and their
-semantics for the calling conventions \code{ccall} and \code{stdcall}.  Other
-calling conventions from Table~\ref{tab:callconv} are expected to be defined
-in future versions of this report.
-
-
-\subsection{Standard C Calls}
-\label{sec:ccall}
-
-The following defines the structure of external entities for foreign
-declarations under the \code{ccall} calling convention for both import and
-export declarations separately.  Afterwards additional constraints on the type
-of foreign functions are defined.
-
-The FFI covers only access to C functions and global variables.  There are no
-mechanisms to access other entities of C programs.  In particular, there is no
-support for accessing pre-processor symbols from Haskell, which includes
-\code{\#define}d constants.  Access from Haskell to such entities is the
-domain of language-specific tools, which provide added convenience over the
-plain FFI as defined in this report.
-
-\subsubsection{Import Declarations}
-
-For import declarations, the syntax for the specification of external entities
-under the \code{ccall} calling convention is as follows:
-%
-\begin{grammar}
-  \grule[static function or address]{impent}{%
-    " \gopt{static} \gopt{\gnterm{chname}} \gopt{\&} 
-    \gopt{\gnterm{cid}} "}
-  \gor[stub factory importing addresses]{%
-    " dynamic "}
-  \gor[stub factory exporting thunks]{%
-    " wrapper "}
-\end{grammar}
-%
-The first alternative either imports a static function \gnterm{cid} or, if
-\gterm\& precedes the identifier, a static address.  If \gnterm{cid} is
-omitted, it defaults to the name of the imported Haskell variable.  The
-optional filename \gnterm{chname} specifies a C header file, where the
-intended meaning is that the header file declares the C entity identified by
-\gnterm{cid}.  In particular, when the Haskell system compiles Haskell to C
-code, the directive
-%
-\begin{quote}
-  \gterm{\#include "\gnterm{chname}"}
-\end{quote}
-%
-needs to be placed into any generated C file that refers to the foreign entity
-before the first occurrence of that entity in the generated C file.
-
-The second and third alternative, identified by the keywords \gterm{dynamic}
-and \gterm{wrapper}, respectively, import stub functions that have to be
-generated by the Haskell system.  In the case of \gterm{dynamic}, the stub
-converts C function pointers into Haskell functions; and conversely, in the
-case of \gterm{wrapper}, the stub converts Haskell thunks to C function
-pointers.  If neither of the specifiers \code{static}, \code{dynamic}, or
-\code{wrapper} is given, \code{static} is assumed.  The specifier
-\code{static} is nevertheless needed to import C routines that are named
-\code{dynamic} or \code{wrapper}.
-
-It should be noted that a static foreign declaration that does not import an
-address (i.e., where \gterm\& is not used in the specification of the external
-entity) always refers to a C function, even if the Haskell type is
-non-functional.  For example, 
-%
-\begin{quote}
-\begin{verbatim}
-foreign import ccall foo :: CInt
-\end{verbatim}
-\end{quote}
-%
-refers to a pure C function \code{foo} with no arguments that returns an
-integer value.  Similarly, if the type is \code{IO CInt}, the declaration
-refers to an impure nullary function.  If a Haskell program needs to access a
-C variable \code{bar} of integer type,
-%
-\begin{quote}
-\begin{verbatim}
-foreign import ccall "&" bar :: Ptr CInt
-\end{verbatim}
-\end{quote}
-%
-must be used to obtain a pointer referring to the variable.  The variable can
-be read and updated using the routines provided by the module \code{Storable}
-(cf.\ Section~\ref{sec:Storable}).
-
-\subsubsection{Export Declarations}
-
-External entities in \gnterm{ccall} export declarations are of the form
-%
-\begin{grammar}
-  \grule{expent}{%
-    " \gopt{\gnterm{cid}} "}
-\end{grammar}
-%
-The optional C identifier \gnterm{cid} defines the external name by which the
-exported Haskell variable is accessible in C.  If it is omitted, the external
-name defaults to the name of the exported Haskell variable.
-
-\subsubsection{Constraints on Foreign Function Types}
-
-In the case of import declaration, there are, depending on the kind of import
-declaration, constraints regarding the admissible Haskell type that the
-variable defined in the import may have.  These constraints are specified in
-the following.
-%
-\begin{description}
-\item[Static Functions.]  A static function can be of any foreign type; in
-  particular, the result type may or may not be in the IO monad.  If a
-  function that is not pure is not imported in the IO monad, the system
-  behaviour is undefined.  Generally, no check for consistency with the C type
-  of the imported label is performed.
-
-  As an example, consider
-  %
-  \begin{quote}
-\begin{verbatim}
-foreign import ccall "static stdlib.h" system :: Ptr CChar -> IO CInt
-\end{verbatim}
-  \end{quote}
-  %
-  This declaration imports the \code{system()} function whose prototype is
-  available from \code{stdlib.h}.
-
-\item[Static addresses.]  The type of an imported address is constrained to be
-  of the form \code{Ptr }\textit{a} or \code{FunPtr }\textit{a}, where
-  \textit{a} can be any type.
-
-  As an example, consider
-  %
-  \begin{quote}
-\begin{verbatim}
-foreign import ccall "errno.h &errno" errno :: Ptr CInt
-\end{verbatim}
-  \end{quote}
-  %
-  It imports the address of the variable \code{errno}, which is of the C type
-  \code{int}.
-
-\item[Dynamic import.]  The type of a \gnterm{dynamic} stub has to be of the
-  form \code{(FunPtr }\textit{ft}\code{) -> }\textit{ft}, where \textit{ft} may
-  be any foreign type.
-
-  As an example, consider
-  %
-  \begin{quote}
-\begin{verbatim}
-foreign import ccall "dynamic" 
-  mkFun :: FunPtr (CInt -> IO ()) -> (CInt -> IO ())
-\end{verbatim}
-  \end{quote}
-  %
-  The stub factory \code{mkFun} converts any pointer to a C function that gets
-  an integer value as its only argument and does not have a return value into
-  a corresponding Haskell function.
-
-\item[Dynamic wrapper.]  The type of a \gnterm{wrapper} stub has to be of the
-  form \textit{ft}\code{ -> }\code{IO (FunPtr }\textit{ft}\code), where
-  \textit{ft} may be any foreign type.
-
-  As an example, consider
-  %
-  \begin{quote}
-\begin{verbatim}
-foreign import ccall "wrapper" 
-  mkCallback :: IO () -> IO (FunPtr (IO ()))
-\end{verbatim}
-  \end{quote}
-  %
-  The stub factory \code{mkCallback} turns any Haskell computation of type
-  \code{IO ()} into a C function pointer that can be passed to C routines,
-  which can call back into the Haskell context by invoking the referenced
-  function.
-
-\end{description}
-
-\subsubsection{Specification of Header Files}
-
-A C header specified in an import declaration is always included by
-\gterm{\#include "\gnterm{chname}"}.  There is no explicit support for
-\gterm{\#include <\gnterm{chname}>} style inclusion.  The ISO C99~\cite{C99}
-standard guarantees that any search path that would be used for a
-\gterm{\#include <\gnterm{chname}>} is also used for \gterm{\#include
-  "\gnterm{chname}"} and it is guaranteed that these paths are searched after
-all paths that are unique to \gterm{\#include "\gnterm{chname}"}.  Furthermore,
-we require that \gnterm{chname} ends on \code{.h} to make parsing of the
-specification of external entities unambiguous.
-  
-The specification of include files has been kept to a minimum on purpose.
-Libraries often require a multitude of include directives, some of which may
-be system-dependent.  Any design that attempts to cover all possible
-configurations would introduce significant complexity.  Moreover, in the
-current design, a custom include file can be specified that uses the standard
-C preprocessor features to include all relevant headers.
-
-Header files have no impact on the semantics of a foreign call, and whether an
-implementation uses the header file or not is implementation-defined.
-However, as some implementations may require a header file that supplies a
-correct prototype for external functions in order to generate correct code,
-portable FFI code must include suitable header files.
-
-\subsubsection{C Argument Promotion}
-
-The argument passing conventions of C are dependant on whether a function
-prototype for the called functions is in scope at a call site.  In particular,
-if no function prototype is in scope, \emph{default argument promotion} is
-applied to integral and floating types.  In general, it cannot be expected
-from a Haskell system that it is aware of whether a given C function was
-compiled with or without a function prototype being in scope.  For the sake of
-portability, we thus require that a Haskell system generally implements calls
-to C functions as well as C stubs for Haskell functions as if a function
-prototype for the called function is in scope.
-
-This convention implies that the onus for ensuring the match between C and
-Haskell code is placed on the FFI user.  In particular, when a C function that
-was compiled without a prototype is called from Haskell, the Haskell signature
-at the corresponding \code{foreign import} declaration must use the types
-\emph{after} argument promotion.  For example, consider the following C
-function definition, which lacks a prototype:
-%
-\begin{quote}
-\begin{verbatim}
-void foo (a)
-float a;
-{
-  ...
-}
-\end{verbatim}
-\end{quote}
-%
-The lack of a prototype implies that a C compiler will apply default argument
-promotion to the parameter \code{a}, and thus, \code{foo} will expect to
-receive a value of type \code{double}, \emph{not} \code{float}.  Hence, the
-correct \code{foreign import} declaration is
-%
-\begin{quote}
-\begin{verbatim}
-foreign import ccall foo :: Double -> IO ()
-\end{verbatim}
-\end{quote}
-
-In contrast, a C function compiled with the prototype
-%
-\begin{quote}
-\begin{verbatim}
-void foo (float a);
-\end{verbatim}
-\end{quote}
-%
-requires
-%
-\begin{quote}
-\begin{verbatim}
-foreign import ccall foo :: Float -> IO ()
-\end{verbatim}
-\end{quote}
-
-A similar situation arises in the case of \code{foreign export} declarations
-that use types that would be altered under the C default argument promotion
-rules.  When calling such Haskell functions from C, a function prototype
-matching the signature provided in the \code{foreign export} declaration must
-be in scope; otherwise, the C compiler will erroneously apply the promotion
-rules to all function arguments.
-
-Note that for a C function defined to a accept a variable number of arguments,
-all arguments beyond the explicitly typed arguments suffer argument promotion.
-However, because C permits the calling convention to be different for such
-functions; a Haskell system will, in general, not be able to make use of
-variable argument functions.  Hence, their use is deprecated in portable code.
-
-
-\subsection{Win32 API Calls}
-
-The specification of external entities under the \code{stdcall} calling
-convention is identical to that for standard C calls.  The two calling
-conventions only differ in the generated code.
-
-
-\begin{FUTURE} % ===== Material for future extension =======================
-
-\subsection{C{+}{+} Calls}
-
-The syntax for the specification of external entities under the
-\code{cplusplus} calling convention is
-
-\subsection{JVM Calls}
-
-The syntax for the specification of external entities under the \code{jvm}
-calling convention is 
-%
-\begin{grammar}
-  \grule{impent}{%
-    "\gnterm{jtype} \gnterm{jqid}(\gnterm{jtypes})"}
-  \gor[constructor call]{%
-    "new \gnterm{jqid}(\gnterm{jtypes})"}
-  \grule[$n\geq0$]{jtypes}{%
-    \gnterm[1]{jtype},\gellipse,\gnterm[n]{jtype}}
-\end{grammar}
-%
-where \gnterm{jqid} is a qualified Java identifier and \gnterm{jtype} a Java
-types as defined in~\cite{gosling-etal:Java}.
-
-\begin{verbatim}
-FIXME: 
-- force the inclusion of the return type in case of "new"?
-\end{verbatim}
-
-\subsection{.NET Calls}
-
-The syntax for the specification of external entities under the \code{dotnet}
-calling convention is
-
-\end{FUTURE}% =============================================================
-
-
-\newpage
-\section{Marshalling}
-\label{sec:marshalling}
-
-In addition to the language extension discussed in previous sections, the FFI
-includes a set of standard libraries, which ease portable use of foreign
-functions as well as marshalling of compound structures.  Generally, the
-marshalling of Haskell structures into a foreign representation and vice versa
-can be implemented in either Haskell or the foreign language.  At least where
-the foreign language is at a significantly lower level, e.g.\ C, there are
-good reasons for doing the marshalling in Haskell:
-%
-\begin{itemize}
-\item Haskell's lazy evaluation strategy would require any foreign code that
-  attempts to access Haskell structures to force the evaluation of these
-  structures before accessing them. This would lead to complicated code in the
-  foreign language, but does not need any extra consideration when coding the
-  marshalling in Haskell.
-\item Despite the fact that marshalling code in Haskell tends to look like C
-  in Haskell syntax, the strong type system still catches many errors that
-  would otherwise lead to difficult-to-debug runtime faults.
-\item Direct access to Haskell heap structures from a language like
-  C---especially, when marshalling from C to Haskell, i.e., when Haskell
-  structures are created---carries the risk of corrupting the heap, which
-  usually leads to faults that are very hard to debug.
-\end{itemize}
-%
-Consequently, the Haskell FFI emphasises Haskell-side marshalling.
-
-The interface to the marshalling libraries is provided by the module
-\code{Foreign} plus a language-dependent module per supported language.  In
-particular, the standard requires the availability of the module
-\code{CForeign}, which simplifies portable interfacing with external C code.
-Language-dependent modules, such as \code{CForeign}, generally provide Haskell
-types representing the basic types of the foreign language using a
-representation that is compatible with the foreign types as implemented by the
-default implementation of the foreign language on the present architecture.
-This is especially important for languages where the standard leaves some
-aspects of the implementation of basic types open.  For example, in C, the
-size of the various integral types is not fixed.  Thus, to represent C
-interfaces faithfully in Haskell, for each integral type in C, we need to have
-an integral type in Haskell that is guaranteed to have the same size as the
-corresponding C type.
-
-In the following, the interface of the language independent support is
-defined.  The interface for C-specific support is discussed in
-Section~\ref{sec:c-marshalling}. 
-
-\subsection{\code{Foreign}}
-\label{sec:Foreign}
-
-The module \code{Foreign} combines the interfaces of all modules providing
-language-independent marshalling support.  These modules are \code{Bits},
-\code{Int}, \code{Word}, \code{Ptr}, \code{ForeignPtr}, \code{StablePtr},
-\code{Storable}, \code{MarshalAlloc}, \code{MarshalArray},
-\code{MarshalError}, and \code{MarshalUtils}.
-
-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, \code{Foreign} provides the following
-primitive:
-%
-\begin{codedesc}
-\item[unsafePerformIO ::\ IO a -> a] Return the value resulting from executing
-  the \code{IO} action.  This value should be independent of the environment;
-  otherwise, the system behaviour is undefined.
-  
-  If the \code{IO} computation wrapped in \code{unsafePerformIO} performs side
-  effects, then the relative order in which those side effects take place
-  (relative to the main \code{IO} trunk, or other calls to
-  \code{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
-  \code{unsafePerformIO} may compromise typing; to avoid this, the programmer
-  should ensure that the result of \code{unsafePerformIO} has a monomorphic
-  type.
-\end{codedesc}
-
-\subsection{\code{Bits}}
-
-This module provides functions implementing typical bit operations overloaded
-for the standard integral types \code{Int} and \code{Integer} as well as the
-types provided by the modules \code{Int} and \code{Word} in
-Section~\ref{sec:Int-Word}.  The overloading is implemented via a new type
-class \code{Bits}, which is a subclass of \code{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 \code{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., \code{Integer}), \code{rotate} is equivalent to
-  \code{shift}.  An instance can define either this unified \code{rotate} or
-  \code{rotateL} and \code{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 \code{a} and whether these values are
-  signed.  These functions never evaluate their argument.  The function
-  \code{bitSize} is undefined for unbounded types (e.g., \code{Integer}).
-
-\item[shiftL,~~shiftR~~::\ Bits a => a -> Int -> a]
-\item[rotateL,~rotateR~::\ Bits a => a -> Int -> a]\combineitems The functions
-  \code{shiftR} and \code{rotateR} are synonyms for \code{shift} and
-  \code{rotate}; \code{shiftL} and \code{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 \code{Bits} must include
-definitions for the following functions: \code{(.\&.)}, \code{(.|.)},
-\code{xor}, \code{complement}, \code{shift}, \code{rotate}, \code{bitSize},
-and \code{isSigned}. 
-
-\subsection{\code{Int} and \code{Word}}
-\label{sec:Int-Word}
-
-The two modules \code{Int} and \code{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            & \code{Int8}  & \code{Word8}\\
-    16           & \code{Int16} & \code{Word16}\\
-    32           & \code{Int32} & \code{Word32}\\
-    64           & \code{Int64} & \code{Word64}\\
-    \hline
-  \end{tabular}
-\end{quote}
-%
-For these integral types, the modules \code{Int} and \code{Word} export class
-instances for the class \code{Bits} and all type classes for which \code{Int}
-has an instance in the Haskell 98 Prelude and standard libraries.  The
-constraints on the implementation of these instances are also the same as
-those outlined for \code{Int} in the Haskell Report.  There is, however, the
-additional constraint that all arithmetic on the fixed-sized types is
-performed modulo \(2^n\).
-
-\subsection{\code{Ptr}}
-\label{sec:Ptr}
-
-The module \code{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.
-
-\subsubsection{Data Pointers}
-
-The interface defining data pointers and associated operations is as follows:
-%
-\begin{codedesc}
-\item[data Ptr a] A value of type \code{Ptr a} represents a pointer to an
-  object, or an array of objects, which may be marshalled to or from Haskell
-  values of type \code{a}.  The type \code{a} will normally be an instance of
-  class \code{Storable} (see Section~\ref{sec:Storable}), which provides the
-  necessary marshalling operations.
-
-  Instances for the classes \code{Eq}, \code{Ord}, and \code{Show} are
-  provided. 
-\item[nullPtr ::\ Ptr a] The constant \code{nullPtr} contains a distinguished
-  value of \code{Ptr} that is not associated with a valid memory location.
-\item[castPtr ::\ Ptr a -> Ptr b] The \code{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, \code{alignPtr} yields an address, the same or next
-  higher, that fulfills the alignment constraint. An alignment constraint
-  \code{x} is fulfilled by any address divisible by \code{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 \code{Int} for pointer differences
-essentially forces any implementation to represent \code{Int} in as many bits
-as used in the representation of pointer values.
-
-\subsubsection{Function Pointers}
-
-The interface defining function pointers and associated operations is as
-follows:
-%
-\begin{codedesc}
-\item[data FunPtr a] A value of type \code{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 \code{Eq}, \code{Ord}, and \code{Show} are
-  provided.
-\item[nullFunPtr ::\ FunPtr a] The constant \code{nullFunPtr} contains a
-  distinguished value of \code{FunPtr} that is not associated with a valid
-  memory location.
-\item[castFunPtr ::\ FunPtr a -> FunPtr b] Cast a \code{FunPtr} to a
-  \code{FunPtr} of a different type.
-\item[freeHaskellFunPtr ::\ FunPtr a -> IO ()] Release the storage associated
-  with the given \code{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 \code{castFunPtrToPtr} and
-\code{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 \code{Ptr}s to \code{FunPtr}s and vice versa.
-\end{codedesc}
-
-\subsection{\code{ForeignPtr}}
-\label{sec:ForeignPtr}
-
-The type \code{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
-\code{ForeignPtr} is parameterised in the same way as \code{Ptr} (cf.\ 
-Section~\ref{sec:Ptr}), but in contrast to vanilla memory references of type
-\code{Ptr}, \code{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 \code{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:
-%
-\begin{quote}
-\begin{verbatim}
-type FinalizerPtr        a = FunPtr (           Ptr a -> IO ())
-type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ())
-\end{verbatim}
-\end{quote}
-%
-A foreign finalizer is represented as a pointer to a C function of type
-\code{Ptr a -> IO ()} or a C function of type \code{Ptr env -> Ptr a -> IO
-  ()}, where \code{Ptr env} represents an optional environment passed to the
-finalizer on invocation.  That is, a foreign finalizer attached to a finalized
-pointer \code{ForeignPtr a} gets the finalized pointer in the form of a raw
-pointer of type \code{Ptr a} as an argument when it is invoked.  In addition,
-a foreign finalizer of type \code{FinalizerEnvPtr env a} also gets an
-environment pointer of type \code{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 \code{ForeignPtr} and associated operations have the following
-signature and purpose:
-%
-\begin{codedesc}
-\item[data ForeignPtr a] A value of type \code{ForeignPtr a} represents a
-  pointer to an object, or an array of objects, which may be marshalled to or
-  from Haskell values of type \code{a}.  The type \code{a} will normally be an
-  instance of class \code{Storable} (see Section~\ref{sec:Storable}), which
-  provides the marshalling operations.
-  
-  Instances for the classes \code{Eq}, \code{Ord}, and \code{Show} are
-  provided.  Equality and ordering of two foreign pointers are the same as for
-  the plain pointers obtained with \code{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 \code{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
-  %
-  \begin{quote}
-\begin{verbatim}
-newForeignPtr finalizer ptr = 
-  do
-    fp <- newForeignPtr_ ptr
-    addForeignPtrFinalizer finalizer fp
-    return fp
-\end{verbatim}
-  \end{quote}
-   
-\item[newForeignPtrEnv ::\ FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO
-  (ForeignPtr a)] This variant of \code{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 \code{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 \code{a}.  The size of
-  the memory area is determined by the function \code{Storable.sizeOf}
-  (Section~\ref{sec:Storable}).  This corresponds to
-  \code{MarshalAlloc.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
-  \code{MarshalAlloc.malloc}; so, \code{MarshalAlloc.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 \code{mallocForeignPtr}, \code{MarshalAlloc.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 \code{MarshalArray}'s
-  \code{mallocArray} and \code{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 \code{MarshalAlloc.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
-  \code{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
-  \code{withForeignPtr} bracket.
-
-  More precisely, the foreign pointer may be finalized after
-  \code{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
-  \code{withForeignPtr} is finished, unless the function
-  \code{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 \code{ForeignPtr}, using the operations from the
-  \code{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 \code{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, \code{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 \code{touchForeignPtr}.  Until the
-  \code{unsafeForeignPtrToPtr} is executed, the thunk representing the
-  suspended call keeps the foreign pointer alive.  Afterwards, the
-  \code{touchForeignPtr} keeps the pointer alive.
-  
-  To avoid subtle coding errors, hand written marshalling code should
-  preferably use the function \code{withForeignPtr} rather than
-  \code{unsafeForeignPtrToPtr} and \code{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 \code{IO}
-  actions. In particular, \code{withForeignPtr} does a \code{touchForeignPtr}
-  after it executes the user action.
-  
-  This function can be used to express liveness dependencies between
-  \code{ForeignPtr}s: For example, if the finalizer for one \code{ForeignPtr}
-  touches a second \code{ForeignPtr}, then it is ensured that the second
-  \code{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 \code{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
-  \code{ForeignPtr} parameterised by one type into another type.
-\end{codedesc}
-
-\subsection{\code{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 \code{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 \code{makeStablePtr}.  If the argument to
-  \code{deRefStablePtr} has already been freed using \code{freeStablePtr}, the
-  behaviour of \code{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 \code{deRefStablePtr} or \code{freeStablePtr}, the behaviour is
-  undefined.  However, the stable pointer may still be passed to
-  \code{castStablePtrToPtr}, but the \code{Ptr ()} value returned by
-  \code{castStablePtrToPtr}, in this case, is undefined (in particular, it may
-  be \code{Ptr.nullPtr}).  Nevertheless, the call to \code{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 \code{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 \code{Storable}
-  (Section~\ref{sec:Storable}) leads to undefined behaviour.
-  
-\item[castPtrToStablePtr ::\ Ptr () -> StablePtr a] The inverse of
-  \code{castStablePtrToPtr}, i.e., we have the identity
-  %
-  \begin{quote}
-\begin{verbatim}
-sp == castPtrToStablePtr (castStablePtrToPtr sp)
-\end{verbatim}
-  \end{quote}
-  %
-  for any stable pointer \code{sp} on which \code{freeStablePtr} has not been
-  executed yet.  Moreover, \code{castPtrToStablePtr} may only be applied to
-  pointers that have been produced by \code{castStablePtrToPtr}.
-\end{codedesc}
-
-It is important to free stable pointers that are no longer required by using
-\code{freeStablePtr}.  Otherwise, the object referenced by the stable pointer
-will be retained in the heap.
-
-
-\subsection{\code{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 \code{Storable}
-provides routines that manipulate primitive data types stored in unstructured
-memory blocks.  The class \code{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 \code{Ptr a}
-(Section~\ref{sec:Ptr}), where \code{a} is a storable type.  The type argument
-to \code{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 \code{Storable} is instantiated for all standard basic types of
-Haskell, the fixed size integral types of the modules \code{Int} and
-\code{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 \code{Storable} for foreign pointers.  The intention
-is to ensure that storing a foreign pointer requires an explicit cast to a
-plain \code{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
-\code{Storable} are as follows:
-%
-\begin{codedesc}
-\item[sizeOf~~~~::\ Storable a => a -> Int]
-\item[alignment~::\ Storable a => a -> Int]\combineitems The function
-  \code{sizeOf} computes the storage requirements (in bytes) of the argument,
-  and alignment computes the alignment constraint of the argument.  An
-  alignment constraint \code{x} is fulfilled by any address divisible by
-  \code{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 \code{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 \code{peek} and \code{poke} functions might require
-properly aligned addresses to function correctly.  Thus, portable code should
-ensure that when peeking or poking values of some type \code{a}, the alignment
-constraint for \code{a}, as given by the function \code{alignment} is
-fulfilled.
-
-A minimal complete definition of \code{Storable} needs to define
-\code{sizeOf}, \code{alignment}, one of \code{peek}, \code{peekElemOff}, or
-\code{peekByteOff}, and one of \code{poke}, \code{pokeElemOff}, and
-\code{pokeByteOff}.
-
-\subsection{\code{MarshalAlloc}}
-\label{sec:MarshalAlloc}
-
-The module \code{MarshalAlloc} 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 \code{a}.  The size of the memory area is
-  determined by the function \code{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 \code{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 \code{alloca}, but
-  allocate a memory area of the given size.  The same alignment constraint as
-  for \code{mallocBytes} holds.
-  
-\item[realloc ::\ Storable b => Ptr a -> IO (Ptr b)] Resize a memory area that
-  was allocated with \code{malloc} or \code{mallocBytes} to the size needed to
-  store values of type \code{b}.  The returned pointer may refer to an
-  entirely different memory area, but will be suitably aligned to hold values
-  of type \code{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 \code{a} and \code{b}.  If the argument to \code{realloc} is
-  \code{Ptr.nullPtr}, \code{realloc} behaves like \code{malloc}.
-  
-\item[reallocBytes ::\ Ptr a -> Int -> IO (Ptr a)] As \code{realloc}, but
-  allocate a memory area of the given size.  In addition, if the requested size
-  is 0, \code{reallocBytes} behaves like \code{free}.
-  
-\item[free ::\ Ptr a -> IO ()] Free a block of memory that was allocated with
-  \code{malloc}, \code{mallocBytes}, \code{realloc}, \code{reallocBytes}, or
-  any of the allocation functions from \code{MarshalArray} (see
-  Section~\ref{sec:MarshalArray}).
-
-\item[finalizerFree ::\ FinalizerPtr a] Foreign finalizer that performs the
-  same operation as \code{free}.
-\end{codedesc}
-%
-If any of the allocation functions fails, a value of \code{Ptr.nullPtr} is
-produced.  If \code{free} or \code{reallocBytes} is applied to a memory area
-that has been allocated with \code{alloca} or \code{allocaBytes}, the
-behaviour is undefined.  Any further access to memory areas allocated with
-\code{alloca} or \code{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
-\code{realloc}, \code{reallocBytes}, or \code{free} entails undefined
-behaviour.
-
-\subsection{\code{MarshalArray}}
-\label{sec:MarshalArray}
-
-The module \code{MarshalArray} 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 \code{CString} (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 \code{0}---e.g., \code{mallocArray} allocates space for an
-array of the given size, whereas \code{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 \code{malloc}, \code{alloca}, and
-  \code{realloc} provided by the module \code{MarshalAlloc}
-  (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 \code{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 \code{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 \code{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 \code{==}) to the
-  terminator are marshalled.
-
-\item[pokeArray0 ::\ Storable a => a -> Ptr a -> {[a]} -> IO ()]
-  Marshal an array like \code{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 \code{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 \code{mallocArray} and \code{allocaArray},
-  respectively, with \code{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 \code{mallocArray0} and \code{allocaArray0},
-  respectively, with the function \code{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
-  \code{MarshalUtils.copyBytes} and \code{MarshalUtils.moveBytes},
-  respectively (Section~\ref{sec:MarshalUtils}).  In particular,
-  \code{moveArray} allows the source and destination array to overlap, whereas
-  \code{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
-  \code{MarshalUtils} 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}
-
-\subsection{\code{MarshalError}}
-\label{sec:MarshalError}
-
-The module \code{MarshalError} provides language independent routines for
-converting error conditions of external functions into Haskell \code{IO} monad
-exceptions.  It consists out of two parts.  The first part extends the I/O
-error facilities of the \code{IO} module of the Haskell 98 Library Report 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.
-
-\subsubsection{I/O Errors}
-%
-The following functions can be used to construct values of type
-\code{IOError}.
-%
-\begin{codedesc}
-\item[data IOErrorType] This is an abstract type that contains a value for
-  each variant of \code{IOError}.
-
-\item[mkIOError ::\ IOErrorType -> String -> Maybe Handle -> Maybe FilePath
-  -> IOError] Construct an \code{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}
-
-\subsubsection{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 \code{True} when applied to the result of that
-  computation, raise an \code{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\us ::\ (a -> Bool) -> (a -> String) -> IO a -> IO ()]
-  Operate as \code{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\us~::\ (Ord a, Num a) => (a -> String) -> IO a -> IO ()]\combineitems
-  These two functions are instances of \code{throwIf} and \code{throwIf\us},
-  respectively, where the predicate is \code{(< 0)}.
-  
-\item[throwIfNull ::\ String -> IO (Ptr a) -> IO (Ptr a)] This is an instance
-  of \code{throwIf}, where the predicate is \code{(== Ptr.nullPtr)} and the
-  error message is constant.
-
-\item[void ::\ IO a -> IO ()]
-  Discard the result of a computation.
-\end{codedesc}
-
-\subsection{\code{MarshalUtils}}
-\label{sec:MarshalUtils}
-
-Finally, the module \code{MarshalUtils} provides a set of useful auxiliary
-routines. 
-%
-\begin{codedesc}
-\item[new ::\ Storable a => a -> IO (Ptr a)] This function first applies
-  \code{MarshalAlloc.malloc} (Section~\ref{sec:MarshalAlloc}) to its
-  argument, and then, stores the argument in the newly allocated memory area
-  using \code{Storable.poke} (Section~\ref{sec:Storable}).
-  
-\item[with ::\ Storable a => a -> (Ptr a -> IO b) -> IO b] This function is
-  like \code{new}, but uses \code{MarshalAlloc.alloca} instead of
-  \code{MarshalAlloc.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 \code{False} is represented by
-  \code{0} and \code{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 \code{a} to a function that
-  marshals a value of type \code{Maybe a}.  In case, where the latter is
-  \code{Nothing}, return \code{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
-  \code{MarshalAlloc.alloca} based marshalling function for \code{a} to
-  \code{Maybe a}.  It marshals values \code{Nothing} in the same way as
-  \code{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 \code{b}, lift it to producing a value of type \code{Maybe b}.
-  If the pointer is \code{Ptr.nullPtr}, produce \code{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 \code{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
-  \code{memcpy()} and \code{memmove()}, respectively.  As with their C
-  counterparts, \code{moveBytes} allows the source and destination array to
-  overlap, whereas \code{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}
-
-\newpage
-\section{C-Specific Marshalling}
-\label{sec:c-marshalling}
-
-\subsection{\code{CForeign}}
-\label{sec:CForeign}
-
-The module \code{CForeign} combines the interfaces of all modules providing
-C-specific marshalling support.  The modules are \code{CTypes},
-\code{CString}, and \code{CError}.
-
-\begin{table}
-  \begin{center}
-    \begin{tabular}{|l|l|l|}
-      \hline
-      C symbol          & Haskell symbol & Constraint on concrete C type\\
-      \hline\hline
-      \code{HsChar}     & \code{Char}    
-      & integral type\\
-      \hline
-      \code{HsInt}      & \code{Int}
-      & signed integral type, $\geq30$ bit\\
-      \hline
-      \code{HsInt8}     & \code{Int8}
-      & signed integral type, 8 bit; \code{int8\_t} if available\\
-      \hline
-      \code{HsInt16}    & \code{Int16}
-      & signed integral type, 16 bit; \code{int16\_t} if available\\
-      \hline
-      \code{HsInt32}    & \code{Int32}
-      & signed integral type, 32 bit; \code{int32\_t} if available\\
-      \hline
-      \code{HsInt64}    & \code{Int64}
-      & signed integral type, 64 bit; \code{int64\_t} if available\\ 
-      \hline
-      \code{HsWord8}    & \code{Word8}
-      & unsigned integral type, 8 bit; \code{uint8\_t} if available\\
-      \hline
-      \code{HsWord16}   & \code{Word16}
-      & unsigned integral type, 16 bit; \code{uint16\_t} if available\\
-      \hline
-      \code{HsWord32}   & \code{Word32}
-      & unsigned integral type, 32 bit; \code{uint32\_t} if available\\
-      \hline
-      \code{HsWord64}   & \code{Word64}
-      & unsigned integral type, 64 bit; \code{uint64\_t} if available\\
-      \hline
-      \code{HsFloat}    & \code{Float}
-      & floating point type\\
-     \hline
-      \code{HsDouble}   & \code{Double}
-      & floating point type\\
-     \hline
-      \code{HsBool}     & \code{Bool}
-      & \code{int}\\
-     \hline
-      \code{HsPtr}      & \code{Ptr a}
-      & \code{(void *)}\\
-     \hline
-      \code{HsFunPtr}   & \code{FunPtr a}
-      & \code{(void (*)(void))}\\
-     \hline
-      \code{HsStablePtr}& \code{StablePtr a}
-      & \code{(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
-      \code{HS\_CHAR\_MIN} & \code{minBound ::\ Char}
-      & \\
-      \hline
-      \code{HS\_CHAR\_MAX} & \code{maxBound ::\ Char}
-      & \\
-      \hline
-      \code{HS\_INT\_MIN} & \code{minBound ::\ Int}
-      & \\
-      \hline
-      \code{HS\_INT\_MAX} & \code{maxBound ::\ Int}
-      & \\
-      \hline
-      \code{HS\_INT8\_MIN} & \code{minBound ::\ Int8}
-      & \\
-      \hline
-      \code{HS\_INT8\_MAX} & \code{maxBound ::\ Int8}
-      & \\
-      \hline
-      \code{HS\_INT16\_MIN} & \code{minBound ::\ Int16}
-      & \\
-      \hline
-      \code{HS\_INT16\_MAX} & \code{maxBound ::\ Int16}
-      & \\
-      \hline
-      \code{HS\_INT32\_MIN} & \code{minBound ::\ Int32}
-      & \\
-      \hline
-      \code{HS\_INT32\_MAX} & \code{maxBound ::\ Int32}
-      & \\
-      \hline
-      \code{HS\_INT64\_MIN} & \code{minBound ::\ Int64}
-      & \\
-      \hline
-      \code{HS\_INT64\_MAX} & \code{maxBound ::\ Int64}
-      & \\
-      \hline
-      \code{HS\_WORD8\_MAX} & \code{maxBound ::\ Word8}
-      & \\
-      \hline
-      \code{HS\_WORD16\_MAX} & \code{maxBound ::\ Word16}
-      & \\
-      \hline
-      \code{HS\_WORD32\_MAX} & \code{maxBound ::\ Word32}
-      & \\
-      \hline
-      \code{HS\_WORD64\_MAX} & \code{maxBound ::\ Word64}
-      & \\
-      \hline
-      \code{HS\_FLOAT\_RADIX} & \code{floatRadix ::\ Float}
-      & \\
-      \hline
-      \code{HS\_FLOAT\_ROUND} & n/a
-      & rounding style as per~\cite{C99}\\
-      \hline
-      \code{HS\_FLOAT\_EPSILON} & n/a
-      & difference between 1 and the least value greater
-      than 1 as per~\cite{C99}\\
-      \hline
-      \code{HS\_DOUBLE\_EPSILON} & n/a
-      & (as above)\\
-      \hline
-      \code{HS\_FLOAT\_DIG} & n/a
-      & number of decimal digits as per~\cite{C99}\\
-      \hline
-      \code{HS\_DOUBLE\_DIG} & n/a
-      & (as above)\\
-      \hline
-      \code{HS\_FLOAT\_MANT\_DIG} & \code{floatDigits ::\ Float}
-      & \\
-      \hline
-      \code{HS\_DOUBLE\_MANT\_DIG} & \code{floatDigits ::\ Double}
-      & \\
-      \hline
-      \code{HS\_FLOAT\_MIN} & n/a
-      & minimum floating point number as per~\cite{C99}\\
-      \hline
-      \code{HS\_DOUBLE\_MIN} & n/a
-      & (as above)\\
-      \hline
-      \code{HS\_FLOAT\_MIN\_EXP} & \code{fst .\ floatRange ::\ Float}
-      & \\
-      \hline
-      \code{HS\_DOUBLE\_MIN\_EXP} & \code{fst .\ floatRange ::\ Double}
-      & \\
-      \hline
-      \code{HS\_FLOAT\_MIN\_10\_EXP} & n/a
-      & minimum decimal exponent as per~\cite{C99}\\
-      \hline
-      \code{HS\_DOUBLE\_MIN\_10\_EXP} & n/a
-      & (as above)\\
-      \hline
-      \code{HS\_FLOAT\_MAX} & n/a
-      & maximum floating point number as per~\cite{C99}\\
-      \hline
-      \code{HS\_DOUBLE\_MAX} & n/a
-      & (as above)\\
-      \hline
-      \code{HS\_FLOAT\_MAX\_EXP} & \code{snd .\ floatRange ::\ Float}
-      & \\
-      \hline
-      \code{HS\_DOUBLE\_MAX\_EXP} & \code{snd .\ floatRange ::\ Double}
-      & \\
-      \hline
-      \code{HS\_FLOAT\_MAX\_10\_EXP} & n/a
-      & maximum decimal exponent as per~\cite{C99}\\
-      \hline
-      \code{HS\_DOUBLE\_MAX\_10\_EXP} & n/a
-      & (as above)\\
-      \hline
-      \code{HS\_BOOL\_FALSE} & False
-      & \\
-      \hline
-      \code{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 \code{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 \code{HsT} represents a Haskell type \code{T}, the occurrence of \code{T}
-in a foreign function declaration should be matched by \code{HsT} in the
-corresponding C function prototype.  Indeed, where the Haskell system
-translates Haskell to C code that invokes \code{foreign} \code{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 \code{nullPtr} is mapped to \code{(HsPtr)
-  NULL} in C and \code{nullFunPtr} is mapped to \code{(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 \code{HS\_FLOAT\_ROUND} are constants that are suitable for use in
-\code{\#if} preprocessing directives.  Note that there is only one rounding
-style (\code{HS\_FLOAT\_ROUND}) and one radix (\code{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 \code{HsInt64} and \code{HsWord64} as a structure.  In
-this case, the bounds \code{HS\_INT64\_MIN}, \code{HS\_INT64\_MAX}, and
-\code{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 \code{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 \code{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 \code{argc} and \code{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
-\code{hs\_exit()}.  Multiple invocations of \code{hs\_init()} are permitted,
-provided that they are followed by an equal number of calls to
-\code{hs\_exit()} and that the first call to \code{hs\_exit()} is after the
-last call to \code{hs\_init()}.  In addition to nested calls to
-\code{hs\_init()}, the Haskell system may be de-initialised with
-\code{hs\_exit()} and be re-initialised with \code{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 \code{hs\_init()}.  Moreover, \code{hs\_init()} may
-be called with \code{NULL} for both \code{argc} and \code{argv}, signalling
-the absence of command line arguments.
-
-The function \code{hs\_set\_argv()} sets the values returned by the functions
-\code{getProgName} and \code{getArgs} of the module \code{System} defined in
-the Haskell 98 Library Report.  This function may only be invoked after
-\code{hs\_init()}.  Moreover, if \code{hs\_set\_argv()} is called at all, this
-call must precede the first invocation of \code{getProgName} and
-\code{getArgs}.  Note that the separation of \code{hs\_init()} and
-\code{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 \code{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 \code{unsafe} into Haskell code nor may it be used
-from a finalizer.
-
-Finally, \code{hs\_free\_stable\_ptr()} and \code{hs\_free\_fun\_ptr()} are
-the C counterparts of the Haskell functions \code{freeStablePtr} and
-\code{freeHaskellFunPtr}.
-
-\subsection{\code{CTypes}}
-\label{sec:CTypes}
-
-The modules \code{CTypes} 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 \code{CT} representing a C type \code{t}:
-%
-\begin{itemize}
-\item If a C function prototype has \code{t} as an argument or result type,
-  the use of \code{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 \code{CT} has a valid
-  representation in C.
-\item \code{Storable.sizeOf (undefined ::\ CT)} will yield the same value as
-  \code{sizeof (t)} in C.
-\item \code{Storable.alignment (undefined ::\ CT)} matches the alignment
-  constraint enforced by the C implementation for \code{t}.
-\item \code{Storable.peek} and \code{Storable.poke} map all values of
-  \code{CT} to the corresponding value of \code{t} and vice versa.
-\item When an instance of \code{Bounded} is defined for \code{CT}, the values
-  of \code{minBound} and \code{maxBound} coincide with \code{t\_MIN} and
-  \code{t\_MAX} in C.
-\item When an instance of \code{Eq} or \code{Ord} is defined for \code{CT},
-  the predicates defined by the type class implement the same relation as the
-  corresponding predicate in C on \code{t}.
-\item When an instance of \code{Num}, \code{Read}, \code{Integral},
-  \code{Fractional}, \code{Floating}, \code{RealFrac}, or \code{RealFloat} is
-  defined for \code{CT}, the arithmetic operations defined by the type class
-  implement the same function as the corresponding arithmetic operations (if
-  available) in C on \code{t}.
-\item When an instance of \code{Bits} is defined for \code{CT}, the bitwise
-  operation defined by the type class implement the same function as the
-  corresponding bitwise operation in C on \code{t}.
-\end{itemize}
-%
-All types exported by \code{CTypes} must be represented as \code{newtype}s of
-basic foreign types as defined in Section~\ref{sec:foreign-types} and the
-export must be abstract.
-
-The module \code{CTypes} provides the following integral types, including
-instances for \code{Eq}, \code{Ord}, \code{Num}, \code{Read}, \code{Show},
-\code{Enum}, \code{Storable}, \code{Bounded}, \code{Real}, \code{Integral},
-and \code{Bits}:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    \code{CChar}     & \code{char}\\\hline
-    \code{CSChar}    & \code{signed char}\\\hline
-    \code{CUChar}    & \code{unsigned char}\\\hline
-    \code{CShort}    & \code{short}\\\hline
-    \code{CUShort}   & \code{unsigned short}\\\hline
-    \code{CInt}      & \code{int}\\\hline
-    \code{CUInt}     & \code{unsigned int}\\\hline
-    \code{CLong}     & \code{long}\\\hline
-    \code{CULong}    & \code{unsigned long}\\\hline
-    \code{CLLong}    & \code{long long}\\\hline
-    \code{CULLong}   & \code{unsigned long long}\\\hline
-  \end{tabular}
-\end{quote}
-%
-Moreover, it provides the following floating point types, including instances
-for \code{Eq}, \code{Ord}, \code{Num}, \code{Read}, \code{Show}, \code{Enum},
-\code{Storable}, \code{Real}, \code{Fractional}, \code{Floating},
-\code{RealFrac}, and \code{RealFloat}:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    \code{CFloat}    & \code{float}\\\hline
-    \code{CDouble}   & \code{double}\\\hline
-    \code{CLDouble}  & \code{long double}\\\hline
-  \end{tabular}
-\end{quote}
-%
-The module provides the following integral types, including instances for
-\code{Eq}, \code{Ord}, \code{Num}, \code{Read}, \code{Show}, \code{Enum},
-\code{Storable}, \code{Bounded}, \code{Real}, \code{Integral}, and
-\code{Bits}:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    \code{CPtrdiff}  & \code{ptrdiff\_t}\\\hline
-    \code{CSize}     & \code{size\_t}\\\hline
-    \code{CWchar}    & \code{wchar\_t}\\\hline
-    \code{CSigAtomic}& \code{sig\_atomic\_t}\\\hline
-  \end{tabular}
-\end{quote}
-%
-Moreover, it provides the following numeric types, including instances for
-\code{Eq}, \code{Ord}, \code{Num}, \code{Read}, \code{Show}, \code{Enum}, and
-\code{Storable}:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    \code{CClock}    & \code{clock\_t}\\\hline
-    \code{CTime}     & \code{time\_t}\\\hline
-  \end{tabular}
-\end{quote}
-%
-And finally, the following types, including instances for \code{Eq} and
-\code{Storable}, are provided:
-%
-\begin{quote}
-  \begin{tabular}{|l|l|l|}
-    \hline
-    Haskell type     & Represented C type\\\hline\hline
-    \code{CFile}     & \code{FILE}\\\hline
-    \code{CFpos}     & \code{fpos\_t}\\\hline
-    \code{CJmpBuf}   & \code{jmp\_buf}\\\hline
-  \end{tabular}
-\end{quote}
-
-\subsection{\code{CString}}
-\label{sec:CString}
-
-The module \code{CString} 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 \code{CString} combine memory
-allocation and marshalling.  The translation between Unicode and the encoding
-of the current locale may be lossy.  The function \code{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 \code{CString} 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 \code{MarshalAlloc.free}.
-
-\item[withCString~~~~::\ String -> (CString~~~~-> IO a) -> IO a]
-\item[withCStringLen~::\ String -> (CStringLen~-> IO a) -> IO a] \combineitems
-  These two routines operate as \code{newCString} and \code{newCStringLen},
-  respectively, but handle memory allocation and deallocation like
-  \code{MarshalAlloc.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 \code{Char} as single byte characters.  Hence, the module
-\code{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 \code{wchar\_t} for character
-sets that cannot be encoded in byte strings, the module \code{CString} also
-exports a variant of the above string marshalling routines for wide
-characters---i.e., for the C \code{wchar\_t} type.\footnote{Note that if the
-  platform defines \code{\_\_STDC\_ISO\_10646\_\_} then \code{wchar\_t}
-  characters are Unicode code points, and thus, the conversion between Haskell
-  \code{Char} and \code{CWchar} is a simple cast.  On other platforms, the
-  translation is locale-dependent, just as for \code{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}
-
-\subsection{\code{CError}}
-\label{sec:CError}
-
-The module CError facilitates C-specific error handling of \code{errno}.  In
-Haskell, we represent values of \code{errno} by
-%
-\begin{quote}
-\begin{verbatim}
-newtype Errno = Errno CInt
-\end{verbatim}
-\end{quote}
-%
-which has an instance for the type class \code{Eq}.  The implementation of
-\code{Errno} is disclosed on purpose.  Different operating systems and/or C
-libraries often support different values of \code{errno}.  This module defines
-the common values, but due to the open definition of \code{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 \code{CError} provides the following functions:
-%
-\begin{codedesc}
-\item[isValidErrno ::\ Errno -> Bool] Yield \code{True} if the given
-  \code{Errno} value is valid on the system.  This implies that the \code{Eq}
-  instance of \code{Errno} is also system dependent as it is only defined for
-  valid values of \code{Errno}.
-
-\item[getErrno ::\ IO Errno] Get the current value of \code{errno}.
-
-\item[resetErrno ::\ IO ()] Reset \code{errno} to \code{eOK}.
-  
-\item[errnoToIOError ::\ String -> Errno -> Maybe Handle -> Maybe String ->
-  IOError] Compute a Haskell 98 I/O error based on the given \code{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 \code{errnoToIOError} to the value
-  currently returned by \code{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\us~:: (a -> Bool) -> String -> IO a -> IO ()]\combineitems
-  Behave like \code{throwErrno} in case that the result of the \code{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\us~:: (a -> Bool) -> String -> IO a -> IO ()]%
-\combineitems Like \code{throwErrnoIf} and \code{throwErrnoIf\us}, but retry
-the \code{IO} action when it yields the error code \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\us~:: Num a => String -> IO a -> IO ()]\combineitems
-  Instantiate \code{throwErrnoIf} and \code{throwErrnoIf\us} with the predicate
-  \code{(== -1)}.
-
-\item[throwErrnoIfMinus1Retry~~:: Num a => String -> IO a -> IO a]
-\item[throwErrnoIfMinus1Retry\us~:: Num a => String -> IO a -> IO ()]%
-  \combineitems Instantiate \code{throwErrnoIfRetry} and
-  \code{throwErrnoIfRetry\us} with the predicate \code{(== -1)}.
-
-\item[throwErrnoIfNull~~~~~~:: String -> IO (Ptr a) -> IO (Ptr a)]
-\item[throwErrnoIfNullRetry~:: String -> IO (Ptr a) -> IO (Ptr a)]%
-  \combineitems Instantiate \code{throwErrnoIf} and \code{throwErrnoIfRetry}
-  with the predicate \code{(== Ptr.nullPtr)}.
-\end{codedesc}
-
-
-\bibliographystyle{plain}
-\bibliography{ffi}
-
-\end{document}
diff --git a/ffi/finalizers.txt b/ffi/finalizers.txt
deleted file mode 100644 (file)
index 285b623..0000000
+++ /dev/null
@@ -1,582 +0,0 @@
-Haskell Finalizers
-==================
-
-  This is intended to be an up-to-date summary of the discussion
-  relating to finalizers on the FFI mailing list, up until the end of
-  2002.
-
-  The final decision was that, since Haskell finalizers could only be
-  implemented in GHC, we would adopt C finalizers.  The problem is
-  described in the section titled "Accessing immutable Haskell state"
-  below but boils down to atomicity assumptions made by the abstract
-  machine.
-
-  The summary is *intended* to be impartial, but since the authors
-  (Simon M. and Alastair Reid) have our own differing opinions about
-  the issues herein, no doubt we've sometimes favoured one side over
-  the other, or at least the exposition of one side of the argument
-  may be more accurate than the other.  Please accept our apologies and
-  modify accordingly.
-
-
-The main issue
-==============
-
-  The current version of the FFI spec restricts the finalizer routine
-  attached to a ForeignPtr to being a C function.  In particular, the
-  signatures of the relevant functions are:
-
-    newForeignPtr :: Ptr a -> FunPtr (Ptr a -> IO ()) -> IO (ForeignPtr a)
-    addForeignPtrFinalizer :: ForeignPtr a -> FunPtr (Ptr a -> IO ()) -> IO ()
-
-  There is an additional restriction that the C function used as the
-  finalizer may not, during its execution, call any function
-  implemented in Haskell or hs_perform_gc().  (this is the same
-  restriction placed on foreign functions imported with the 'unsafe'
-  attribute).
-
-  The primary issue under debate is whether these functions can be
-  reasonably generalised to
-
-    newForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a)
-    addForeignPtrFinalizer :: ForeignPtr a -> IO () -> IO ()
-
-  (this is a generalisation because a computation of type IO () can
-  implement a computation of type FunPtr (Ptr a -> IO ()) via 'foreign
-  import dynamic').
-
-  Note that in the current version of these functions, if the foreign
-  finalizers is allowed to call back into Haskell, you can essentially
-  implement the second version.  So removing this restriction and
-  generalising the finalizers to be of type 'IO ()' are essentially
-  the same thing.
-
-  Semantics
-  ---------
-
-    Finalizers are guaranteed to run after the ForeignPtr becomes
-    unreachable.  We neither define "unreachable" nor specify a bound
-    on the length of time between the point at which the ForeignPtr
-    becomes unreachable and the time at which the finalizer begins
-    executing.
-
-    C finalizers are atomic with respect to other C finalizers and C
-    functions called from Haskell.
-
-
-Rationale
-=========
-
-  Why is this a useful generalisation?
-
-  So far we have identified 3 useful categories of functionality that
-  would be enabled with Haskell finalizers:
-
-  Composite finalizers
-  --------------------
-
-    This is when a finalizer needs to perform multiple operations, and
-    composing them in Haskell is simpler than writing a separate C
-    routine for the composition.
-    
-    eg(1). in Text.Regex.Posx, the finalizer for a regular expression
-    needs to call both c_regfree and free on the pointer (in that
-    order).  This can be handled in three ways: in a Haskell
-    finalizer, using addForeignPtrFinalizer to add both finalizers, and
-    by writing a separate C routine which calls both functions.
-    The two Haskell alternatives are more convenient whilst the third is
-    what one would normally do as a C programmer.
-    
-    eg(2). we might want to free a composite object; say an array of
-    strings.  In C we would write the obvious C finalizer:
-
-      void freeStrings(char** ss) {
-        for( int i=0; ss[i]; ++i) { free(ss[i]); }
-        free(ss);
-      }
-
-    whereas in Haskell, we can write the finalizer more concisely as:
-    
-      do els <- peekArray ptr; mapM free els; free ptr
-    
-    The tradeoff here is between the naturalness of finalizing C
-    objects using C code and the conciseness of Haskell.
-
-    Note that in these examples it is only because we are using a
-    ForeignPtr that we have to write the finalizer in C: if we do
-    explicit allocation/freeing then it can all be done in Haskell.
-    On the other hand, if the object allocator is written in C, it is
-    usual to write the finalizer in C as well so it is not clear if
-    either example is a burden.
-
-    This issue is rather finely balanced with Haskell finalizers
-    giving little benefit over C finalizers.
-    
-
-  Taking advantage of closures
-  ----------------------------
-
-    The Haskell finalizer can have free variables, whereas the C
-    routine only has access to global variables.
-
-    eg. Suppose you have a custom allocator that requires the size of
-    the object to be passed to the free routine.  In Haskell, we'd
-    write
-
-      p <- my_allocate size
-      fp <- newForeignPtr p (my_free p size)
-
-    whereas in C we'd have to allocate a separate structure to contain
-    the pointer and its size, essentially programming the closure
-    explicitly.
-
-  Communicating with a foreign runtime/garbage collector
-  ------------------------------------------------------
-
-    The FFI standard does not currently address the issues of calling
-    languages which have their own garbage collector.  When these are
-    addressed it seems likely that we will have to provide additional
-    'hooks' into the Haskell runtime system to allow the foreign GC to
-    communicate with the Haskell GC.
-
-    George Russell claimed to have an example where it is also
-    necessary for the foreign GC to invoke Haskell finalizers, but 
-    on closer examination it became clear that what is needed is the
-    ability to call hs_free_stable_ptr / hs_free_fun_ptr and a richer
-    interface to the garbage collector to deal with cycles that span
-    both the Haskell and the foreign heap.  In the end, no need for
-    Haskell finalizers was demonstrated.
-
-
-  Expressing liveness dependencies between ForeignPtrs
-  ----------------------------------------------------
-
-    The current FFI spec says, under the documentation for touchForeignPtr:
-
-      This function can be used to express liveness dependencies
-      between ForeignPtrs: 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 touchForeignObj to
-      express the requirement that the exterior pointer must not be
-      finalized until the interior pointer is no longer referenced.
-
-    If finalizers are restricted to being C-only, then we need an
-    alternative mechanism to be able to express these dependencies.
-
-    (side note: we believe this technique doesn't work in GHC at the
-    moment, although you can achieve the desired effect using Weak
-    pointers).
-
-
-  Other cleanups
-  --------------
-
-   1. MarshalAlloc has to export a FunPtr version of free, so that it
-      can be used in a finalizer.
-
-   2. A general point: the philosophy of the FFI is to move as much
-      marshalling machinery into Haskell as possible, on the grounds
-      that we believe Haskell is likely to be more expressive than the
-      foreign language, and hence writing marshalling code in Haskell
-      is likely to be easier.  Requiring that finalizers be C
-      functions seems to go against the grain here.
-
-      On the other hand, writing the finalizer for a C object in C is
-      a very natural way to write code and allows us to take advantage
-      of what syntactic convenience and typechecking C affords us.
-
-
-  Accessing immutable Haskell state
-  ---------------------------------
-
-    There are significant implementation problems if the finalizer
-    has to evaluate a thunk (unevaluated expression) currently being
-    evaluated by the main program. 
-
-    A pure graph reduction machine performs evaluation using a series
-    of small, atomic, non-overlapping reduction steps.  Context
-    switches between threads may be made between any two reductions.
-    Unfortunately, no Haskell compiler implements pure graph reduction.
-
-    Hugs and (I believe) NHC are based on variants of the G-machine.
-    An important property of the G-machine is that reduction steps are
-    not small, not atomic and may overlap.  Making context switches
-    'between' reductions isn't feasible because there are no gaps
-    between reductions and making context switches during reductions
-    is hard because the heap isn't in a consistent state - some of the
-    essential state of the evaluation is in the stack (where it is
-    hard to access).
-
-    GHC is based on the STG-machine.  Like the G-machine, the STG
-    machine has large, non-atomic, overlapping reductions but two
-    techniques have been developed which allow context switches in
-    'the middle' of a reduction step.
-
-    1) When a thunk is being evaluated, the thunk is overwritten with
-       a 'blocking queue'.  If a thread tries to evaluate a blocking
-       queue, the thread is blocked (put to sleep, removed from the
-       running queue) and added to the queue to be restarted when the
-       thread reawakens.  (Deadlock may result in some circumstances -
-       this is handled by a generic deadlock-detection mechanism.)
-
-       A worthwhile variant of this is to delay overwriting the thunks
-       until a context switch happens.
-
-       Obviously, the use of blocking queues relies on being able to
-       block a thread.
-
-    2) The STG machine also provides a way to abandon evaluation with
-       the possibility of later choosing to evaluate it again using
-       resumable black holes.
-
-          A. Reid, 
-          Putting the Spine back in the Spineless Tagless G-machine: 
-           An Implementation of Resumable Blackholes.
-          Proceedings of Implementation of Functional Languages (IFL98), 
-          Lecture Notes in Computer Science, volume 1595, pp 189-202, 
-          Springer Verlag, 1999
-          http://www.reid-consulting-uk.ltd.uk/alastair/publications/ifl98.ps.gz
-
-       This mechanism allows the thread state on the stack to be
-       transferred back onto the heap.  That is, it is another
-       mechanism with which threads may be blocked.  Thus, on
-       encountering a thunk which is already being evaluated, we could
-       abandon evaluation of this thread and restart it later.  A
-       difficult question is how we would know when it was safe to try
-       again.
-
-       Implicit in the title of the paper is the idea that this
-       technique is only necessary in the _Spineless_ Tagless
-       G-machine but it is not actually known whether a similar
-       technique is needed in the G-machine as well.
-
-    Both techniques rely on an important detail of GHC's
-    implementation: the evaluation stack is explcitly managed by the
-    Haskell compiler.  This means that the Haskell compiler is free to
-    change and/or exploit the layout to make blocking threads or
-    construction of resumable black holes possible.
-
-    In contrast, Hugs' implementation is such that the evaluation
-    stack is managed by the C compiler severely limiting our ability
-    to implement blocking.  (NHC's implementation is currently
-    unknown.)  One possibility is to use setjmp/longjmp to discard
-    segments of the C stack (as is used to implement exception
-    handlers) to abandon evaluation until a later date.    
-
-
-  Manipulating mutable Haskell state
-  ----------------------------------
-
-    There are significant problems when one wants to manipulate
-    mutable Haskell state from a Haskell finalizer.  This is discussed in the
-    section on mutable state, below.
-
-
-  Concurrency
-  -----------
-
-    If the implementation supports preemptive concurrency, then the
-    problems with mutable state are easily solved.  With concurrency
-    *and* mutable state, there are plenty of good reasons for wanting
-    Haskell finalizers.
-    
-    Dissenting note: no example of this has been presented.  (An
-    alleged example turned out to be an example of adding a Haskell
-    finalizer to a Haskell object.  The Haskell object contained a
-    buffer which was to be flushed and deallocated when the object was
-    finalized.  The buffer happened to be a C object but clearly the
-    buffer needed to be flushed no matter what.)
-
-
-Arguments against
-=================
-
-    Apart from awkward interactions with mutable state and possible
-    implementation problems (both discussed below), the reasons for
-    wanting C finalizers are:
-
-    1. Experience.  Hugs has had C finalizers for ever, we know they
-       are sufficient and can be implemented readily.  
-
-       (NHC also has C finalizers and GHC had C finalizers for about 5
-       years before switching to Haskell finalizers.)
-
-    2. Adding Haskell finalizers drags in many concurrency issues for
-       programmers:
-       
-       - potential to introduce race conditions
-       - potential for deadlock
-       
-       As with most concurrency issues, the resulting bugs are easy to
-       introduce, hard to reproduce and hard to track down.
-       
-    3. Adding Haskell finalizers has a high implementation burden for
-       those who have not already implemented preemptive concurrency -
-       greatly increasing the complexity of implementing Haskell +
-       FFI.
-
-       It is apparently straightforward to simply delay execution of
-       finalizers until they reach 'safe' points in the IO monad but, as
-       discussed below, this runs the risk of starvation.
-       
-    4. Writing Haskell finalizers which benefit from being written in
-       Haskell instead of C (i.e., getting some advantage from the
-       more complex implementation) requires the addition of mutable
-       Haskell state which can be manipulated atomically by the main
-       program without fear of being preempted by finalizers.
-
-       These must be specified in the FFI spec and, of course, implemented.
-
-    5. The complexity of the solution seems to be out of line with the
-       simplicity of the task to be accomplished.
-
-
-Implementations
-===============
-
-  GHC
-  ---
-
-    Currently implements Haskell finalizers.  Finalizers are run in a
-    separate thread from other Haskell threads (although several
-    finalizers may be run in the same thread) using GHC's preemptive
-    concurrency.
-
-  Hugs
-  ----
-
-    A prototype patch implementing Haskell finalizers has been
-    submitted.  The technique used is to delay the execution of
-    finalizers until a "safe" point in the runtime system is reached,
-    and then recursively invoke the evaluator to run the finalizer.
-    The effect is that the finalizer can "preempt" any running Haskell
-    computation, and finalizers can even preempt each other.
-
-    The patch does not address any of the issues described in the
-    section on mutable state, below and it is believed that deadlock
-    could result if the finalizers used MVars.  More seriously, the
-    patch does not deal with the problems discussed in the section on
-    immutable state, above.
-
-    An alternative implementation would be to piggyback on Hugs'
-    cooperative concurrency and place finalizers into the "thread
-    pool" (or whatever Hugs uses for this).  Unfortunately, this runs
-    the risk of starvation since context switches only occur when
-    certain IO operations are run: programs that don't call those IO
-    operations will fail to execute finalizers.
-
-  NHC
-  ---
-
-    Malcolm Wallace claims that Haskell finalizers can also be
-    implemented in NHC.  As far as we know, there are no further
-    issues here (except those relevant to both Hugs & NHC, which are
-    discussed below).
-
-    [Closer examination suggests that NHC probably suffers from the
-    problems discussed in the section on immutable state, above.]
-
-        
-Further Implications
-====================
-
-  Implementing Haskell finalizers is not the end of the story.  Since,
-  using the implementation techniques described above, a Haskell
-  finalizer can pre-empt the currently running Haskell computation,
-  other issues arise...
-
-Mutable State in Haskell Finalizers
-===================================
-
-    IORefs are not a standard part of Haskell and are not required by
-    the FFI specification.  Nevertheless, there are three reasons why
-    we should consider them when designing the FFI.
-
-    1) They are widely implemented and heavily used.
-
-    2) If absent, they can be implemented (perhaps in an ad hoc way)
-       using mutable C state and StablePtrs.
-
-    3) Since the purpose of finalizers is to cleanup (mutable) state,
-       one of the strongest motivations for writing a finalizer in 
-       Haskell instead of C is that the finalizer's job is to cleanup
-       mutable Haskell state involving the C object.
-
-    We want to be able to use mutable Haskell state from a Haskell
-    finalizer, but we clearly can't use IORefs.  Finalizers which
-    modify IORefs will always contain race conditions.
-
-    The usual solution to this problem is to use appropriate
-    synchronisation primitives, but we don't necessarily have
-    concurrency available.
-
-    Indeed, attempting to use synchronization (i.e. MVars) from a
-    finalizer in Hugs using the implementation outlined above will
-    lead to deadlock, because the finalizer is run outside of the
-    scheduling mechanism used to implement cooperative concurrency in
-    Hugs.
-
-    Alastair Reid also argues that this restriction will lead to
-    non-portable code: anyone that requires synchronization will use
-    MVars, the code will work in GHC, will deadlock in Hugs, and won't
-    work at all in NHC (no MVars).
-
-    Solution 1 - safe points
-    ------------------------
-
-      To avoid this problem, execution of finalizers could be restricted
-      to 'safe' points in the IO monad.  For example, the programmer
-      could explicitly call a function 'runFinalizers' or we could agree
-      the certain IO operations constitute 'safe' points.  This runs the
-      risk of starvation: the finalizer may never be run if the program
-      spends all its time executing pure (non-IO) code or fails to call
-      runFinalizers often enough.  It is also rather vulnerable to
-      differences between garbage collectors in different systems: at
-      the time that a call to runFinalizers is made, a compiler with a
-      simple 2-space collector might have identified a ForeignPtr as
-      garbage and the finalizer will be run whilst a compiler with a
-      sophisticated generational collector might not yet have identified
-      the ForeignPtr as garbage and 'miss the boat'.  This may lead to
-      starvation since the 'boat' may never come back.
-
-    Solution 2 - we just don't support it
-    -------------------------------------
-
-      One solution is to simply say that using mutable state from a
-      finalizer is not supported.  Since mutable state (i.e. IORef or
-      MVar) isn't part of the Haskell 98 standard or the FFI, it would
-      appear that this conveniently sidesteps the issue.  There are two
-      problems with trying to define away the problem in this way:
-      
-      Most implementations use mutable state internally in their
-      libraries, so this might entail some implementation effort to make
-      these libraries finalizer-safe.  Without any synchronization
-      primitives, making the libraries safe might be tricky or
-      impossible (although you could back off and simply say that
-      certain library calls cannot be invoked from a finalizer).  Again,
-      this leads to portability problems and is bound to result in
-      subtle race conditions - a highly undesirable situation!
-      
-      We don't have any idea about how widespread this problem is
-      likely to be, without someone looking through the libraries.
-      SimonM had a cursory look through Hugs's IO library (actually
-      before I submitted the patch to implement Haskell finalizers)
-      and didn't see any problems.  GHC's IO library is affected; but
-      then it requires various other extensions, including Weak
-      references (which provide Haskell finalizers for Haskell
-      objects), anyhow.
-      
-    Solution 3 - find an appropriate synchronisation mechanism
-    ----------------------------------------------------------
-
-      Another solution is to find an appropriate synchronization
-      mechanism.  A problem is to find something which doesn't impose an
-      excessive burden to implement (e.g., Hugs and NHC developers
-      consider adding the mechanisms of preemptive concurrency (multiple
-      stacks, etc.) to be too much) but which will work well in code
-      which already supports preemptive concurrency.  Discussion didn't
-      go very far.
-
-
-  Issues with C concurrency
-  -------------------------
-
-    Interactions with a multithreaded C program seem highly relevant
-    but turn out to be a red herring.  The goal of the FFI is to
-    enable Haskell to communicate with foreign languages.  Even if the
-    language supports threads, this does not require that the Haskell
-    runtime should be multithreaded.  It only requires that a lock is
-    used to ensure that only one foreign thread can call into Haskell
-    at a time.  
-
-    Since the foreign language may choose to implement its own
-    scheduler and provide its own locks, it is not appropriate for the
-    Haskell runtime to choose a locking mechanism such as pthread
-    locks.  Rather, the choice of lock should be made based on the set
-    of foreign languages which interact with Haskell.
-
-  
-Interaction with co-operative concurrency
-=========================================
-
-    Earlier we mentioned that it may be possible to implement Haskell
-    finalizers using Hugs's co-operative concurrency.  Forgetting for
-    the moment the fact that NHC doesn't support this, what other
-    issues does this raise?
-
-    The main problem is one of starvation.  In a co-operative system,
-    it would be possible to delay the finalizer indefinitely, without
-    doing anything particularly strange.  Indeed, the programmer would
-    have to arrange to call yield at regular intervals and arrange
-    that pure computations always drop back to the IO monad
-    occasionally, in order to give finalizers a chance to run.
-
-    One might argue that since you have to do this anyway in Hugs -
-    another thread can only get control at an explicit yield point -
-    doing it for finalizers too isn't so bad.  However, this is a red
-    herring since cooperative concurrency is primarily used as a
-    structuring mechanism.  For example, the HGL uses a
-    producer-consumer communication pattern to communicate between the
-    event-driven window system (X11 or Win32) and the procedural
-    program.
-
-    Another red herring is the argument that, we don't guarantee the
-    promptness of finalizers (the Java community tends to the view
-    that finalizers are for last-resort cleanup only, not to be relied
-    on for normal system operation).  This is a red herring because
-    the issue is not one of 'promptness' but of 'starvation'.  We are
-    not concerned that execution of a finalizer might be delayed half
-    a second or 10 seconds or some other finite time; we are concerned
-    that the execution of the finalizer might be delayed indefinitely.
-    [It is also open to question whether lessons learnt with imperative
-    languages like Java apply to lazy languages.  For example, only
-    lazy languages have hGetContents and similar functions built using
-    unsafeInterleaveIO.]
-
-    Simon M. tends to the view that implementing Haskell finalizers
-    using co-operative concurrency isn't a particularly fruitful
-    direction to explore, unless we can't do it any other way.
-
-    Alastair Reid is of the opinion that the risk of starvation makes
-    this approach unusable.
-
-  
-Proposals
-=========
-
-1. No change to the spec for the time being.
-
-   C finalizers are subject to the same restrictions as unsafe foreign
-   imports.
-
-   Meanwhile, we can evaluate the need for and cost of implementing
-   Haskell finalizers in a range of implementations.  Note that
-   upgrading from C finalizers to Haskell finalizers would only
-   require that we say that finalizers are invoked with the equivalent
-   of a 'safe' ffi call instead of an 'unsafe' ffi call and, no doubt,
-   the addition of some convenience functions.
-
-2. No change to the spec for the time being, but we all agree to
-   implement an experimental extension to support Haskell finalizers
-   and experiment with it.
-
-3. Change the FFI spec to use Haskell finalizers.
-
-   Haskell finalizers would be restricted to not access mutable state
-   involving Haskell objects.
-
-   [The awkward construction 'mutable state involving Haskell objects'
-   is intended to cover both IORefs and any ad-hoc reinvention of
-   IORefs using mutable C state and StablePtrs.  Rephrasings welcome.]
-
-4. Support both Haskell and C finalizers.
-
-
-
---
-Simon Marlow, Alastair Reid, Simon Peyton Jones, Malcolm Wallace, Ross
-Paterson, Manuel Chakravarty, George Russell, John Meacham, and others
-on the ffi@haskell.org mailing list.  (please add or remove names as
-appropriate).
diff --git a/ffi/threads.tex b/ffi/threads.tex
deleted file mode 100644 (file)
index e0673a8..0000000
+++ /dev/null
@@ -1,496 +0,0 @@
-\documentclass[a4paper,twoside]{article}
-
-\usepackage{a4wide}
-
-\usepackage{proof}
-\usepackage{code}
-\usepackage{url}
-\usepackage{version}
-
-%\sloppy
-%\setlength{\parskip}{0.5\baselineskip plus 0.2\baselineskip minus 0.1\baselineskip}
-%\setlength{\parsep}{\parskip}
-%\setlength{\topsep}{0cm}
-%\setlength{\parindent}{0cm}
-%\renewcommand{\textfraction}{0}
-%\renewcommand{\topfraction}{1}
-%\renewcommand{\floatpagefraction}{0.8}
-%\renewcommand{\dblfloatpagefraction}{0.8}
-
-\excludeversion{DRAFT}
-
-\newcommand{\clearemptydoublepage}{%
-  \newpage{\pagestyle{empty}\cleardoublepage}}
-
-
-\newcommand{\NS}{{\cal N}}
-%       NS: set of native threads
-\newcommand{\HS}{{\cal H}}
-%       HS: set of Haskell threads
-\newcommand{\hcall}{H}
-\newcommand{\fcall}[2]{F^{#1}~#2}
-\newcommand{\ret}[1]{RET~#1}
-
-\newcommand{\bound}[1]{B(#1)}
-\newcommand{\forkio}[1]{ForkIO(#1)}
-\begin{document}
-\pagestyle{headings}
-
-\title{%
-  The Concurrent Haskell Foreign Function Interface 1.0\\
-  An Addendum to the Haskell 98 FFI Report%
-}
-
-\author{Wolfgang Thaller}
-\date{}
-\maketitle
-\par\vfill
-\noindent
-Copyright (c) 2003 Wolfgang Thaller
-\par\noindent
-\emph{The authors intend this Report to belong to the entire Haskell
-  community, and so we grant permission to copy and distribute it for any
-  purpose, provided that it is reproduced in its entirety, including this
-  Notice.  Modified versions of this Report may also be copied and distributed
-  for any purpose, provided that the modified version is clearly presented as
-  such, and that it does not claim to be a definition of the Concurrent Haskell
-  Foreign Function Interface.}
-\par\bigskip\noindent
-The master version of the Concurrent Haskell FFI Report is at \url{haskell.org}. Any
-corrections or changes in the report are found there.
-\thispagestyle{empty}
-
-
-\clearemptydoublepage
-\pagenumbering{roman}
-\tableofcontents
-
-\clearemptydoublepage
-
-\makeatactive
-
-%\section*{Preface}
-%
-
-\pagenumbering{arabic}
-
-\section{Introduction}
-
-This report intends to define the interaction of two extensions to Haskell 98, namely
-the Foreign Function Interface and Concurrent Haskell. It is therefore an addendum
-to both the Haskell 98 FFI report and the (yet unwritten) Concurrent Haskell report.
-Familiarity with Haskell 98 and both extensions is assumed.
-
-Concurrent Haskell itself does not require operating system thread primitives\footnote{for
-example @pthread\_create@ on POSIX systems or @CreateThread@ on Win32}
-to be used. Today's Concurrent Haskell implementations do in fact use their own
-scheduler loop and run all Concurrent Haskell threads in just one OS thread.
-
-This is significantly more efficient and sometimes also easier to implement than solutions
-based on the OS primitives. However, there are problems with interfacing such an
-implementation with libraries written in other languages.
-
-The functionality described in this addendum facilitates interoperation with foreign
-languages without sacrificing performance.
-
-\subsection{Definitions}
-
-Throughout this document, the term \emph{Haskell thread} will be used to refer to the
-entity that is visible to Haskell programs. Every Haskell IO action runs in a Haskell thread,
-and you can create new Haskell threads using @forkIO@.
-
-The term \emph{OS thread} will be used to refer to threads managed by the operating
-system. All code that is run (both Haskell and foreign code) runs in an OS thread. New
-OS threads are created using OS-specific primitives, like @pthread\_create@ on POSIX
-systems and @CreateThread@ on Win32.
-
-A Haskell run-time system is responsible for managing the relationship between OS threads
-and Haskell thread. Every Haskell thread has to be run by an OS thread to do anything at all.
-
-\section{Problems}
-This section outlines the problems with Haskell implementations that use a single OS thread
-for executing all Haskell threads.
-
-\subsection{Blocking foreign calls}
-If all Haskell scheduling is done in one OS thread, then there can be only one call to a
-foreign imported function in progress at any one time. While a foreign call is in progress,
-the Haskell run-time system is not in control, and therefore all other Haskell threads are
-blocked.
-This severely limits the usefulness of Concurrent Haskell when used together with the FFI.
-
-For some time now, there has been an optional extension to the Glasgow Haskell Compiler,
-the so-called ``Threaded RTS'', that allows non-blocking foreign calls to be made. However,
-this solution makes the problem described in the next section even worse.
-\subsection{Thread-local state}
-OS threads can be uniquely identified by their thread id and by their thread-local state.
-To libraries that make use of this, it does matter from which OS thread they are called from.
-
-Thread-local state is used mostly to allow libraries that use global state variables as part of
-their interface to be used from multiple (OS) threads concurrently. One important example of
-this is OpenGL. OpenGL manages a lot of state variables for each ``rendering context''.
-The ``current rendering context'' is not passed as a parameter to OpenGL functions; rather,
-it is stored in a thread-local state variable. It is therefore possible to use OpenGL from two
-separate OS threads to render into two separate contexts (two separate windows).
-
-When a Haskell implementation uses only one OS thread to schedule several Haskell
-threads, only one of these may access a library that uses thread-local state at any given
-time, as all Haskell threads will share the same OS-thread-local state.
-
-GHC's threaded RTS made the problem worse: it doesn't execute a (foreign exported)
-callback in the same OS thread as the (foreign) function that calls it, and it may move
-all Haskell threads to a different OS thread at any time. While this behaviour sounds
-far-fetched, it is a good way to preserve GHC's good multithreading performance.
-
-Foreign libraries that set a thread-local state variable to a particular value will not find
-the same value there when they are called from a different OS thread. For example,
-programs that use OpenGL segfault because OpenGL functions are called from an OS
-thread that does not have a current OpenGL context set. Similar problems arise with
-Microsoft's Win32, and Apple's Carbon and Cocoa libraries.
-
-\section{Requirements}
-
-The following requirements were used as guidelines for developing the solution to the
-above problems:
-
-\begin{itemize}
-\item Safe Foreign calls (i.e. calls not marked as unsafe) should not cause
-other threads to block.
-
-\item Libraries that rely on thread-local state should be usable from Haskell.
-
-\item The specification should be implementable in a way that allows a lot
-of ``unsafe'' foreign calls to be made with no additional overhead. Unsafe calls to
-libraries that rely on thread-local state must be possible.
-
-Using a library like OpenGL from Haskell would not be practical otherwise.
-
-\item The excellent performance of ``lightweight'' threads, that is, of using one OS thread
-to execute all Haskell threads, should not be sacrificed. Performance should still
-OK when using the new features with only a few threads (i.e. not more than commonly
-used from multithreaded C programs).
-
-This requirement is what makes this whole document necessary in the first place.
-Using exactly one OS thread for every Haskell thread solves the problems by sacrificing
-some performance.
-
-\item The specification shouldn't explicitly require lightweight threads to exist.
-The specification should be implementable in a simple
-and obvious way in Haskell systems that always use a 1:1 correspondence
-between Haskell threads and OS threads.
-
-\item The specification shouldn't specify which particular OS thread
-should be used to execute Haskell code. It should be possible to
-implement it with e.g. a Haskell interpreter running in one OS thread
-that just uses other OS threads for foreign calls.
-
-\end{itemize}
-
-\newpage
-\section{Informal semantics}
-
-Here's the basic idea:
-\begin{description}
-\item[Haskell threads and OS threads.] \mbox{}\\
-\begin{itemize}
-\item Every Haskell thread is \emph{either} unbound, \emph{or} bound to a exactly one OS thread.  
-
-\item At most one Haskell thread may be bound to one OS thread.
-In particular, @forkIO@ forks a new unbound Haskell thread.
-
-\item A Haskell thread, bound to a new OS thread, can be created with @forkOS@.
-
-\end{itemize}
-
-\item[Foreign interface.] \mbox{}\\
-\begin{itemize}
-\item No @safe@ vs @threadsafe@ distinction\footnote{``@threadsafe@'' has already
-been removed from the current Release Candidate of the FFI addendum}. But we retain
-the @safe@/@unsafe@ distinction.
-\item A foreign call made by a Haskell thread is (guaranteed to be) made by its bound OS thread, if
-any.
-
-\item If a @safe@ foreign call blocks, then no Haskell threads block.  (Remember, every OS thread
-has at most one Haskell thread bound to it.)
-
-\item A foreign call \emph{into Haskell} (via @foreign export@ or @foreign import wrapper@) is 
-run by a Haskell thread bound to the OS thread that made the call.
-\end{itemize}
-
-
-\item[Open questions and notes.] \mbox{}\\
-\begin{itemize}
-\item Notice that, there \emph{can} be a 1-1 mapping between Haskell threads
-and OS threads.  Furthermore, we can run efficiently on an SMP.
-\end{itemize}
-\end{description}
-
-
-\section{Formal semantics}
-
-The syntax of a native thread is this:
-$$
-\begin{array}{lrcll}
-\mbox{Native thread} &  t & ::= & N[S] \\
-\\
-\mbox{Native thread stack} &  S & ::= & \epsilon & \mbox{Empty}\\
-        & & | & \hcall : S  & \mbox{Executing Haskell} \\
-        & & | & \fcall{si}{a_{bt}} : S & \mbox{Executing foreign code} \\
-        & & | & \bullet & \mbox{Unknown}\\
-\\
-\mbox{Safety indicator} &  si & ::= & u & \mbox{Unsafe} \\
-        & & | & s & \mbox{Safe}
-\end{array}
-$$
-A native thread of form $N[S]$ has thread-id $N$, while $S$ is
-an abstraction of its call stack.  If $\hcall$ is on top of the stack,
-the thread is willing to execute a Haskell thread. 
-If $\fcall{si}{h}$ is
-on top of the stack, the thread is in the process of dealing with a call
-to a foreign function, which will return its result to the Haskell thread
-$h$.  The safety-indicator $si$ is from the FFI spec.
-
-A native thread of form $N[H]$ has a stack that exists only to serve Haskell 
-threads, and so can safely block inside a foreign call without mucking anything
-else up.  We might call them ``worker threads''.
-
-The syntax of a Haskell thread is this:
-$$
-\begin{array}{lrcll}
-\mbox{Haskell thread} &  h & ::= & (a)_{bt} \\
-\\
-\mbox{Bound thread id} & bt & ::= & \epsilon & \mbox{Not bound} \\
-        & & | & N & \mbox{Bound to native thread N} \\
-\\
-\mbox{Haskell action} &  a & ::= & p ~@>>@~ a  & \mbox{Sequence} \\
-        & & | & \ret  & \mbox{Return from a call into Haskell} \\
-\\
-\mbox{Primitive action} &  p & ::= & \tau & \mbox{Internal action} \\
-        & & | & @forkIO@~a & \mbox{Fork a thread} \\
-        & & | & @forkOS@~a & \mbox{Fork a native thread} \\
-        & & | & \fcall{si}{f} & \mbox{Foreign call} 
-\end{array}
-$$
-A Haskell thread $h$ of form $(a)_{N}$ has action $a$.  The indicator
-$N$ identifies the native thread $N$ to which the Haskell thread is \emph{bound}.
-
-An action $a$ is a sequence of primitive actions, finishing with a 
-return of some kind.  A primitive action is either some internal Haskell
-thing (such as performing a bit of evaluation, or operating on an @MVar@),
-or else it is a call to a foreign function $f$.
-
-We do not model the data passed to, or returned from, a foreign call, nor
-any details of what ``internal Haskell'' operations are.  
-
-\subsection{Evolution}
-
-We describe how the system evolves in a very standard way, using 
-transition rules, of form
-$$
-\NS ; \HS ~\Rightarrow~ \NS' ; \HS'
-$$
-The structural rules are these:
-$$
-\begin{array}{c}
-\infer{\NS \cup \{t\} ; \HS ~\Rightarrow~ \NS'  \cup \{t\}; \HS'}
-        {\NS ; \HS ~\Rightarrow~ \NS' ; \HS'}
-\qquad
-\infer{\NS ; \HS  \cup \{h\} ~\Rightarrow~ \NS'; \HS'   \cup \{h\}}
-        {\NS ; \HS ~\Rightarrow~ \NS' ; \HS'}
-\end{array}
-$$
-These standard rules allow us to write the interesting transitions with less clutter.
-$$
-\begin{array}{rcll}
-N[\hcall:S]; (\tau~@>>@~a)_{bt} 
-        & \Rightarrow 
-        & N[\hcall:S]; (a)_{bt} & (INT) \\
-\\
-N[\hcall:S]; (@forkIO@~b~@>>@~a)_{bt} 
-        & \Rightarrow 
-        & N[\hcall:S]; (a)_{bt}, (b)_\epsilon & (FORKIO) \\
-\\
-N[\hcall:S]; (\fcall{si}{f}~@>>@~a)_N 
-        & \Rightarrow 
-        & N[\fcall{si}{a_N}:\hcall:S];  & (FCALL1) \\
-N[\hcall]; (\fcall{si}{f}~@>>@~a)_\epsilon 
-        & \Rightarrow 
-        & N[\fcall{si}{a_\epsilon}:\hcall:S];  & (FCALL2) \\
-\\
-N[\fcall{si}{a_{bt}}:S];  
-        & \Rightarrow 
-        & N[S]; a_{bt} & (FRET) \\
-\\
-N[\bullet];
-        & \Rightarrow 
-        & N[\hcall:\bullet];  (f ~@>>@~ \ret{})_{N} & (HCALL1) \\
-\\
-N[\fcall{s}{a} : S]; 
-        & \Rightarrow 
-        & N[\hcall : \fcall{s}{a} : S]; ~ (f ~@>>@~ \ret{})_{N} & (HCALL2) \\
- \\
-N[\hcall : S]; (\ret{})_N
-        & \Rightarrow 
-        & N[S]; & (HRET) \\
-\\
-; (\ret{})_\epsilon
-        & \Rightarrow 
-        & ; & (HEND) \\
-\\
-(nothing)
-        & \Rightarrow 
-        & N[\hcall]; & (WKR) \\
-        & \multicolumn{2}{l}{\mbox{where $N$ is fresh}} \\
-\\
-(nothing)
-        & \Rightarrow 
-        & N[\bullet]; & (EXT) \\
-        & \multicolumn{2}{l}{\mbox{where $N$ is fresh}} \\
- \\
-N[S];
-        & \Rightarrow 
-        & (nothing) & (NEND) \\
-\end{array}
-$$
-
-\begin{description}
-%\item[FORKOS.]  Note that we spawn a new OS thread $M[H,\bullet]$.  The $\bullet$ prevents it
-%participating in (FCALL2), which might block $M$ inside a foreign call; instead, $M$ must
-%remain available to participate in (FCALL1), since no other OS thread can do so.
-
-\item[WKR.] This rule models the birth of new worker OS threads, in case they should
-all be blocked in a foreign call.
-\end{description}
-
-\section{Primitives}
-
-The following primitives are exported from the module @Control.Concurrent@,
-except for the @forkProcess@ function, which is only available on POSIX systems
-and exported from @System.Posix.Process@.
-
-\subsection{rtsSupportsBoundThreads}
-
-\begin{quote}
-\begin{verbatim}
-rtsSupportsBoundThreads :: Bool
-\end{verbatim}
-\end{quote}
-
-Defined to be @True@ if multiple OS threads are supported as described in this
-document. When @rtsSupportsBoundThreads@ is @False@, the function
-@isCurrentThreadBound@ below will always return @False@, and @forkOS@ will fail.
-
-Note that an implementation which uses a simple 1:1 correspondence between
-Haskell threads and OS threads will define @rtsSupportsBoundThreads@ to be
-@True@.
-
-\subsection{forkIO and forkOS}
-
-\begin{quote}
-\begin{verbatim}
-forkIO :: IO () -> IO ThreadId
-forkOS :: IO () -> IO ThreadId
-\end{verbatim}
-\end{quote}
-
-As described in the formal semantics above.
-
-This document does not specify the meaning of the @ThreadId@ return value. The
-definition of what constitutes one Haskell thread used for the return value
-need not agree with the definition used for describing the formal semantics.
-Questions like ``are thread ids preserved across foreign calls and call-backs''
-are outside the scope of this document.
-
-\subsection{isCurrentThreadBound}
-
-\begin{quote}
-\begin{verbatim}
-isCurrentThreadBound :: IO Bool
-\end{verbatim}
-\end{quote}
-
-... should return @True@ if and only if it is safe to use foreign calls that
-rely on thread-local state. That means it will return True when executed from a
-bound Haskell thread. It may also return @True@ for threads that are not bound
-according to the above semantics if the run time system is implemented in such
-a way that thread-local-state can be used from all threads, e.g. using a 1-1
-relationship between Haskell threads and OS threads.
-
-This primitive is intended to make use of forkOS unnecessary when a bound
-thread is already available; take a look at @runInBoundThread@ below.
-
-\subsection{forkProcess}
-
-\begin{quote}
-\begin{verbatim}
-forkProcess :: IO () -> IO ProcessID
-\end{verbatim}
-\end{quote}
-
-The primitive @forkProcess@ is available in the module @System.Posix.Process@
-on Posix platforms only.
-While it is based on the POSIX fork system call, it's semantics are slightly
-different: It only returns to the parent; it doesn't return to the child process,
-rather, the IO action passed as a parameter will be run as a bound thread in the
-child process. No other threads will be copied to the child process. When the IO
-action finishes, the child process will terminate.
-
-\section{Utility Functions}
-
-The following utility functions are exported from @Control.Concurrent@. They can
-be implemented in terms of the primitives above; simple reference
-implementations that ignore exception handling issues are provided below.
-
-\subsection{runInBoundThread}
-\begin{quote}
-\begin{verbatim}
-runInBoundThread :: IO a -> IO a
-\end{verbatim}
-\end{quote}
-
-Run the IO computation passed as the first argument. If the calling thread
-is not bound, a bound thread is created temporarily. @runInBoundThread@
-doesn't finish until the IO computation finishes.
-
-\begin{quote}
-\begin{verbatim}
-runInBoundThread action = do
-    bound <- isCurrentThreadBound
-    if bound
-        then action
-        else do
-            mv <- newEmptyMVar
-            forkOS (action >>= putMVar mv)
-            takeMVar mv
-\end{verbatim}
-\end{quote}
-
-
-\subsection{runInUnboundThread}
-
-\begin{quote}
-\begin{verbatim}
-runInUnboundThread :: IO a -> IO a
-\end{verbatim}
-\end{quote}
-
-Run the IO computation passed as the first argument. If the calling thread
-is bound, an unbound thread is created temporarily using @forkIO@.
-@runInBoundThread@ doesn't finish until the IO computation finishes.
-
-\begin{quote}
-\begin{verbatim}
-runInUnboundThread action = do
-    bound <- isCurrentThreadBound
-    if bound
-        then do
-            mv <- newEmptyMVar
-            forkIO (action >>= putMVar mv)
-            takeMVar mv
-        else action
-\end{verbatim}
-\end{quote}        
-        
-\end{document}
diff --git a/hierarchical-modules/Makefile b/hierarchical-modules/Makefile
deleted file mode 100644 (file)
index a9535ea..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-all : hier.ps hier.pdf
-
-hier.ps: hier.tex
-       TEXINPUTS=../styles: latex $<
-       dvips -f < hier.dvi > $@
-
-hier.pdf: hier.tex
-       TEXINPUTS=../styles: pdflatex $<
-
-clean :
-       rm hier.ps hier.pdf
diff --git a/hierarchical-modules/hier.tex b/hierarchical-modules/hier.tex
deleted file mode 100644 (file)
index 40e1687..0000000
+++ /dev/null
@@ -1,187 +0,0 @@
-% Haskell 98 Addendum: Hierarchical Module Namespace Extension
-% [ Addendum to the Definition of Haskell 98 ]
-%
-% Editor: Simon Marlow <simonmar@microsoft.com>
-%
-% Copyright 2003 Simon Marlow
-%
-% The authors intend this Report to belong to the entire Haskell community, and
-% so we grant permission to copy and distribute it for any purpose, provided
-% that it is reproduced in its entirety, including this Notice.  Modified
-% versions of this Addendum may also be copied and distributed for any purpose,
-% provided that the modified version is clearly presented as such, and that it
-% does not claim to be a definition of The Haskell~98 Hierarchical
-% Module Namespace Extension.
-%
-
-\documentclass[a4paper,twoside]{article}
-
-\usepackage{a4wide}
-\usepackage{url}
-\usepackage{code}
-
-\newcommand{\clearemptydoublepage}{%
-  \newpage{\pagestyle{empty}\cleardoublepage}}
-
-\begin{document}
-
-\makeatactive
-
-\title{%
-  DRAFT: The Hierarchical Module Namespace Extension, version 0.0\\
-  An Addendum to the Haskell~98 Report%
-}
-\author{
-  Simon Marlow, Microsoft Research, Cambridge\\
-  Malcolm Wallace, University of York
-}
-
-\date{}
-\maketitle
-\par\vfill
-\noindent
-Copyright (c) 2003 Simon Marlow
-\par\noindent
-\emph{The authors intend this Report to belong to the entire Haskell
-community, and so we grant permission to copy and distribute it for
-any purpose, provided that it is reproduced in its entirety, including
-this Notice.  Modified versions of this Addendum may also be copied
-and distributed for any purpose, provided that the modified version is
-clearly presented as such, and that it does not claim to be a
-definition of The Haskell~98 Hierarchical
-Module Namespace Extension.}
-
-\par\bigskip\noindent The master version of Hierarchical Module
-Namespace Extension is at \url{haskell.org}. Any corrections or
-changes in the report are found there.
-\thispagestyle{empty}
-
-\clearemptydoublepage
-\pagenumbering{roman}
-%\tableofcontents
-
-\clearemptydoublepage
-\section*{Preface}
-
-Haskell~98 defines a module system with a \emph{flat} module
-namespace.  That is, module names are just identifiers, and all module
-names occupy the same namespace.  This creates two problems for the
-Haskell programmer: 
-
-\begin{itemize}
-\item
-  There is no consistent naming scheme for modules, so it is hard to
-  locate functionality within a library.
-
-\item
-  Module names are likely to clash with each other.  It is not
-  possible to choose a module name for a library that is guaranteed
-  not to clash with other library modules.
-\end{itemize}
-
-The purpose of this document is to define a modest extension to
-Haskell~98 that extends the module namespace and gives it a
-hierarchical structure.  
-
-On the face of it, this extension solves neither of the above two
-problems!  However, it is an important first step: in having a way to
-arrange modules into a hierarchy, we have a \emph{mechanism} to avoid
-name clashes, and a way to organise libraries into a tree by
-functionality.  The policy by which the hierarchy itself is organised
-is not in the scope of this specification, but we expect it to be the
-subject of future specification(s).
-
-This document is an \emph{addendum} to the Haskell~98 definition,
-which means that it has undergone extensive peer-review by the Haskell
-community prior to publication\footnote{or at least it will have done,
-by the time version 1.0 is published}.
-
-The hierarchical module namespace extension depends on no other
-Haskell~98 extensions.
-
-\subsection*{Acknowledgements}
-
-We would like to thank everyone on the mailing list
-@libraries@\verb+@+@haskell.org@ who has contributed in some way to this
-proposal, and also those Haskell system implementors who have added
-this extension to their compilers and interpreters.
-
-\clearemptydoublepage
-\pagenumbering{arabic}
-\section{The Language Extension}
-
-The key concept is to map the module namespace into a hierarchical
-directory-like structure. We propose using the dot as a separator,
-analogous to Java's usage for namespaces.
-
-This is a surface change to the module naming convention. It does not
-introduce nested definition of modules.  One change is required to the
-lexical syntax of Haskell, namely that \textit{modid} is redefined
-from:
-
-\[
-  \textit{modid} \rightarrow \textit{conid}
-\]
-
-\noindent to:
-
-\[
-  \textit{modid} \rightarrow \textit{qconid}
-\]
-
-\noindent for reference, the definition of \textit{qconid} is:
-
-\[
-   \textit{qconid} \rightarrow [ \textit{modid} @.@ ] \textit{conid}
-\]
-
-\noindent Note that the new syntax is recursive, a \textit{modid} may contain
-multiple components separated by dots, where the final component is a
-\textit{conid}.
-
-A consequence of using the dot as the module namespace separator is
-that it steals one extremely rare construction from Haskell~98:
-
-\begin{code}
-   A.B.C.D 
-\end{code}
-
-\noindent in Haskell'98 means the composition of constructor D from
-module C, with constructor B from module A:
-
-\begin{code}
-   (.)  A.B  C.D 
-\end{code}
-
-\noindent With the hierarchical module namespace extension, @A.B.C.D@
-would instead be interpreted as the identifier @D@ from module
-@A.B.C@.  If the original Haskell~98 interpretation is intended, then
-it must be written with extra spaces, as @A.B . C.D@.
-
-\section{Modules and the filesystem}
-      
-This section describes possible implementation techniques, and how we
-expect the hierarchical namespace to be exposed to the programmer by
-Haskell implementations.  What follows is \emph{not} part of the
-specification of the hierarchical module namespace extension; Haskell
-implementations are still free to implement any mapping between
-modules and filenames they choose (as in plain Haskell~98).
-
-For most compilers and interpreters, we expect that the hierarchical
-module namespace will map directly to a directory/file structure in
-which the modules are stored.  For example, a module @Foo.Bar.Baz@
-might be stored in the file @Foo/Bar/Baz.hs@ if @/@ is the directory
-separator.
-
-Note that the hierarchical module namespace is far simpler than a file
-directory structure, in that hierarchical module names do not provide
-any operations such as relative paths or parent directory.
-
-In the hierarchical module namespace, a particular module name may
-also be a node in the hierarchy.  For example, we might have modules
-names both @Data.Array@ and @Data.Array.IO@.  It is therefore
-important that directories are distinguished form Haskell source
-modules, for example by using the @.hs@ suffix: @Data.Array@ would be
-stored in @Data/Array.hs@ and @Data.Array.IO@ in @Data/Array/IO.hs@.
-
-\end{document}
diff --git a/hierarchical-modules/index.html b/hierarchical-modules/index.html
deleted file mode 100644 (file)
index 871f391..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-  <head>
-    <title>Haskell 98 Hierarchical Module Namespace Extension</title>
-  </head>
-
-  <body>
-    <h1>Haskell 98 Hierarchical Module Namespace Extension</h1>
-
-    <p>This is the home of the Hierarchical Module Namespace
-    Extension, an addendum to the <a
-    href="http://www.haskell.org/definition">Haskell 98 language
-    definition</a>.
-
-    <p>Version 0.0 is currently available in the following formats:
-
-    <ul>
-      <li><a href="hier.ps">Postscript (A4)</a>
-      <li><a href="hier.pdf">PDF</a>
-    </ul>
-
-    <p>System compliance status:
-
-    <ul>
-      <li><a href="http://www.haskell.org/ghc/">GHC</a> (since version 5.04) is fully compliant.
-      <li><a href="http://haskell.org/nhc98/">NHC98</a> (since version
-      1.04) is fully compliant.
-      <li><a href="http://haskell.org/hugs/">Hugs</a> (since December 2001
-      release) is fully compliant.
-    </ul>
-
-    <h2>Hierarchical Libraries</h2>
-
-    <p>The above addendum describes a pure language extension; it
-    makes no attempt to dictate how the namespace should be allocated
-    to libraries, and what module names in the hierarchy are available
-    to programmers.
-
-    <p>The following document describes a proposal for the use of the
-    hierarchical module namespace.  It is <em>not</em> a Haskell 98
-    addendum, since it is more policy-oriented.  Comments on this
-    document are welcome on the <a
-href="http://www.haskell.org/mailman/listinfo/libraries"><tt>libraries@haskell.org</tt></a> mailing list.
-
-   <ul>
-     <li><a href="libraries/libraries.html">Hierarchical Haskell Libraries</a>
-   </ul>
-
-  </body>
-</html>
diff --git a/libraries/Makefile b/libraries/Makefile
deleted file mode 100644 (file)
index 73ac8bc..0000000
+++ /dev/null
@@ -1,169 +0,0 @@
-# Makefile for the Haskell Library Report
-# read the README file before you start!
-#
-
-# Begin by saying
-#      touch library.idx
-
-default: library.ps.gz html
-
-
-#########################################
-#      Tools you need
-#########################################
-
-# Stuf from the tools/directory
-RUN_TEX   = ../tools/run_tex
-RUN_INDEX = ../tools/run_index
-VERBATIM  = ../tools/verbatim
-
-# splitAndIndexPgm won't work unless you have "perl"
-SPLITPGM = perl ../tools/splitAndIndexPgm
-
-CC    = gcc
-RM    = rm -f
-LATEX = latex
-MAKEINDEX = makeindex
-
-# 'expand' expands tabs to spaces
-# On my machine the windows program (which does something
-# quite different) shadows it.  Sigh.
-EXPAND = expand
-# EXPAND = c:/cygwin/bin/expand
-
-
-#########################################
-#      Files
-#########################################
-
-# I've been having problems with that damn NT messing up filenames in the html
-# generator so I'm changing the .verb files to lower case  -- jcp
-
-RELEASE_DIR = ../haskell98-revised
-JFP_DIR = ../jfp-release
-
-PARTS =                library.tex introduction.tex ratio.tex complex.tex ix.tex \
-                numeric.tex \
-                array.tex io.tex char.tex monad.tex list.tex \
-                system.tex directory.tex \
-                maybe.tex time.tex cputime.tex random.tex \
-               locale.tex 
-
-CODE =         code/Ratio.tex code/Complex.tex code/Ix.tex \
-                code/Numeric.tex \
-                code/Array.tex code/Char.tex code/List.tex \
-                code/Monad.tex code/Maybe.tex code/IO.tex \
-               code/Time.tex code/Locale.tex
-
-CODEV =                code/Ratio.verb code/Complex.verb code/Ix.verb \
-                code/Numeric.verb \
-                code/Array.verb code/Char.verb code/List.verb \
-                code/Monad.verb code/Maybe.verb code/IO.verb code/Bit.verb \
-               code/Time.verb code/Locale.verb
-
-HEADERS =      headers/Ratio.tex headers/Complex.tex headers/Ix.tex \
-                headers/Numeric.tex \
-                headers/Array.tex headers/IO.tex headers/Char.tex \
-               headers/List.tex headers/List1.tex \
-                headers/Monad.tex headers/System.tex headers/Directory.tex \
-                headers/Maybe.tex headers/IO1.tex headers/Random.tex \
-               headers/Time.tex headers/Time1.tex headers/CPUTime.tex \
-               headers/Locale.tex 
-HEADERSV =     headers/Ratio.verb headers/Complex.verb headers/Ix.verb \
-                headers/Numeric.verb \
-                headers/Array.verb headers/IO.verb headers/Char.verb \
-               headers/List.verb headers/List1.verb \
-                headers/Monad.verb headers/System.verb headers/Directory.verb \
-                headers/Maybe.verb headers/IO1.verb headers/Random.verb \
-               headers/Time.verb headers/CPUTime.verb \
-               headers/Locale.verb 
-
-# The normally formatted report -- 2 sided, one-up
-library.dvi: library.ind ${PARTS} ${CODE} ${HEADERS} index-intro.tex
-
-html: index.html ${PARTS} ${SYNTAX} ${PRELUDE}
-       -mkdir haskell98-library-html
-       $(RUN_TEX)
-       $(RUN_TEX)
-       cp *.gif index.html haskell98-library-html
-
-# remove this rule if you don't have "makeindex"
-library.ind: library.idx
-       makeindex -i -t library.ilg < library.idx > library.ind
-
-veryclean: clean
-       $(RM) *~ code/*~ headers/*~
-
-clean:
-       $(RM) *.dvi *.log *.aux *.ilg *.blg *.toc haskell.tex \
-               $(PARTS) $(CODE) $(HEADERS) \
-               library.ps library.pdf haskell98-library-html/*
-       cp library.ind library.ind.two-sided 
-       echo "Don't delete the Prelude*.tex files"
-       echo "Not everyone has \"perl\" to re-make them"
-
-
-# Stuff to make the "two-up" version for SIGPLAN Notices:
-# We take the A4 pages and double them up onto (virtual) A3 pages:
-# (two A5 pages make one A4 page; two A4 pages make one A3 page; ...)
-#
-#      % dvidvi '2:0,1(210mm,0)' haskell.dvi > haskell-2up.dvi
-#
-# We now print the "A3" pages in landscape, but "magnify" them by
-# 1 / sqrt(2) ~ 0.7071; this should make our "A4" pages print in an
-# A4 space: presto! 2up printing!
-# (except that I've tried to make it give us 1" margins all round
-#  when we print on US 8.5"x11" paper)
-#
-#      % dvips -t landscape -x 707 haskell-2up.dvi > haskell-2up.ps
-#
-# if your "dvips" is set up properly, it will run Metafont for you,
-# creating just-right magnifications for all the fonts.
-#
-# print with: lpr -Pmy-laserwriter haskell-2up.ps
-
-# These rules keep failing for me (segmentation fault on haskell-2up.dvi)
-# The output seems fine, though, and the individual commands work
-# perfectly(!).  More network wierdness?  KH
-
-
-verbs:  $(CODEV) $(HEADERSV)
-
-library.ps : library.dvi
-       dvips library.dvi -o library.ps
-
-release: library.ps html
-       gzip < library.ps > $(RELEASE_DIR)/library.ps.gz
-       cp -r haskell98-library-html $(RELEASE_DIR)
-       tar cvf - haskell98-library-html | gzip > $(RELEASE_DIR)/haskell98-library-html.tar.gz
-
-publish-pdf: library.pdf
-       gzip < library.pdf > y:Haskell/haskell98-library/library.pdf.gz
-
-jfp: ${PARTS} ${CODE} ${HEADERS} index-intro.tex
-       -mkdir $(JFP_DIR)
-       -mkdir $(JFP_DIR)/code
-       -mkdir $(JFP_DIR)/headers
-       for n in ${PARTS}  ${CODE}  ${HEADERS}; do  \
-               ../tools/subsection < $$n >  $(JFP_DIR)/$$n ; done 
-
-#########################################
-#      Suffix rules
-#########################################
-
-.SUFFIXES:     .hs .verb .tex .dvi .gz .ps
-
-.verb.tex:
-       $(EXPAND) < $< | $(VERBATIM) >$@
-
-.hs.verb:
-       $(EXPAND) < $< | $(SPLITPGM) >$@
-
-.hs.tex:
-       $(EXPAND) < $< | $(SPLITPGM) | $(VERBATIM) >$@
-
-.tex.dvi:
-       $(LATEX) $<
-
-
diff --git a/libraries/README b/libraries/README
deleted file mode 100644 (file)
index c1fbc7a..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-
-This is the Haskell 98 library report, source distribution.  
-
-This has all files needed to generate either the postscript or the
-html version of the Haskell library report.  Some of these files are
-generated from others - these are marked with a (*) and are included in
-case the tool used to generate the file is unavailable.
-
-To generate the postscript library report you need lex, perl, latex,
-makeindex, and dvips.
-
-To generate the html library report you need Hugs 1.4 (probably any Haskell
-1.4 compiler will do).
-
-To chage the date on the report, you must change:
-       * library.verb (line 415-ish)
-       * index.html (line 8-ish)
-       * html.config (~foot item)
-       
-
-Source files: 
-  library.verb  -- Top level of the library report
-  introduction.verb
-  ratio.verb
-  complex.verb
-  numeric.verb
-  ix.verb
-  array.verb
-  list.verb
-  maybe.verb
-  char.verb
-  monad.verb
-  io.verb
-  directory.verb
-  system.verb
-  time.verb
-  locale.verb
-  cputime.verb
-  random.verb
-  index-intro.verb
-
-Haskell files:
-code/*.hs         -- executable versions of most libraries (IO incomplete),
-                  -- CPUTime, Random, Directory not included
-headers/*.hs      -- Lists all exported names from each library
-
-Tex generated files:
-  library.dvi (*) -- to make a .ps from
-  library.idx (*)
-  library.ind (*
-  library.aux (*) -- The aux file generated by latex; used by html translator
-
-Html support:
-
-tex.hs             -- Program to generate html from verb / hs
-html.config        -- configuration file for tex.hs.
-index.html         -- Html top level
-title.gif          -- title graphic 
-
-Other files:
-
-Makefile         -- Lots of extra cruft no longer used. 
-verbatim.lex     -- lex program to expand .verb into .tex
-splitAndIndexPgm -- perl script to convert .hs to .verb
-splitAndIndexPgm.kh -- an old perl script to convert .hs to .verb
-library.dvi (*)  -- in case you just want to run dvips
-library.ind (*)  -- is case you don't have makeindex 
-library.idx (*)  -- makes building easier
-
-
-To build the .dvi you need to patch the makefile to call the proper
-version of perl.  You will have some `non-grokked' instances in the
-perl.  Remember that you have to run latex twice.  If anyone converts
-the perl program to perl5 please send it to us!  Also, the indexing misses
-a few definitions.
-
-Report any problems to peterson-john@cs.yale.edu
-
-Building the HTML files
-~~~~~~~~~~~~~~~~~~~~~~~
-Build the html by creating a `html' subdirectory, copy the .html and
-.gif files to it, and run tex.hs twice (like tex - to get forward refs
-right).  
-
-Build the html by creating a `html' subdirectory, copy the .html and
-.gif files to it, and run tex.hs twice (like tex - to get forward refs
-right).  Run index.hs to generate the function index.  You're done.
-The 'make html' does most of this.
-
-There is one file you need to work on:
-
-       report/html.config
-
-Edit the title in the headers and footers. 
-You can hack in whatever html you want for page headers and
-footers .  You can also hack on the output directory setting (htmldir)
-to direct the output wherever you want.  You'll have to fiddle
-"index.hs" if you do this, though.  You can also add the line
-
-       style = microsoftsymbols,article
-
-This exploits the symbol font that microsoft uses in its browser.
-Much nicer for some of the equations.  Probably a good idea since most
-browsers handle the symbol font OK nowadays.
-
-As to the building process:
-
-To build the html library report: (using the .aux file and all the .verb files) 
-
-cd <library directory>
-runhugs tex.hs
-runhugs tex.hs
-
-Like latex, you have to run tex.hs twice.  Unless you make massive
-changes, though, you can probably just do it once.  I'm sure ghc will
-compile tex.hs if you want to speed things up. 
-
-Note there is no index.hs here.
-
-
-
diff --git a/libraries/array.verb b/libraries/array.verb
deleted file mode 100644 (file)
index ead6e91..0000000
+++ /dev/null
@@ -1,183 +0,0 @@
-%**<title>The Haskell 98 Library Report: Arrays</title>
-%**~header
-\section{Arrays}
-\label{arrays}
-\index{array}
-
-\outline{
-\inputHS{headers/Array}
-}
-
-\Haskell{} provides indexable {\em arrays}, which may be thought of as
-functions whose domains are isomorphic to contiguous subsets of the
-integers.
-Functions restricted in this way can be
-implemented efficiently; in particular, a programmer may
-reasonably expect rapid access to the components.  To ensure
-the possibility of such an implementation, arrays are treated as data, not as
-general functions.
-
-Since most array functions involve the class @Ix@, this module is
-exported from @Array@ so that modules need not import both @Array@ and
-@Ix@. 
-
-\subsection{Array Construction}
-If @a@ is an index type and @b@ is any type, the type of arrays with
-indices in @a@ and elements in @b@ is written @Array a b@.\indextycon{Array}
-An array may be created by the function @array@\indextt{array}.
-The first argument of @array@ is a pair of {\em bounds}, each of the
-index type of the array.  These bounds are the lowest and
-highest indices in the array, in that order.  For example, a
-one-origin vector of length @10@ has bounds @(1,10)@, and a one-origin @10@
-by @10@ matrix has bounds @((1,1),(10,10))@.
-
-The second argument of @array@ is a list of {\em associations}
-of the form ($index$,~$value$).  Typically, this list will
-be expressed as a comprehension.  An association @(i, x)@ defines the
-value of the array at index @i@ to be @x@.  The array is undefined (i.e.~$\bot$) if
-any index in the list is out of bounds.  If any two associations in the
-list have the same index, the value at that index is undefined (i.e.~$\bot$).
-Because the indices must be checked for these errors, @array@ is
-strict in the bounds argument and in the indices of the association list,
-but nonstrict in the values.  Thus, recurrences such as the following are
-possible:
-\bprog
-@
-a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i <- [2..100]])
-@
-\eprog
-Not every index within the bounds of the array need
-appear in the association list, but the values associated with indices
-that do not appear will be undefined (i.e.~$\bot$).
-Figure~\ref{array-examples} shows some examples that use the
-@array@ constructor.
-
-\begin{figure}[tb]
-\outline{
-@
--- Scaling an array of numbers by a given number:
-scale :: (Num a, Ix b) => a -> Array b a -> Array b a
-scale x a = array b [(i, a!i * x) | i <- range b]
-           where b = bounds a
-
--- Inverting an array that holds a permutation of its indices
-invPerm :: (Ix a) => Array a a -> Array a a
-invPerm a = array b [(a!i, i) | i <- range b]
-           where b = bounds a
-
--- The inner product of two vectors
-inner :: (Ix a, Num b) => Array a b -> Array a b -> b
-inner v w = if b == bounds w
-               then sum [v!i * w!i | i <- range b]
-               else error "inconformable arrays for inner product"
-           where b = bounds v
-@
-}
-\ecaption{Array examples}
-\label{array-examples}
-\end{figure}
-
-The @(!)@\index{!@@{\tt {\char'041}}} operator denotes array subscripting.
-% array subscripting -- if the index lies outside the bounds of the
-% array, the result is undefined.  
-The @bounds@\indextt{bounds} function
-applied to an array returns its bounds.
-The functions @indices@\indextt{indices}, @elems@\indextt{elems}, and
-@assocs@,\indextt{assocs} when applied to an array, return lists of
-the indices, elements, or associations, respectively, in index order.
-An array may be constructed from a pair of bounds and a list
-of values in index order using the function @listArray@\indextt{listArray}.
-
-If, in any dimension, the lower bound is greater than the upper bound,
-then the array is legal, but empty.  Indexing an empty array always
-gives an array-bounds error, but @bounds@ still yields the bounds
-with which the array was constructed.
-
-\subsubsection{Accumulated Arrays}
-\index{array!accumulated}
-
-Another array creation function, @accumArray@,\indextt{accumArray}
-relaxes the restriction that a given index may appear at most once in
-the association list, using an {\em accumulating function} which
-combines the values of associations with the same index.
-% \cite{nikhil:id-nouveau,wadler:array-primitive}:
-The first argument of @accumArray@ is the accumulating function; the
-second is an initial value; the remaining two arguments are a bounds
-pair and an association list, as for the @array@ function.
-For example, given a list of values of some index type, @hist@
-produces a histogram of the number of occurrences of each index within
-a specified range:
-\bprog
-@
-hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b
-hist bnds is = accumArray (+) 0 bnds [(i, 1) | i<-is, inRange bnds i]
-@
-\eprog
-If the accumulating function is strict, then @accumArray@ is
-strict in the values, as well as the indices, in the
-association list.  Thus, unlike ordinary arrays,
-accumulated arrays should not in general be recursive.
-
-\subsection{Incremental Array Updates}
-\label{array-update}
-
-The operator @(//)@\indextt{//} takes an array and a list of pairs and returns
-an array identical to the left argument except that it has
-been updated by the associations in the right argument.  (As with
-the @array@ function, the indices in the association list must
-be unique for the updated elements to be defined.)  For example,
-if @m@ is a 1-origin, @n@ by @n@ matrix, then
-@m//[((i,i), 0) | i <- [1..n]]@ is the same matrix, except with
-the diagonal zeroed.
-
-@accum@\indextt{accum} "f" takes an array
-and an association list and accumulates pairs from the list into
-the array with the accumulating function "f".  Thus @accumArray@
-can be defined using @accum@:\nopagebreak[4]
-\bprog
-@
-accumArray f z b = accum f (array b [(i, z) | i <- range b])
-@
-\eprogNoSkip
-
-\subsection{Derived Arrays}
-\index{array!derived}
-
-The two functions @fmap@\indextt{fmap} and @ixmap@\indextt{ixmap}
-derive new arrays from existing ones; they may be
-thought of as providing function composition on the left and right,
-respectively, with the mapping that the original array embodies.
-The @fmap@ function transforms the array values while 
-@ixmap@ allows for transformations on array indices.
-Figure~\ref{derived-array-examples} shows some examples.
-
-\begin{figure}[tb]
-\outline{
-@
--- A rectangular subarray
-subArray :: (Ix a) => (a,a) -> Array a b -> Array a b
-subArray bnds = ixmap bnds (\i->i)
-
--- A row of a matrix
-row :: (Ix a, Ix b) => a -> Array (a,b) c -> Array b c
-row i x = ixmap (l',u') (\j->(i,j)) x where ((_,l'),(_,u')) = bounds x
-
--- Diagonal of a matrix (assumed to be square)
-diag :: (Ix a) => Array (a,a) b -> Array a b
-diag x = ixmap (l,u) (\i->(i,i)) x
-       where 
-         ((l,_),(u,_)) = bounds x
-
--- Projection of first components of an array of pairs
-firstArray :: (Ix a) => Array a (b,c) -> Array a b
-firstArray = fmap (\(x,y)->x)
-@
-}
-\ecaption{Derived array examples}
-\label{derived-array-examples}
-\end{figure}
-
-\subsection{Library {\tt Array}}
-\label {Libarray}
-\inputHS{code/Array}
-%**~footer
diff --git a/libraries/char.verb b/libraries/char.verb
deleted file mode 100644 (file)
index ad3fbe2..0000000
+++ /dev/null
@@ -1,98 +0,0 @@
-%**<title>The Haskell 98 Library Report: Character Utilities</title>
-%**~header
-\section{Character Utilities}
-
-\outline{
-\inputHS{headers/Char}
-}
-\indextt{isAscii}
-\indextt{isLatin1}
-\indextt{isControl}
-\indextt{isPrint}
-\indextt{isSpace}
-\indextt{isUpper}
-\indextt{isLower}
-\indextt{isAlpha}
-\indextt{isDigit}
-\indextt{isOctDigit}
-\indextt{isHexDigit}
-\indextt{isAlphaNum}
-\indextt{toUpper}
-\indextt{toLower}
-
-This library provides a limited set of operations on the Unicode
-character set.  
-The first 128 entries of this character set are identical to the
-ASCII set; with the next 128 entries comes the remainder of the
-Latin-1 character set.
-This module offers only a limited view of the
-full Unicode character set; the full set of Unicode character
-attributes is not accessible in this library.
-
-Unicode characters may be divided into five general categories:
-non-printing, lower case alphabetic, other alphabetic, numeric digits, and
-other printable characters.  For the purposes of Haskell, any
-alphabetic character which is not lower case is treated as upper case
-(Unicode actually has three cases: upper, lower, and title).  Numeric
-digits may be part of identifiers but digits outside the ASCII range are not
-used by the reader to represent numbers.  
-
-For each sort of Unicode character, here are the predicates which
-return @True@:
-\begin{center}
-\begin{tabular}{|l|llll|}
-\hline
-Character Type & Predicates  & & & \\
-\hline
-Lower Case Alphabetic & @isPrint@ & @isAlphaNum@ & @isAlpha@ & @isLower@ \\
-Other Alphabetic & @isPrint@ & @isAlphaNum@ & @isAlpha@ & @isUpper@ \\
-Digits & @isPrint@ & @isAlphaNum@ & & \\
-Other Printable & @isPrint@ & & & \\
-Non-printing & & & &\\
-\hline
-\end{tabular}
-\end{center}
-
-The @isDigit@, @isOctDigit@, and @isHexDigit@ functions select only
-ASCII characters.  @intToDigit@ and @digitToInt@ convert between 
-a single digit @Char@ and the corresponding @Int@.  
-@digitToInt@ operates fails unless its argument satisfies @isHexDigit@,
-but recognises both upper and lower-case hexadecimal digits (i.e. @'0'@..@'9'@,
-@'a'@..@'f'@, @'A'@..@'F'@).  @intToDigit@ fails unless its argument is in the range
-@0@..@15@, and generates lower-case hexadecimal digits.
-
-The @isSpace@ function recognizes only white characters in the Latin-1
-range.
-
-The function @showLitChar@ converts a character to a string using
-only printable characters, using Haskell source-language escape conventions.
-The function @lexLitChar@ does the reverse, returning the sequence of characters 
-that encode the character.
-The function @readLitChar@ does the same, but in addition converts the 
-to the character that it encodes.  For example:
-\bprog
-@
-  showLitChar '\n' s       =  "\\n" ++ s
-  lexLitChar  "\\nHello"   =  [("\\n", "Hello")]
-  readLitChar "\\nHello"   =  [('\n', "Hello")]
-@
-\eprog
-
-Function @toUpper@ converts a letter to the corresponding
-upper-case letter, leaving any other character unchanged.  Any
-Unicode letter which has an upper-case equivalent is transformed.
-Similarly, @toLower@ converts a letter to the
-corresponding lower-case letter, leaving any other character
-unchanged.
-
-The @ord@ and @chr@ functions are @fromEnum@ and @toEnum@
-restricted to the type @Char@.
-
-\clearpage
-\subsection{Library {\tt Char}}
-\label{Char}
-\inputHS{code/Char}
-
-%**~footer
-
-
diff --git a/libraries/code/Array.hs b/libraries/code/Array.hs
deleted file mode 100644 (file)
index ad100bf..0000000
+++ /dev/null
@@ -1,85 +0,0 @@
-module  Array ( 
-    module Ix,  -- export all of Ix 
-    Array, array, listArray, (!), bounds, indices, elems, assocs, 
-    accumArray, (//), accum, ixmap ) where
-
-import Ix
-import List( (\\) )
-
-infixl 9  !, //
-
-data (Ix a) => Array a b = MkArray (a,a) (a -> b) deriving ()
-
-array       :: (Ix a) => (a,a) -> [(a,b)] -> Array a b
-array b ivs =
-    if and [inRange b i | (i,_) <- ivs]
-        then MkArray b
-                     (\j -> case [v | (i,v) <- ivs, i == j] of
-                            [v]   -> v
-                            []    -> error "Array.!: \
-                                           \undefined array element"
-                            _     -> error "Array.!: \
-                                           \multiply defined array element")
-        else error "Array.array: out-of-range array association"
-
-listArray             :: (Ix a) => (a,a) -> [b] -> Array a b
-listArray b vs        =  array b (zipWith (\ a b -> (a,b)) (range b) vs)
-
-(!)                   :: (Ix a) => Array a b -> a -> b
-(!) (MkArray _ f)     =  f
-
-bounds                :: (Ix a) => Array a b -> (a,a)
-bounds (MkArray b _)  =  b
-
-indices               :: (Ix a) => Array a b -> [a]
-indices               =  range . bounds
-
-elems                 :: (Ix a) => Array a b -> [b]
-elems a               =  [a!i | i <- indices a]
-
-assocs                :: (Ix a) => Array a b -> [(a,b)]
-assocs a              =  [(i, a!i) | i <- indices a]
-
-(//)                  :: (Ix a) => Array a b -> [(a,b)] -> Array a b
-a // new_ivs          = array (bounds a) (old_ivs ++ new_ivs)
-                      where
-                       old_ivs = [(i,a!i) | i <- indices a,
-                                             i `notElem` new_is]
-                       new_is  = [i | (i,_) <- new_ivs]
-
-accum                 :: (Ix a) => (b -> c -> b) -> Array a b -> [(a,c)]
-                                   -> Array a b
-accum f               =  foldl (\a (i,v) -> a // [(i,f (a!i) v)])
-
-accumArray            :: (Ix a) => (b -> c -> b) -> b -> (a,a) -> [(a,c)]
-                                   -> Array a b
-accumArray f z b      =  accum f (array b [(i,z) | i <- range b])
-
-ixmap                 :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c
-                                         -> Array a c
-ixmap b f a           = array b [(i, a ! f i) | i <- range b]
-
-instance  (Ix a)          => Functor (Array a) where
-    fmap fn (MkArray b f) =  MkArray b (fn . f) 
-
-instance  (Ix a, Eq b)  => Eq (Array a b)  where
-    a == a' =  assocs a == assocs a'
-
-instance  (Ix a, Ord b) => Ord (Array a b)  where
-    a <= a' =  assocs a <= assocs a'
-
-instance  (Ix a, Show a, Show b) => Show (Array a b)  where
-    showsPrec p a = showParen (p > arrPrec) (
-                    showString "array " .
-                    showsPrec (arrPrec+1) (bounds a) . showChar ' ' .
-                    showsPrec (arrPrec+1) (assocs a)                  )
-
-instance  (Ix a, Read a, Read b) => Read (Array a b)  where
-    readsPrec p = readParen (p > arrPrec)
-           (\r -> [ (array b as, u) 
-                  | ("array",s) <- lex r,
-                    (b,t)       <- readsPrec (arrPrec+1) s,
-                    (as,u)      <- readsPrec (arrPrec+1) t ])
-
--- Precedence of the 'array' function is that of application itself
-arrPrec = 10
diff --git a/libraries/code/Char.hs b/libraries/code/Char.hs
deleted file mode 100644 (file)
index ab08471..0000000
+++ /dev/null
@@ -1,157 +0,0 @@
-module Char ( 
-    isAscii, isLatin1, isControl, isPrint, isSpace, isUpper, isLower,
-    isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum,
-    digitToInt, intToDigit,
-    toUpper, toLower,
-    ord, chr,
-    readLitChar, showLitChar, lexLitChar,
-
-        -- ...and what the Prelude exports
-    Char, String
-    ) where
-
-import Array         -- Used for character name table.
-import Numeric (readDec, readOct, lexDigits, readHex)
-import UnicodePrims  -- Source of primitive Unicode functions.
-
--- Character-testing operations
-isAscii, isLatin1, isControl, isPrint, isSpace, isUpper, isLower,
- isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum :: Char -> Bool
-
-isAscii c                =  c < '\x80'
-
-isLatin1 c               =  c <= '\xff'
-
-isControl c              =  c < ' ' || c >= '\DEL' && c <= '\x9f'
-
-isPrint                  =  primUnicodeIsPrint
-
-isSpace c                =  c `elem` " \t\n\r\f\v\xA0"
-        -- Only Latin-1 spaces recognized
-
-isUpper                  =  primUnicodeIsUpper  -- 'A'..'Z'
-
-isLower                  =  primUnicodeIsLower  -- 'a'..'z'
-
-isAlpha c                =  isUpper c || isLower c
-
-isDigit c                =  c >= '0' && c <= '9'
-
-isOctDigit c             =  c >= '0' && c <= '7'
-
-isHexDigit c             =  isDigit c || c >= 'A' && c <= 'F' ||
-                                         c >= 'a' && c <= 'f'
-
-isAlphaNum               =  primUnicodeIsAlphaNum
-
-
--- Digit conversion operations
-digitToInt :: Char -> Int
-digitToInt c
-  | isDigit c            =  fromEnum c - fromEnum '0'
-  | c >= 'a' && c <= 'f' =  fromEnum c - fromEnum 'a' + 10
-  | c >= 'A' && c <= 'F' =  fromEnum c - fromEnum 'A' + 10
-  | otherwise            =  error "Char.digitToInt: not a digit"
-
-intToDigit :: Int -> Char
-intToDigit i
-  | i >= 0  && i <=  9   =  toEnum (fromEnum '0' + i)
-  | i >= 10 && i <= 15   =  toEnum (fromEnum 'a' + i - 10)
-  | otherwise            =  error "Char.intToDigit: not a digit"
-
-
--- Case-changing operations
-toUpper :: Char -> Char
-toUpper =  primUnicodeToUpper
-        
-toLower :: Char -> Char
-toLower =  primUnicodeToLower
-
--- Character code functions
-ord  :: Char -> Int
-ord  =  fromEnum
-     
-chr  :: Int  -> Char
-chr  =  toEnum
-
--- Text functions
-readLitChar          :: ReadS Char
-readLitChar ('\\':s) =  readEsc s
-readLitChar (c:s)    =  [(c,s)]
-
-readEsc          :: ReadS Char
-readEsc ('a':s)  = [('\a',s)]
-readEsc ('b':s)  = [('\b',s)]
-readEsc ('f':s)  = [('\f',s)]
-readEsc ('n':s)  = [('\n',s)]
-readEsc ('r':s)  = [('\r',s)]
-readEsc ('t':s)  = [('\t',s)]
-readEsc ('v':s)  = [('\v',s)]
-readEsc ('\\':s) = [('\\',s)]
-readEsc ('"':s)  = [('"',s)]
-readEsc ('\'':s) = [('\'',s)]
-readEsc ('^':c:s) | c >= '@' && c <= '_'
-                 = [(chr (ord c - ord '@'), s)]
-readEsc s@(d:_) | isDigit d
-                 = [(chr n, t) | (n,t) <- readDec s]
-readEsc ('o':s)  = [(chr n, t) | (n,t) <- readOct s]
-readEsc ('x':s)  = [(chr n, t) | (n,t) <- readHex s]
-readEsc s@(c:_) | isUpper c
-                 = let table = ('\DEL', "DEL") : assocs asciiTab
-                   in case [(c,s') | (c, mne) <- table,
-                                     ([],s') <- [match mne s]]
-                      of (pr:_) -> [pr]
-                         []     -> []
-readEsc _        = []
-
-match                         :: (Eq a) => [a] -> [a] -> ([a],[a])
-match (x:xs) (y:ys) | x == y  =  match xs ys
-match xs     ys               =  (xs,ys)
-
-showLitChar               :: Char -> ShowS
-showLitChar c | c > '\DEL' =  showChar '\\' . 
-                              protectEsc isDigit (shows (ord c))
-showLitChar '\DEL'         =  showString "\\DEL"
-showLitChar '\\'           =  showString "\\\\"
-showLitChar c | c >= ' '   =  showChar c
-showLitChar '\a'           =  showString "\\a"
-showLitChar '\b'           =  showString "\\b"
-showLitChar '\f'           =  showString "\\f"
-showLitChar '\n'           =  showString "\\n"
-showLitChar '\r'           =  showString "\\r"
-showLitChar '\t'           =  showString "\\t"
-showLitChar '\v'           =  showString "\\v"
-showLitChar '\SO'          =  protectEsc (== 'H') (showString "\\SO")
-showLitChar c              =  showString ('\\' : asciiTab!c)
-
-protectEsc p f             = f . cont
-                             where cont s@(c:_) | p c = "\\&" ++ s
-                                   cont s             = s
-asciiTab = listArray ('\NUL', ' ')
-           ["NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
-            "BS",  "HT",  "LF",  "VT",  "FF",  "CR",  "SO",  "SI", 
-            "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
-            "CAN", "EM",  "SUB", "ESC", "FS",  "GS",  "RS",  "US", 
-            "SP"] 
-
-lexLitChar          :: ReadS String
-lexLitChar ('\\':s) =  map (prefix '\\') (lexEsc s)
-        where
-          lexEsc (c:s)     | c `elem` "abfnrtv\\\"'" = [([c],s)]
-          lexEsc ('^':c:s) | c >= '@' && c <= '_'    = [(['^',c],s)]
-
-          -- Numeric escapes
-          lexEsc ('o':s)               = [prefix 'o' (span isOctDigit s)]
-          lexEsc ('x':s)               = [prefix 'x' (span isHexDigit s)]
-          lexEsc s@(d:_)   | isDigit d = [span isDigit s]
-
-          -- Very crude approximation to \XYZ.
-          lexEsc s@(c:_)   | isUpper c = [span isCharName s]
-          lexEsc _                     = []
-
-          isCharName c   = isUpper c || isDigit c
-          prefix c (t,s) = (c:t, s)
-
-lexLitChar (c:s)    =  [([c],s)]
-lexLitChar ""       =  []
-
diff --git a/libraries/code/Complex.hs b/libraries/code/Complex.hs
deleted file mode 100644 (file)
index cbfaee0..0000000
+++ /dev/null
@@ -1,94 +0,0 @@
-
-module Complex(Complex((:+)), realPart, imagPart, conjugate, mkPolar,
-               cis, polar, magnitude, phase)  where
-
-infix  6  :+
-
-data  (RealFloat a)     => Complex a = !a :+ !a  deriving (Eq,Read,Show)
-
-
-realPart, imagPart :: (RealFloat a) => Complex a -> a
-realPart (x:+y)         =  x
-imagPart (x:+y)         =  y
-
-conjugate       :: (RealFloat a) => Complex a -> Complex a
-conjugate (x:+y) =  x :+ (-y)
-
-mkPolar                 :: (RealFloat a) => a -> a -> Complex a
-mkPolar r theta         =  r * cos theta :+ r * sin theta
-
-cis             :: (RealFloat a) => a -> Complex a
-cis theta       =  cos theta :+ sin theta
-
-polar           :: (RealFloat a) => Complex a -> (a,a)
-polar z                 =  (magnitude z, phase z)
-
-magnitude :: (RealFloat a) => Complex a -> a
-magnitude (x:+y) =  scaleFloat k
-                    (sqrt ((scaleFloat mk x)^2 + (scaleFloat mk y)^2))
-                   where k  = max (exponent x) (exponent y)
-                         mk = - k
-
-phase :: (RealFloat a) => Complex a -> a
-phase (0 :+ 0) = 0
-phase (x :+ y) = atan2 y x
-
-
-instance  (RealFloat a) => Num (Complex a)  where
-    (x:+y) + (x':+y')  =  (x+x') :+ (y+y')
-    (x:+y) - (x':+y')  =  (x-x') :+ (y-y')
-    (x:+y) * (x':+y')  =  (x*x'-y*y') :+ (x*y'+y*x')
-    negate (x:+y)      =  negate x :+ negate y
-    abs z              =  magnitude z :+ 0
-    signum 0           =  0
-    signum z@(x:+y)    =  x/r :+ y/r  where r = magnitude z
-    fromInteger n      =  fromInteger n :+ 0
-
-instance  (RealFloat a) => Fractional (Complex a)  where
-    (x:+y) / (x':+y')  =  (x*x''+y*y'') / d :+ (y*x''-x*y'') / d
-                          where x'' = scaleFloat k x'
-                                y'' = scaleFloat k y'
-                                k   = - max (exponent x') (exponent y')
-                                d   = x'*x'' + y'*y''
-
-    fromRational a     =  fromRational a :+ 0
-
-instance  (RealFloat a) => Floating (Complex a)        where
-    pi             =  pi :+ 0
-    exp (x:+y)     =  expx * cos y :+ expx * sin y
-                      where expx = exp x
-    log z          =  log (magnitude z) :+ phase z
-
-    sqrt 0         =  0
-    sqrt z@(x:+y)  =  u :+ (if y < 0 then -v else v)
-                      where (u,v) = if x < 0 then (v',u') else (u',v')
-                            v'    = abs y / (u'*2)
-                            u'    = sqrt ((magnitude z + abs x) / 2)
-
-    sin (x:+y)     =  sin x * cosh y :+ cos x * sinh y
-    cos (x:+y)     =  cos x * cosh y :+ (- sin x * sinh y)
-    tan (x:+y)     =  (sinx*coshy:+cosx*sinhy)/(cosx*coshy:+(-sinx*sinhy))
-                      where sinx  = sin x
-                            cosx  = cos x
-                            sinhy = sinh y
-                            coshy = cosh y
-
-    sinh (x:+y)    =  cos y * sinh x :+ sin  y * cosh x
-    cosh (x:+y)    =  cos y * cosh x :+ sin y * sinh x
-    tanh (x:+y)    =  (cosy*sinhx:+siny*coshx)/(cosy*coshx:+siny*sinhx)
-                      where siny  = sin y
-                            cosy  = cos y
-                            sinhx = sinh x
-                            coshx = cosh x
-
-    asin z@(x:+y)  =  y':+(-x')
-                      where  (x':+y') = log (((-y):+x) + sqrt (1 - z*z))
-    acos z@(x:+y)  =  y'':+(-x'')
-                      where (x'':+y'') = log (z + ((-y'):+x'))
-                            (x':+y')   = sqrt (1 - z*z)
-    atan z@(x:+y)  =  y':+(-x')
-                      where (x':+y') = log (((1-y):+x) / sqrt (1+z*z))
-
-    asinh z        =  log (z + sqrt (1+z*z))
-    acosh z        =  log (z + (z+1) * sqrt ((z-1)/(z+1)))
-    atanh z        =  log ((1+z) / sqrt (1-z*z))
diff --git a/libraries/code/IO.hs b/libraries/code/IO.hs
deleted file mode 100644 (file)
index 6c29939..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-module IO {- export list omitted -} where
-
--- Just provide an implementation of the system-independent
--- actions that IO exports.
-
-try            :: IO a -> IO (Either IOError a)
-try f          =  catch (do r <- f
-                            return (Right r))
-                        (return . Left)
-
-bracket        :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
-bracket before after m = do
-        x  <- before
-        rs <- try (m x)
-        after x
-        case rs of
-           Right r -> return r
-           Left  e -> ioError e
-
--- variant of the above where middle computation doesn't want x
-bracket_        :: IO a -> (a -> IO b) -> IO c -> IO c
-bracket_ before after m = do
-         x  <- before
-         rs <- try m
-         after x
-         case rs of
-            Right r -> return r
-            Left  e -> ioError e
diff --git a/libraries/code/Ix.hs b/libraries/code/Ix.hs
deleted file mode 100644 (file)
index e379aac..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-module Ix ( Ix(range, index, inRange, rangeSize) ) where
-
-class  Ord a => Ix a  where
-    range     :: (a,a) -> [a]
-    index     :: (a,a) -> a -> Int
-    inRange   :: (a,a) -> a -> Bool
-    rangeSize :: (a,a) -> Int
-
-    rangeSize b@(l,h) | null (range b) = 0
-                      | otherwise      = index b h + 1 
-       -- NB: replacing "null (range b)" by  "not (l <= h)"
-       -- fails if the bounds are tuples.  For example,
-       --      (1,2) <= (2,1)
-       -- but the range is nevertheless empty
-       --      range ((1,2),(2,1)) = []
-
-instance  Ix Char  where
-    range (m,n)                = [m..n]
-    index b@(c,c') ci
-        | inRange b ci  =  fromEnum ci - fromEnum c
-        | otherwise     =  error "Ix.index: Index out of range."
-    inRange (c,c') i    =  c <= i && i <= c'
-
-instance  Ix Int  where
-    range (m,n)                = [m..n]
-    index b@(m,n) i
-        | inRange b i   =  i - m
-        | otherwise     =  error "Ix.index: Index out of range."
-    inRange (m,n) i     =  m <= i && i <= n
-
-instance  Ix Integer  where
-    range (m,n)                = [m..n]
-    index b@(m,n) i
-        | inRange b i   =  fromInteger (i - m)
-        | otherwise     =  error "Ix.index: Index out of range."
-    inRange (m,n) i     =  m <= i && i <= n
-
-instance (Ix a,Ix b) => Ix (a, b) -- as derived, for all tuples
-instance Ix Bool                  -- as derived
-instance Ix Ordering              -- as derived
-instance Ix ()                    -- as derived
diff --git a/libraries/code/List.hs b/libraries/code/List.hs
deleted file mode 100644 (file)
index 0300b1b..0000000
+++ /dev/null
@@ -1,270 +0,0 @@
-module List ( 
-    elemIndex, elemIndices,
-    find, findIndex, findIndices,
-    nub, nubBy, delete, deleteBy, (\\), deleteFirstsBy,
-    union, unionBy, intersect, intersectBy,
-    intersperse, transpose, partition, group, groupBy,
-    inits, tails, isPrefixOf, isSuffixOf,
-    mapAccumL, mapAccumR,
-    sort, sortBy, insert, insertBy, maximumBy, minimumBy,
-    genericLength, genericTake, genericDrop,
-    genericSplitAt, genericIndex, genericReplicate,
-    zip4, zip5, zip6, zip7,
-    zipWith4, zipWith5, zipWith6, zipWith7,
-    unzip4, unzip5, unzip6, unzip7, unfoldr,
-
-    -- ...and what the Prelude exports
-    -- []((:), []),    -- This is built-in syntax
-    map, (++), concat, filter,
-    head, last, tail, init, null, length, (!!),
-    foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,
-    iterate, repeat, replicate, cycle,
-    take, drop, splitAt, takeWhile, dropWhile, span, break,
-    lines, words, unlines, unwords, reverse, and, or,
-    any, all, elem, notElem, lookup,
-    sum, product, maximum, minimum, concatMap, 
-    zip, zip3, zipWith, zipWith3, unzip, unzip3
-    ) where
-
-import Maybe( listToMaybe )
-
-infix 5 \\
-
-elemIndex               :: Eq a => a -> [a] -> Maybe Int
-elemIndex x             =  findIndex (x ==)
-        
-elemIndices             :: Eq a => a -> [a] -> [Int]
-elemIndices x           =  findIndices (x ==)
-                        
-find                    :: (a -> Bool) -> [a] -> Maybe a
-find p                  =  listToMaybe . filter p
-
-findIndex               :: (a -> Bool) -> [a] -> Maybe Int
-findIndex p             =  listToMaybe . findIndices p
-
-findIndices             :: (a -> Bool) -> [a] -> [Int]
-findIndices p xs        =  [ i | (x,i) <- zip xs [0..], p x ]
-
-nub                     :: Eq a => [a] -> [a]
-nub                     =  nubBy (==)
-
-nubBy                   :: (a -> a -> Bool) -> [a] -> [a]
-nubBy eq []             =  []
-nubBy eq (x:xs)         =  x : nubBy eq (filter (\y -> not (eq x y)) xs)
-
-delete                  :: Eq a => a -> [a] -> [a]
-delete                  =  deleteBy (==)
-
-deleteBy                :: (a -> a -> Bool) -> a -> [a] -> [a]
-deleteBy eq x []        = []
-deleteBy eq x (y:ys)    = if x `eq` y then ys else y : deleteBy eq x ys
-
-(\\)                    :: Eq a => [a] -> [a] -> [a]
-(\\)                    =  foldl (flip delete)
-
-deleteFirstsBy          :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-deleteFirstsBy eq       =  foldl (flip (deleteBy eq))
-
-union                   :: Eq a => [a] -> [a] -> [a]
-union                   =  unionBy (==)    
-
-unionBy                 :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-unionBy eq xs ys        =  xs ++ deleteFirstsBy eq (nubBy eq ys) xs
-
-intersect               :: Eq a => [a] -> [a] -> [a]
-intersect               =  intersectBy (==)
-
-intersectBy             :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-intersectBy eq xs ys    =  [x | x <- xs, any (eq x) ys]
-
-intersperse             :: a -> [a] -> [a]
-intersperse sep []      =  []
-intersperse sep [x]     =  [x]
-intersperse sep (x:xs)  =  x : sep : intersperse sep xs
-
--- transpose is lazy in both rows and columns,
---       and works for non-rectangular 'matrices'
--- For example, transpose [[1,2],[3,4,5],[]]  =  [[1,3],[2,4],[5]]
--- Note that [h | (h:t) <- xss] is not the same as (map head xss)
---      because the former discards empty sublists inside xss
-transpose                :: [[a]] -> [[a]]
-transpose []             = []
-transpose ([]     : xss) = transpose xss
-transpose ((x:xs) : xss) = (x : [h | (h:t) <- xss]) : 
-                           transpose (xs : [t | (h:t) <- xss])
-
-partition               :: (a -> Bool) -> [a] -> ([a],[a])
-partition p xs          =  (filter p xs, filter (not . p) xs)
-
--- group splits its list argument into a list of lists of equal, adjacent
--- elements.  e.g.,
--- group "Mississippi" == ["M","i","ss","i","ss","i","pp","i"]
-group                   :: Eq a => [a] -> [[a]]
-group                   =  groupBy (==)
-
-groupBy                 :: (a -> a -> Bool) -> [a] -> [[a]]
-groupBy eq []           =  []
-groupBy eq (x:xs)       =  (x:ys) : groupBy eq zs
-                           where (ys,zs) = span (eq x) xs
-
--- inits xs returns the list of initial segments of xs, shortest first.
--- e.g., inits "abc" == ["","a","ab","abc"]
-inits                   :: [a] -> [[a]]
-inits []                =  [[]]
-inits (x:xs)            =  [[]] ++ map (x:) (inits xs)
-
--- tails xs returns the list of all final segments of xs, longest first.
--- e.g., tails "abc" == ["abc", "bc", "c",""]
-tails                   :: [a] -> [[a]]
-tails []                =  [[]]
-tails xxs@(_:xs)        =  xxs : tails xs
-
-isPrefixOf               :: Eq a => [a] -> [a] -> Bool
-isPrefixOf []     _      =  True
-isPrefixOf _      []     =  False
-isPrefixOf (x:xs) (y:ys) =  x == y && isPrefixOf xs ys
-
-isSuffixOf              :: Eq a => [a] -> [a] -> Bool
-isSuffixOf x y          =  reverse x `isPrefixOf` reverse y
-
-mapAccumL               :: (a -> b -> (a, c)) -> a -> [b] -> (a, [c])
-mapAccumL f s []        =  (s, [])
-mapAccumL f s (x:xs)    =  (s'',y:ys)
-                           where (s', y ) = f s x
-                                 (s'',ys) = mapAccumL f s' xs
-
-mapAccumR               :: (a -> b -> (a, c)) -> a -> [b] -> (a, [c])
-mapAccumR f s []        =  (s, [])
-mapAccumR f s (x:xs)    =  (s'', y:ys)
-                           where (s'',y ) = f s' x
-                                 (s', ys) = mapAccumR f s xs
-
-unfoldr                 :: (b -> Maybe (a,b)) -> b -> [a]
-unfoldr f b             = case f b of
-                                Nothing    -> []
-                                Just (a,b) -> a : unfoldr f b
-
-sort                    :: (Ord a) => [a] -> [a]
-sort                    =  sortBy compare
-
-sortBy                  :: (a -> a -> Ordering) -> [a] -> [a]
-sortBy cmp              =  foldr (insertBy cmp) []
-
-insert                  :: (Ord a) => a -> [a] -> [a]
-insert                  = insertBy compare
-
-insertBy                :: (a -> a -> Ordering) -> a -> [a] -> [a]
-insertBy cmp x []       =  [x]
-insertBy cmp x ys@(y:ys')
-                        =  case cmp x y of
-                                GT -> y : insertBy cmp x ys'
-                                _  -> x : ys
-
-maximumBy               :: (a -> a -> Ordering) -> [a] -> a
-maximumBy cmp []        =  error "List.maximumBy: empty list"
-maximumBy cmp xs        =  foldl1 max xs
-                        where
-                           max x y = case cmp x y of
-                                        GT -> x
-                                        _  -> y
-
-minimumBy               :: (a -> a -> Ordering) -> [a] -> a
-minimumBy cmp []        =  error "List.minimumBy: empty list"
-minimumBy cmp xs        =  foldl1 min xs
-                        where
-                           min x y = case cmp x y of
-                                        GT -> y
-                                        _  -> x
-
-genericLength           :: (Integral a) => [b] -> a
-genericLength []        =  0
-genericLength (x:xs)    =  1 + genericLength xs
-
-genericTake             :: (Integral a) => a -> [b] -> [b]
-genericTake _ []        =  []
-genericTake 0 _         =  []
-genericTake n (x:xs) 
-   | n > 0              =  x : genericTake (n-1) xs
-   | otherwise          =  error "List.genericTake: negative argument"
-
-genericDrop             :: (Integral a) => a -> [b] -> [b]
-genericDrop 0 xs        =  xs
-genericDrop _ []        =  []
-genericDrop n (_:xs) 
-   | n > 0              =  genericDrop (n-1) xs
-   | otherwise          =  error "List.genericDrop: negative argument"
-
-genericSplitAt          :: (Integral a) => a -> [b] -> ([b],[b])
-genericSplitAt 0 xs     =  ([],xs)
-genericSplitAt _ []     =  ([],[])
-genericSplitAt n (x:xs) 
-   | n > 0              =  (x:xs',xs'')
-   | otherwise          =  error "List.genericSplitAt: negative argument"
-       where (xs',xs'') =  genericSplitAt (n-1) xs
-
-genericIndex            :: (Integral a) => [b] -> a -> b
-genericIndex (x:_)  0   =  x
-genericIndex (_:xs) n 
-        | n > 0         =  genericIndex xs (n-1)
-        | otherwise     =  error "List.genericIndex: negative argument"
-genericIndex _ _        =  error "List.genericIndex: index too large"
-
-genericReplicate        :: (Integral a) => a -> b -> [b]
-genericReplicate n x    =  genericTake n (repeat x)
-zip4                    :: [a] -> [b] -> [c] -> [d] -> [(a,b,c,d)]
-zip4                    =  zipWith4 (,,,)
-
-zip5                    :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a,b,c,d,e)]
-zip5                    =  zipWith5 (,,,,)
-
-zip6                    :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> 
-                              [(a,b,c,d,e,f)]
-zip6                    =  zipWith6 (,,,,,)
-
-zip7                    :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] ->
-                              [g] -> [(a,b,c,d,e,f,g)]
-zip7                    =  zipWith7 (,,,,,,)
-
-zipWith4                :: (a->b->c->d->e) -> [a]->[b]->[c]->[d]->[e]
-zipWith4 z (a:as) (b:bs) (c:cs) (d:ds)
-                        =  z a b c d : zipWith4 z as bs cs ds
-zipWith4 _ _ _ _ _      =  []
-
-zipWith5                :: (a->b->c->d->e->f) -> 
-                           [a]->[b]->[c]->[d]->[e]->[f]
-zipWith5 z (a:as) (b:bs) (c:cs) (d:ds) (e:es)
-                        =  z a b c d e : zipWith5 z as bs cs ds es
-zipWith5 _ _ _ _ _ _    =  []
-
-zipWith6                :: (a->b->c->d->e->f->g) ->
-                           [a]->[b]->[c]->[d]->[e]->[f]->[g]
-zipWith6 z (a:as) (b:bs) (c:cs) (d:ds) (e:es) (f:fs)
-                        =  z a b c d e f : zipWith6 z as bs cs ds es fs
-zipWith6 _ _ _ _ _ _ _  =  []
-
-zipWith7                :: (a->b->c->d->e->f->g->h) ->
-                           [a]->[b]->[c]->[d]->[e]->[f]->[g]->[h]
-zipWith7 z (a:as) (b:bs) (c:cs) (d:ds) (e:es) (f:fs) (g:gs)
-                   =  z a b c d e f g : zipWith7 z as bs cs ds es fs gs
-zipWith7 _ _ _ _ _ _ _ _ = []
-
-unzip4                  :: [(a,b,c,d)] -> ([a],[b],[c],[d])
-unzip4                  =  foldr (\(a,b,c,d) ~(as,bs,cs,ds) ->
-                                        (a:as,b:bs,c:cs,d:ds))
-                                 ([],[],[],[])
-
-unzip5                  :: [(a,b,c,d,e)] -> ([a],[b],[c],[d],[e])
-unzip5                  =  foldr (\(a,b,c,d,e) ~(as,bs,cs,ds,es) ->
-                                        (a:as,b:bs,c:cs,d:ds,e:es))
-                                 ([],[],[],[],[])
-
-unzip6                  :: [(a,b,c,d,e,f)] -> ([a],[b],[c],[d],[e],[f])
-unzip6                  =  foldr (\(a,b,c,d,e,f) ~(as,bs,cs,ds,es,fs) ->
-                                        (a:as,b:bs,c:cs,d:ds,e:es,f:fs))
-                                 ([],[],[],[],[],[])
-
-unzip7          :: [(a,b,c,d,e,f,g)] -> ([a],[b],[c],[d],[e],[f],[g])
-unzip7          =  foldr (\(a,b,c,d,e,f,g) ~(as,bs,cs,ds,es,fs,gs) ->
-                                (a:as,b:bs,c:cs,d:ds,e:es,f:fs,g:gs))
-                         ([],[],[],[],[],[],[])
diff --git a/libraries/code/Locale.hs b/libraries/code/Locale.hs
deleted file mode 100644 (file)
index b56a648..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-module Locale(TimeLocale(..), defaultTimeLocale) where
-
-data TimeLocale = TimeLocale {
-        wDays  :: [(String, String)],   -- full and abbreviated week days
-        months :: [(String, String)],   -- full and abbreviated months
-        amPm   :: (String, String),     -- AM/PM symbols
-        dateTimeFmt, dateFmt,           -- formatting strings
-          timeFmt, time12Fmt :: String     
-        } deriving (Eq, Ord, Show)
-
-defaultTimeLocale :: TimeLocale 
-defaultTimeLocale =  TimeLocale { 
-        wDays  = [("Sunday",   "Sun"),  ("Monday",    "Mon"),   
-                  ("Tuesday",  "Tue"),  ("Wednesday", "Wed"), 
-                  ("Thursday", "Thu"),  ("Friday",    "Fri"), 
-                  ("Saturday", "Sat")],
-
-        months = [("January",   "Jan"), ("February",  "Feb"),
-                  ("March",     "Mar"), ("April",     "Apr"),
-                  ("May",       "May"), ("June",      "Jun"),
-                  ("July",      "Jul"), ("August",    "Aug"),
-                  ("September", "Sep"), ("October",   "Oct"),
-                  ("November",  "Nov"), ("December",  "Dec")],
-
-        amPm = ("AM", "PM"),
-        dateTimeFmt = "%a %b %e %H:%M:%S %Z %Y",
-        dateFmt = "%m/%d/%y",
-        timeFmt = "%H:%M:%S",
-        time12Fmt = "%I:%M:%S %p"
-        }
diff --git a/libraries/code/Maybe.hs b/libraries/code/Maybe.hs
deleted file mode 100644 (file)
index f1eac52..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-module Maybe(
-    isJust, isNothing,
-    fromJust, fromMaybe, listToMaybe, maybeToList,
-    catMaybes, mapMaybe,
-
-    -- ...and what the Prelude exports
-    Maybe(Nothing, Just),
-    maybe
-  ) where
-
-isJust                 :: Maybe a -> Bool
-isJust (Just a)        =  True
-isJust Nothing         =  False
-
-isNothing             :: Maybe a -> Bool
-isNothing             =  not . isJust
-
-fromJust               :: Maybe a -> a
-fromJust (Just a)      =  a
-fromJust Nothing       =  error "Maybe.fromJust: Nothing"
-
-fromMaybe              :: a -> Maybe a -> a
-fromMaybe d Nothing    =  d
-fromMaybe d (Just a)   =  a
-
-maybeToList            :: Maybe a -> [a]
-maybeToList Nothing    =  []
-maybeToList (Just a)   =  [a]
-
-listToMaybe            :: [a] -> Maybe a
-listToMaybe []         =  Nothing
-listToMaybe (a:_)      =  Just a
-catMaybes              :: [Maybe a] -> [a]
-catMaybes ms           =  [ m | Just m <- ms ]
-
-mapMaybe               :: (a -> Maybe b) -> [a] -> [b]
-mapMaybe f             =  catMaybes . map f
diff --git a/libraries/code/Monad.hs b/libraries/code/Monad.hs
deleted file mode 100644 (file)
index 6d63563..0000000
+++ /dev/null
@@ -1,97 +0,0 @@
-module Monad (
-    MonadPlus(mzero, mplus),
-    join, guard, when, unless, ap,
-    msum,
-    filterM, mapAndUnzipM, zipWithM, zipWithM_, foldM, 
-    liftM, liftM2, liftM3, liftM4, liftM5,
-
-    -- ...and what the Prelude exports
-    Monad((>>=), (>>), return, fail),
-    Functor(fmap),
-    mapM, mapM_, sequence, sequence_, (=<<), 
-    ) where
-
-
--- The MonadPlus class definition
-
-class  (Monad m) => MonadPlus m  where
-    mzero  :: m a
-    mplus  :: m a -> m a -> m a
-
-
--- Instances of MonadPlus
-
-instance  MonadPlus Maybe  where
-    mzero                 = Nothing
-
-    Nothing `mplus` ys    =  ys
-    xs      `mplus` ys    =  xs
-
-instance  MonadPlus []  where
-    mzero =  []
-    mplus = (++)
-
-
--- Functions    
-
-
-msum            :: MonadPlus m => [m a] -> m a
-msum xs                 =  foldr mplus mzero xs
-
-join             :: (Monad m) => m (m a) -> m a
-join x           =  x >>= id
-
-when             :: (Monad m) => Bool -> m () -> m ()
-when p s         =  if p then s else return ()
-
-unless           :: (Monad m) => Bool -> m () -> m ()
-unless p s       =  when (not p) s
-
-ap               :: (Monad m) => m (a -> b) -> m a -> m b
-ap               =  liftM2 ($)
-
-guard            :: MonadPlus m => Bool -> m ()
-guard p          =  if p then return () else mzero
-
-mapAndUnzipM     :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
-mapAndUnzipM f xs = sequence (map f xs) >>= return . unzip
-
-zipWithM         :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
-zipWithM f xs ys =  sequence (zipWith f xs ys)
-
-zipWithM_         :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m ()
-zipWithM_ f xs ys =  sequence_ (zipWith f xs ys)
-
-foldM            :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
-foldM f a []     =  return a
-foldM f a (x:xs) =  f a x >>= \ y -> foldM f y xs
-
-filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]
-filterM p []     = return []
-filterM p (x:xs) = do { b  <- p x;
-                       ys <- filterM p xs; 
-                       return (if b then (x:ys) else ys)
-                  }
-
-liftM            :: (Monad m) => (a -> b) -> (m a -> m b)
-liftM f          =  \a -> do { a' <- a; return (f a') }
-
-liftM2           :: (Monad m) => (a -> b -> c) -> (m a -> m b -> m c)
-liftM2 f         =  \a b -> do { a' <- a; b' <- b; return (f a' b') }
-
-liftM3           :: (Monad m) => (a -> b -> c -> d) ->
-                                 (m a -> m b -> m c -> m d)
-liftM3 f         =  \a b c -> do { a' <- a; b' <- b; c' <- c;
-                                  return (f a' b' c') }
-
-liftM4           :: (Monad m) => (a -> b -> c -> d -> e) ->
-                                 (m a -> m b -> m c -> m d -> m e)
-liftM4 f         =  \a b c d -> do { a' <- a; b' <- b; c' <- c; d' <- d;
-                                    return (f a' b' c' d') }
-
-liftM5           :: (Monad m) => (a -> b -> c -> d -> e -> f) ->
-                                 (m a -> m b -> m c -> m d -> m e -> m f)
-liftM5 f         =  \a b c d e -> do { a' <- a; b' <- b; c' <- c; d' <- d;
-                                      e' <- e; return (f a' b' c' d' e') }
-
-
diff --git a/libraries/code/Numeric.hs b/libraries/code/Numeric.hs
deleted file mode 100644 (file)
index 9dcf496..0000000
+++ /dev/null
@@ -1,341 +0,0 @@
-module Numeric(fromRat,
-               showSigned, showIntAtBase,
-               showInt, showOct, showHex,
-               readSigned, readInt,
-               readDec, readOct, readHex, 
-               floatToDigits,
-               showEFloat, showFFloat, showGFloat, showFloat, 
-               readFloat, lexDigits) where
-
-import Char   ( isDigit, isOctDigit, isHexDigit
-              , digitToInt, intToDigit )
-import Ratio  ( (%), numerator, denominator )
-import Array  ( (!), Array, array )
-
--- This converts a rational to a floating.  This should be used in the
--- Fractional instances of Float and Double.
-
-fromRat :: (RealFloat a) => Rational -> a
-fromRat x = 
-    if x == 0 then encodeFloat 0 0              -- Handle exceptional cases
-    else if x < 0 then - fromRat' (-x)          -- first.
-    else fromRat' x
-
--- Conversion process:
--- Scale the rational number by the RealFloat base until
--- it lies in the range of the mantissa (as used by decodeFloat/encodeFloat).
--- Then round the rational to an Integer and encode it with the exponent
--- that we got from the scaling.
--- To speed up the scaling process we compute the log2 of the number to get
--- a first guess of the exponent.
-fromRat' :: (RealFloat a) => Rational -> a
-fromRat' x = r
-  where b = floatRadix r
-        p = floatDigits r
-        (minExp0, _) = floatRange r
-        minExp = minExp0 - p            -- the real minimum exponent
-        xMin = toRational (expt b (p-1))
-        xMax = toRational (expt b p)
-        p0 = (integerLogBase b (numerator x) -
-              integerLogBase b (denominator x) - p) `max` minExp
-        f = if p0 < 0 then 1 % expt b (-p0) else expt b p0 % 1
-        (x', p') = scaleRat (toRational b) minExp xMin xMax p0 (x / f)
-        r = encodeFloat (round x') p'
-
--- Scale x until xMin <= x < xMax, or p (the exponent) <= minExp.
-scaleRat :: Rational -> Int -> Rational -> Rational -> 
-             Int -> Rational -> (Rational, Int)
-scaleRat b minExp xMin xMax p x =
-    if p <= minExp then
-        (x, p)
-    else if x >= xMax then
-        scaleRat b minExp xMin xMax (p+1) (x/b)
-    else if x < xMin  then
-        scaleRat b minExp xMin xMax (p-1) (x*b)
-    else
-        (x, p)
-
--- Exponentiation with a cache for the most common numbers.
-minExpt = 0::Int
-maxExpt = 1100::Int
-expt :: Integer -> Int -> Integer
-expt base n =
-    if base == 2 && n >= minExpt && n <= maxExpt then
-        expts!n
-    else
-        base^n
-
-expts :: Array Int Integer
-expts = array (minExpt,maxExpt) [(n,2^n) | n <- [minExpt .. maxExpt]]
-
--- Compute the (floor of the) log of i in base b.
--- Simplest way would be just divide i by b until it's smaller then b,
--- but that would be very slow!  We are just slightly more clever.
-integerLogBase :: Integer -> Integer -> Int
-integerLogBase b i =
-     if i < b then
-        0
-     else
-        -- Try squaring the base first to cut down the number of divisions.
-        let l = 2 * integerLogBase (b*b) i
-            doDiv :: Integer -> Int -> Int
-            doDiv i l = if i < b then l else doDiv (i `div` b) (l+1)
-        in  doDiv (i `div` (b^l)) l
-
-
--- Misc utilities to show integers and floats 
-
-showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
-showSigned showPos p x 
-  | x < 0     = showParen (p > 6) (showChar '-' . showPos (-x))
-  | otherwise = showPos x
-
--- showInt, showOct, showHex are used for positive numbers only
-showInt, showOct, showHex :: Integral a => a -> ShowS
-showOct = showIntAtBase  8 intToDigit
-showInt = showIntAtBase 10 intToDigit
-showHex = showIntAtBase 16 intToDigit
-
-showIntAtBase :: Integral a 
-             => a              -- base
-             -> (Int -> Char)  -- digit to char
-             -> a              -- number to show
-             -> ShowS
-showIntAtBase base intToDig n rest
-  | n < 0     = error "Numeric.showIntAtBase: can't show negative numbers"
-  | n' == 0   = rest'
-  | otherwise = showIntAtBase base intToDig n' rest'
-  where
-    (n',d) = quotRem n base
-    rest'  = intToDig (fromIntegral d) : rest
-
-
-readSigned :: (Real a) => ReadS a -> ReadS a
-readSigned readPos = readParen False read'
-                     where read' r  = read'' r ++
-                                      [(-x,t) | ("-",s) <- lex r,
-                                                (x,t)   <- read'' s]
-                           read'' r = [(n,s)  | (str,s) <- lex r,
-                                                (n,"")  <- readPos str]
-
-
--- readInt reads a string of digits using an arbitrary base.  
--- Leading minus signs must be handled elsewhere.
-
-readInt :: (Integral a) => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
-readInt radix isDig digToInt s =
-   [(foldl1 (\n d -> n * radix + d) (map (fromIntegral . digToInt) ds), r)
-          | (ds,r) <- nonnull isDig s ]
-
--- Unsigned readers for various bases
-readDec, readOct, readHex :: (Integral a) => ReadS a
-readDec = readInt 10 isDigit    digitToInt
-readOct = readInt  8 isOctDigit digitToInt
-readHex = readInt 16 isHexDigit digitToInt
-
-
-showEFloat     :: (RealFloat a) => Maybe Int -> a -> ShowS
-showFFloat     :: (RealFloat a) => Maybe Int -> a -> ShowS
-showGFloat     :: (RealFloat a) => Maybe Int -> a -> ShowS
-showFloat      :: (RealFloat a) => a -> ShowS
-
-showEFloat d x =  showString (formatRealFloat FFExponent d x)
-showFFloat d x =  showString (formatRealFloat FFFixed d x)
-showGFloat d x =  showString (formatRealFloat FFGeneric d x)
-showFloat      =  showGFloat Nothing 
-
--- These are the format types.  This type is not exported.
-
-data FFFormat = FFExponent | FFFixed | FFGeneric
-
-formatRealFloat :: (RealFloat a) => FFFormat -> Maybe Int -> a -> String
-formatRealFloat fmt decs x 
-  = s
-  where 
-    base = 10
-    s = if isNaN x then 
-            "NaN"
-        else if isInfinite x then 
-            if x < 0 then "-Infinity" else "Infinity"
-        else if x < 0 || isNegativeZero x then 
-            '-' : doFmt fmt (floatToDigits (toInteger base) (-x))
-        else 
-            doFmt fmt (floatToDigits (toInteger base) x)
-    
-    doFmt fmt (is, e)
-      = let 
-           ds = map intToDigit is
-        in  
-        case fmt of
-          FFGeneric -> 
-              doFmt (if e < 0 || e > 7 then FFExponent else FFFixed)
-                    (is, e)
-          FFExponent ->
-            case decs of
-              Nothing ->
-                case ds of
-                   []    -> "0.0e0"
-                   [d]   -> d : ".0e" ++ show (e-1)
-                   d:ds  -> d : '.' : ds ++ 'e':show (e-1)
-          
-              Just dec ->
-                let dec' = max dec 1 in
-                case is of
-                  [] -> '0':'.':take dec' (repeat '0') ++ "e0"
-                  _ ->
-                    let (ei, is') = roundTo base (dec'+1) is
-                        d:ds = map intToDigit
-                                   (if ei > 0 then init is' else is')
-                    in d:'.':ds  ++ "e" ++ show (e-1+ei)
-          
-          FFFixed ->
-            case decs of
-               Nothing         -- Always prints a decimal point
-                 | e > 0     -> take e (ds ++ repeat '0')
-                                ++ '.' : mk0 (drop e ds)
-                 | otherwise -> "0." ++ mk0 (replicate (-e) '0' ++ ds)
-              
-               Just dec ->  -- Print decimal point iff dec > 0
-                 let dec' = max dec 0 in
-                 if e >= 0 then
-                   let (ei, is') = roundTo base (dec' + e) is
-                       (ls, rs)  = splitAt (e+ei) 
-                                              (map intToDigit is')
-                   in  mk0 ls ++ mkdot0 rs
-                 else
-                   let (ei, is') = roundTo base dec' 
-                                           (replicate (-e) 0 ++ is)
-                       d : ds = map intToDigit 
-                                    (if ei > 0 then is' else 0:is')
-                   in  d : mkdot0 ds
-            where   
-              mk0 "" = "0"        -- Print 0.34, not .34
-              mk0 s  = s  
-    
-              mkdot0 "" = ""       -- Print 34, not 34.
-              mkdot0 s  = '.' : s  -- when the format specifies no
-                                  -- digits after the decimal point
-    
-
-roundTo :: Int -> Int -> [Int] -> (Int, [Int])
-roundTo base d is = case f d is of
-                (0, is) -> (0, is)
-                (1, is) -> (1, 1 : is)
-  where b2 = base `div` 2
-        f n [] = (0, replicate n 0)
-        f 0 (i:_) = (if i >= b2 then 1 else 0, [])
-        f d (i:is) = 
-            let (c, ds) = f (d-1) is
-                i' = c + i
-            in  if i' == base then (1, 0:ds) else (0, i':ds)
-
---
--- Based on "Printing Floating-Point Numbers Quickly and Accurately"
--- by R.G. Burger and R. K. Dybvig, in PLDI 96.
--- The version here uses a much slower logarithm estimator.  
--- It should be improved.
-
--- This function returns a non-empty list of digits (Ints in [0..base-1])
--- and an exponent.  In general, if
---      floatToDigits r = ([a, b, ... z], e)
--- then
---      r = 0.ab..z * base^e
--- 
-
-floatToDigits :: (RealFloat a) => Integer -> a -> ([Int], Int)
-
-floatToDigits _ 0 = ([], 0)
-floatToDigits base x =
-    let (f0, e0) = decodeFloat x
-        (minExp0, _) = floatRange x
-        p = floatDigits x
-        b = floatRadix x
-        minExp = minExp0 - p            -- the real minimum exponent
-
-        -- Haskell requires that f be adjusted so denormalized numbers
-        -- will have an impossibly low exponent.  Adjust for this.
-        f :: Integer
-        e :: Int
-        (f, e) = let n = minExp - e0
-                 in  if n > 0 then (f0 `div` (b^n), e0+n) else (f0, e0)
-
-        (r, s, mUp, mDn) =
-           if e >= 0 then
-               let be = b^e in
-               if f == b^(p-1) then
-                   (f*be*b*2, 2*b, be*b, b)
-               else
-                   (f*be*2, 2, be, be)
-           else
-               if e > minExp && f == b^(p-1) then
-                   (f*b*2, b^(-e+1)*2, b, 1)
-               else
-                   (f*2, b^(-e)*2, 1, 1)
-        k = 
-            let k0 =
-                    if b==2 && base==10 then
-                        -- logBase 10 2 is slightly bigger than 3/10 so
-                        -- the following will err on the low side.  Ignoring
-                        -- the fraction will make it err even more.
-                        -- Haskell promises that p-1 <= logBase b f < p.
-                        (p - 1 + e0) * 3 `div` 10
-                    else
-                        ceiling ((log (fromInteger (f+1)) + 
-                                 fromIntegral e * log (fromInteger b)) / 
-                                  log (fromInteger base))
-                fixup n =
-                    if n >= 0 then
-                        if r + mUp <= expt base n * s then n else fixup (n+1)
-                    else
-                        if expt base (-n) * (r + mUp) <= s then n
-                                                           else fixup (n+1)
-            in  fixup k0
-
-        gen ds rn sN mUpN mDnN =
-            let (dn, rn') = (rn * base) `divMod` sN
-                mUpN' = mUpN * base
-                mDnN' = mDnN * base
-            in  case (rn' < mDnN', rn' + mUpN' > sN) of
-                (True,  False) -> dn : ds
-                (False, True)  -> dn+1 : ds
-                (True,  True)  -> if rn' * 2 < sN then dn : ds else dn+1 : ds
-                (False, False) -> gen (dn:ds) rn' sN mUpN' mDnN'
-        rds =
-            if k >= 0 then
-                gen [] r (s * expt base k) mUp mDn
-            else
-                let bk = expt base (-k)
-                in  gen [] (r * bk) s (mUp * bk) (mDn * bk)
-    in  (map fromIntegral (reverse rds), k)
-
-
-
--- This floating point reader uses a less restrictive syntax for floating
--- point than the Haskell lexer.  The `.' is optional.
-
-readFloat     :: (RealFrac a) => ReadS a
-readFloat r    = [(fromRational ((n%1)*10^^(k-d)),t) | (n,d,s) <- readFix r,
-                                                       (k,t)   <- readExp s] ++
-                 [ (0/0, t) | ("NaN",t)      <- lex r] ++
-                 [ (1/0, t) | ("Infinity",t) <- lex r]
-               where 
-                 readFix r = [(read (ds++ds'), length ds', t)
-                             | (ds,d) <- lexDigits r,
-                               (ds',t) <- lexFrac d ]
-               
-                 lexFrac ('.':ds) = lexDigits ds
-                 lexFrac s        = [("",s)]        
-                 
-                 readExp (e:s) | e `elem` "eE" = readExp' s
-                 readExp s                     = [(0,s)]
-                 
-                 readExp' ('-':s) = [(-k,t) | (k,t) <- readDec s]
-                 readExp' ('+':s) = readDec s
-                 readExp' s       = readDec s
-
-lexDigits        :: ReadS String 
-lexDigits        =  nonnull isDigit
-
-nonnull          :: (Char -> Bool) -> ReadS String
-nonnull p s      =  [(cs,t) | (cs@(_:_),t) <- [span p s]]
-
diff --git a/libraries/code/Random.hs b/libraries/code/Random.hs
deleted file mode 100644 (file)
index 8a917d7..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-module Random (
-       RandomGen(next, split, genRange),
-       StdGen, mkStdGen,
-
-       Random( random,   randomR, 
-               randoms,  randomRs,
-               randomIO, randomRIO ),
-
-       getStdRandom,
-       getStdGen, setStdGen, newStdGen
-  ) where
-       
----------------- The RandomGen class ---------------------------
-
-class RandomGen g where
-  genRange :: g -> (Int, Int)
-  next     :: g -> (Int, g)
-  split    :: g -> (g, g)      -- May not exist for all RandomGens
-
-
----------------- A standard instance of RandomGen ---------------
-data StdGen = ...      -- Abstract
-
-instance RandomGen StdGen where ...
-
--- The show/read instances provide a primitive way to save
--- the state of a random number generator
--- It is expected read (show g) == g
-
-instance Read StdGen where ...
-       -- read succeeds on *any* string, not only those
-       -- constructed with show.  Hence you can use any
-       -- string as way to construct a RandomGen.
-       --   - read guarantees to consume a finite portion of
-       --     the string
-       --   - different strings are likely to result in 
-       --     different generators
-
-instance Show StdGen where ...
-
-mkStdGen :: Int -> StdGen
--- Make a StdGen from an Int.  Different Ints should result
--- in different generators.
-
-
----------------- The Random class ---------------------------
-
-class Random a where
-   randomR :: RandomGen g => (a, a) -> g -> (a, g)
-       -- Returns a random value uniformly distributed in [lo,hi]
-       -- It is unspecified what happens if lo > hi
-
-   random  :: RandomGen g => g -> (a, g)
-       -- Return any value of type a.
-       -- For bounded types, the range is normally the whole type
-       -- For Fractional types, the range is normally [0..1]
-       -- For Integer, the range is (arbitrarily) the range of Int
-
-   randomRs :: RandomGen g => (a, a) -> g -> [a]
-   randoms  :: RandomGen g => g -> [a]
-
-   randomIO :: IO a
-   randomRIO :: (a,a) -> IO a
-
-       -- Default methods
-   randoms g = x : randoms g' 
-            where 
-              (x,g') = random g
-   randomRs = ...similar...
-
-   randomIO        = getStdRandom random
-   randomRIO range = getStdRandom (randomR range)
-
-
-instance Random Int     where ...
-instance Random Integer where ...
-instance Random Float   where ...
-instance Random Double  where ...
-instance Random Bool    where ...
-instance Random Char    where ...
-
-
----------------- The global random generator ---------------------------
-
--- There is a single, implicit, global random number generator
--- of type StdGen, held in some global variable maintained by the IO monad
---
--- It is initialised non-deterministically; to get
--- deterministic behaviour use setStdGen.
-
-setStdGen :: StdGen -> IO ()   -- Set the global generator
-getStdGen :: IO StdGen -- Get the global generator
-
-getStdRandom :: (StdGen -> (a, StdGen)) -> IO a
-       -- Use the supplied function to get a value from
-       -- the current global random generator, g, and update the
-       -- global generator with the new generator returned
-getStdRandom f = do
-       g <- getStdGen
-       let (val, g') = f g
-       setStdGen g'
-       return val
-
-newStdGen :: IO StdGen
-       -- Apply split to the current global random generator
-       -- update it with one of the results and return the other
-newStdGen = do
-       g <- getStdGen
-       let (s1,s2) = split g
-       setStdGen s1
-       return s2
-
-
diff --git a/libraries/code/Ratio.hs b/libraries/code/Ratio.hs
deleted file mode 100644 (file)
index 10b0c84..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
--- Standard functions on rational numbers
-
-module  Ratio (
-    Ratio, Rational, (%), numerator, denominator, approxRational ) where
-
-infixl 7  %
-
-ratPrec = 7 :: Int
-
-data  (Integral a)      => Ratio a = !a :% !a  deriving (Eq)
-type  Rational          =  Ratio Integer
-
-(%)                     :: (Integral a) => a -> a -> Ratio a
-numerator, denominator  :: (Integral a) => Ratio a -> a
-approxRational          :: (RealFrac a) => a -> a -> Rational
-
-
--- "reduce" is a subsidiary function used only in this module.
--- It normalises a ratio by dividing both numerator
--- and denominator by their greatest common divisor.
---
--- E.g., 12 `reduce` 8    ==  3 :%   2
---       12 `reduce` (-8) ==  3 :% (-2)
-
-reduce _ 0              =  error "Ratio.% : zero denominator"
-reduce x y              =  (x `quot` d) :% (y `quot` d)
-                           where d = gcd x y
-
-x % y                   =  reduce (x * signum y) (abs y)
-
-numerator (x :% _)      =  x
-
-denominator (_ :% y)    =  y
-
-
-instance  (Integral a)  => Ord (Ratio a)  where
-    (x:%y) <= (x':%y')  =  x * y' <= x' * y
-    (x:%y) <  (x':%y')  =  x * y' <  x' * y
-
-instance  (Integral a)  => Num (Ratio a)  where
-    (x:%y) + (x':%y')   =  reduce (x*y' + x'*y) (y*y')
-    (x:%y) * (x':%y')   =  reduce (x * x') (y * y')
-    negate (x:%y)       =  (-x) :% y
-    abs (x:%y)          =  abs x :% y
-    signum (x:%y)       =  signum x :% 1
-    fromInteger x       =  fromInteger x :% 1
-
-instance  (Integral a)  => Real (Ratio a)  where
-    toRational (x:%y)   =  toInteger x :% toInteger y
-
-instance  (Integral a)  => Fractional (Ratio a)  where
-    (x:%y) / (x':%y')   =  (x*y') % (y*x')
-    recip (x:%y)        =  y % x
-    fromRational (x:%y) =  fromInteger x :% fromInteger y
-
-instance  (Integral a)  => RealFrac (Ratio a)  where
-    properFraction (x:%y) = (fromIntegral q, r:%y)
-                            where (q,r) = quotRem x y
-
-instance  (Integral a)  => Enum (Ratio a)  where
-    succ x           =  x+1
-    pred x           =  x-1
-    toEnum           =  fromIntegral
-    fromEnum         =  fromInteger . truncate -- May overflow
-    enumFrom         =  numericEnumFrom                -- These numericEnumXXX functions
-    enumFromThen     =  numericEnumFromThen    -- are as defined in Prelude.hs
-    enumFromTo       =  numericEnumFromTo      -- but not exported from it!
-    enumFromThenTo   =  numericEnumFromThenTo
-
-instance  (Read a, Integral a)  => Read (Ratio a)  where
-    readsPrec p  =  readParen (p > ratPrec)
-                              (\r -> [(x%y,u) | (x,s)   <- readsPrec (ratPrec+1) r,
-                                                ("%",t) <- lex s,
-                                                (y,u)   <- readsPrec (ratPrec+1) t ])
-
-instance  (Integral a)  => Show (Ratio a)  where
-    showsPrec p (x:%y)  =  showParen (p > ratPrec)
-                               (showsPrec (ratPrec+1) x . 
-                               showString " % " . 
-                               showsPrec (ratPrec+1) y)
-
-
-
-approxRational x eps    =  simplest (x-eps) (x+eps)
-        where simplest x y | y < x      =  simplest y x
-                           | x == y     =  xr
-                           | x > 0      =  simplest' n d n' d'
-                           | y < 0      =  - simplest' (-n') d' (-n) d
-                           | otherwise  =  0 :% 1
-                                        where xr@(n:%d) = toRational x
-                                              (n':%d')  = toRational y
-
-              simplest' n d n' d'       -- assumes 0 < n%d < n'%d'
-                        | r == 0     =  q :% 1
-                        | q /= q'    =  (q+1) :% 1
-                        | otherwise  =  (q*n''+d'') :% n''
-                                     where (q,r)      =  quotRem n d
-                                           (q',r')    =  quotRem n' d'
-                                           (n'':%d'') =  simplest' d' r' d r
diff --git a/libraries/code/Time.hs b/libraries/code/Time.hs
deleted file mode 100644 (file)
index 93f0c56..0000000
+++ /dev/null
@@ -1,135 +0,0 @@
-module Time (
-        ClockTime, 
-        Month(January,February,March,April,May,June,
-              July,August,September,October,November,December),
-        Day(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday),
-       CalendarTime(CalendarTime, ctYear, ctMonth, ctDay, ctHour, ctMin,
-                    ctPicosec, ctWDay, ctYDay, ctTZName, ctTZ, ctIsDST),
-       TimeDiff(TimeDiff, tdYear, tdMonth, tdDay, 
-                tdHour, tdMin, tdSec, tdPicosec),
-        getClockTime, addToClockTime, diffClockTimes,
-        toCalendarTime, toUTCTime, toClockTime,
-        calendarTimeToString, formatCalendarTime ) where
-
-import Ix(Ix)
-import Locale(TimeLocale(..),defaultTimeLocale)
-import Char ( intToDigit )
-
-data ClockTime = ...                    -- Implementation-dependent
-instance Ord  ClockTime where ...
-instance Eq   ClockTime where ...
-
-data Month =  January   | February | March    | April
-           |  May       | June     | July     | August
-           |  September | October  | November | December
-           deriving (Eq, Ord, Enum, Bounded, Ix, Read, Show)
-
-data Day   =  Sunday | Monday  | Tuesday  | Wednesday | Thursday 
-           |  Friday | Saturday
-           deriving (Eq, Ord, Enum, Bounded, Ix, Read, Show)
-
-data CalendarTime = CalendarTime {
-                ctYear                          :: Int,
-                ctMonth                         :: Month,
-                ctDay, ctHour, ctMin, ctSec     :: Int,
-                ctPicosec                       :: Integer,
-                ctWDay                          :: Day,
-                ctYDay                          :: Int,
-                ctTZName                        :: String,
-                ctTZ                            :: Int,
-                ctIsDST                         :: Bool
-        } deriving (Eq, Ord, Read, Show)
-
-data TimeDiff = TimeDiff {
-                tdYear, tdMonth, tdDay, tdHour, tdMin, tdSec :: Int,
-                tdPicosec                                    :: Integer
-        } deriving (Eq, Ord, Read, Show)
-
-
-getClockTime            :: IO ClockTime
-getClockTime            = ...           -- Implementation-dependent
-
-addToClockTime          :: TimeDiff     -> ClockTime -> ClockTime
-addToClockTime td ct    =  ...          -- Implementation-dependent
-
-diffClockTimes          :: ClockTime    -> ClockTime -> TimeDiff
-diffClockTimes ct1 ct2  =  ...          -- Implementation-dependent
-
-toCalendarTime          :: ClockTime    -> IO CalendarTime
-toCalendarTime ct       =  ...          -- Implementation-dependent
-
-toUTCTime               :: ClockTime    -> CalendarTime
-toUTCTime ct            =  ...          -- Implementation-dependent
-
-toClockTime             :: CalendarTime -> ClockTime
-toClockTime cal         =  ...          -- Implementation-dependent
-
-calendarTimeToString    :: CalendarTime -> String
-calendarTimeToString    =  formatCalendarTime defaultTimeLocale "%c"
-
-formatCalendarTime :: TimeLocale -> String -> CalendarTime -> String
-formatCalendarTime l fmt ct@(CalendarTime year mon day hour min sec sdec 
-                                           wday yday tzname _ _) =
-        doFmt fmt
-  where doFmt ('%':c:cs) = decode c ++ doFmt cs
-        doFmt (c:cs) = c : doFmt cs
-        doFmt "" = ""
-
-        to12 :: Int -> Int
-        to12 h = let h' = h `mod` 12 in if h' == 0 then 12 else h'
-
-        decode 'A' = fst (wDays l  !! fromEnum wday)
-        decode 'a' = snd (wDays l  !! fromEnum wday)
-        decode 'B' = fst (months l !! fromEnum mon)
-        decode 'b' = snd (months l !! fromEnum mon)
-        decode 'h' = snd (months l !! fromEnum mon)
-        decode 'C' = show2 (year `quot` 100)
-        decode 'c' = doFmt (dateTimeFmt l)
-        decode 'D' = doFmt "%m/%d/%y"
-        decode 'd' = show2 day
-        decode 'e' = show2' day
-        decode 'H' = show2 hour
-        decode 'I' = show2 (to12 hour)
-        decode 'j' = show3 yday
-        decode 'k' = show2' hour
-        decode 'l' = show2' (to12 hour)
-        decode 'M' = show2 min
-        decode 'm' = show2 (fromEnum mon+1)
-        decode 'n' = "\n"
-        decode 'p' = (if hour < 12 then fst else snd) (amPm l)
-        decode 'R' = doFmt "%H:%M"
-        decode 'r' = doFmt (time12Fmt l)
-        decode 'T' = doFmt "%H:%M:%S"
-        decode 't' = "\t"
-        decode 'S' = show2 sec
-        decode 's' = ...                -- Implementation-dependent
-        decode 'U' = show2 ((yday + 7 - fromEnum wday) `div` 7)
-        decode 'u' = show (let n = fromEnum wday in 
-                           if n == 0 then 7 else n)
-        decode 'V' = 
-            let (week, days) = 
-                   (yday + 7 - if fromEnum wday > 0 then 
-                               fromEnum wday - 1 else 6) `divMod` 7
-            in  show2 (if days >= 4 then
-                          week+1 
-                       else if week == 0 then 53 else week)
-
-        decode 'W' = 
-            show2 ((yday + 7 - if fromEnum wday > 0 then 
-                               fromEnum wday - 1 else 6) `div` 7)
-        decode 'w' = show (fromEnum wday)
-        decode 'X' = doFmt (timeFmt l)
-        decode 'x' = doFmt (dateFmt l)
-        decode 'Y' = show year
-        decode 'y' = show2 (year `rem` 100)
-        decode 'Z' = tzname
-        decode '%' = "%"
-        decode c   = [c]
-
-show2, show2', show3 :: Int -> String
-show2 x = [intToDigit (x `quot` 10), intToDigit (x `rem` 10)]
-
-show2' x = if x < 10 then [ ' ', intToDigit x] else show2 x
-
-show3 x = intToDigit (x `quot` 100) : show2 (x `rem` 100)
-
diff --git a/libraries/complex.verb b/libraries/complex.verb
deleted file mode 100644 (file)
index 33343a3..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
-%**<title>The Haskell 98 Library Report: Complex Numbers</title>
-%**~header
-\section{Complex Numbers}
-\label{lib-num}
-
-\outline{
-\inputHS{headers/Complex}
-}
-
-Complex numbers are an algebraic type.
-The constructor @(:+)@\indextt{:+} forms a complex number from its
-real and imaginary rectangular components.  This constructor is
-strict: if either the real part or the imaginary part of the number is
-$\bot$, the entire number is $\bot$.  A complex number may also
-be formed from polar components of magnitude and phase by the function
-@mkPolar@\indextt{mkPolar}.  The function @cis@\indextt{polar}
-produces a complex number from an angle "t".
-Put another way, @cis@ "t" is a complex value with magnitude "1"
-and phase "t" (modulo "2\pi").
-
-The function @polar@\indextt{polar} takes a complex number and
-returns a (magnitude, phase) pair in canonical form: The magnitude is
-nonnegative, and the phase, in the range $(- \pi , \pi ]$; if the
-magnitude is zero, then so is the phase.  
-
-The functions @realPart@\indextt{realPart} and
-@imagPart@\indextt{imagPart} extract the rectangular components of a
-complex number and the functions @magnitude@\indextt{magnitude} and
-@phase@\indextt{phase} extract the polar components of a complex
-number.  The function @conjugate@\indextt{conjugate} computes the
-conjugate of a complex number in the usual way.
-
-The magnitude and sign of a complex number are defined as follows:
-\bprog
-@
-abs z            =  magnitude z :+ 0
-signum 0         =  0
-signum z@@(x:+y)   =  x/r :+ y/r  where r = magnitude z
-@
-\eprog
-That is, @abs@ $z$ is a number with the magnitude of $z$, but oriented
-in the positive real direction, whereas @signum@ $z$ has the phase of
-$z$, but unit magnitude.
-
-\subsection{Library {\tt Complex}}
-\inputHS{code/Complex}
-
-%**~footer
-
diff --git a/libraries/cputime.verb b/libraries/cputime.verb
deleted file mode 100644 (file)
index 23c14db..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-%**<title>The Haskell 98 Library Report: CPU Time</title>
-%**~header
-\section{CPU Time}
-\label{cputime}
-\index{CPU time}
-\index{execution time}
-
-\outline {
-\inputHS{headers/CPUTime}
-}
-
-Computation @getCPUTime@ returns the number of picoseconds of CPU time
-used by the current program.  The precision of this result is given by
-@cpuTimePrecision@.  This is the smallest measurable difference in CPU
-time that the implementation can record, and is given as an integral
-number of picoseconds.
-
-%**~footer
-
diff --git a/libraries/directory.verb b/libraries/directory.verb
deleted file mode 100644 (file)
index 6de782c..0000000
+++ /dev/null
@@ -1,165 +0,0 @@
-%**<title>The Haskell 98 Library Report: Directory functions</title>
-%**~header
-
-%% Other useful functions from SML 96 include modification time
-%% and path-testing (is this a full path/real path).
-
-\section{Directory Functions}
-\index{directories}
-\index{the file system}
-
-\outline{
-\inputHS{headers/Directory}
-}
-\indextt{createDirectory}\indextt{removeDirectory}\indextt{removeFile}
-\indextt{renameDirectory}\indextt{renameFile}
-\indextt{getDirectoryContents}\indextt{getCurrentDirectory}
-\indextt{setCurrentDirectory}
-
-These functions operate on directories in the file system.  
-
-Any @Directory@ operation could raise an @isIllegalOperation@, as
-described in Section~\ref{IOError}; all other permissible errors are
-described below.  Note that, in particular, if an implementation does
-not support an operation it should raise an @isIllegalOperation@.
-A directory contains a series of entries, each of which is a named
-reference to a file system object (file, directory etc.).  Some
-entries may be hidden, inaccessible, or have some administrative
-function (for instance, ``.'' or ``..'' under POSIX), but all such
-entries are considered to form part of the directory contents.
-Entries in sub-directories are not, however, considered to form part
-of the directory contents.  Although there may be
-file system objects other than files and directories, this library
-does not distinguish between physical files and other non-directory
-objects.  All such objects should therefore be treated as if they are files.
-
-Each file system object is referenced by a {\it path}\index{path}.  There is
-normally at least one absolute path to each file system object.  In
-some operating systems, it may also be possible to have paths which
-are relative to the current directory.
-
-Computation @createDirectory@~"dir" creates a new directory "dir" which is
-initially empty, or as near to empty as the operating system allows.
-\index{making directories}
-
-{\em Error~reporting}.
-The @createDirectory@ computation may fail with:
-@isPermissionError@ if the user is not permitted to create the directory;
-@isAlreadyExistsError@ if the directory already exists; or @isDoesNotExistError@ if
-the new directory's parent does not exist.
-
-Computation @removeDirectory@~"dir" removes an existing directory
-"dir"\index{deleting directories}\index{removing directories}.  The
-implementation may specify additional constraints which must be
-satisfied before a directory can be removed (for instance, the directory has to
-be empty, or may not be in use by other processes).  It is not legal
-for an implementation to partially remove a directory unless the
-entire directory is removed. A conformant implementation need not
-support directory removal in all situations (for instance, removal of the root
-directory).
-
-Computation @removeFile@~"file" removes the directory entry for an existing
-file "file", where "file" is not itself a directory\index{deleting
-files}\index{removing files}. The implementation may specify additional
-constraints which must be satisfied before a file can be removed (for instance, the
-file may not be in use by other processes).
-
-{\em Error~reporting}.
-The @removeDirectory@ and @removeFile@ computations may fail with:
-@isPermissionError@ if the user is not permitted to remove the file/directory;
-or @isDoesNotExistError@ if the file/directory does not exist.
-
-Computation @renameDirectory@~"old"~"new" changes the name of an existing
-directory from "old" to "new"\index{renaming directories}\index{moving
-directories}.  If the "new" directory already exists, it is atomically
-replaced by the "old" directory.  If the "new" directory is neither
-the "old" directory nor an alias of the "old" directory, it is removed
-as if by @removeDirectory@.  A conformant implementation need not
-support renaming directories in all situations (for instance, renaming to an
-existing directory, or across different physical devices), but the
-constraints must be documented.
-
-Computation @renameFile@~"old"~"new" changes the name of an existing file
-system object from "old" to "new"\index{renaming files}\index{moving files}.
-If the "new" object already exists, it is atomically replaced by the "old"
-object.  Neither path may refer to an existing directory.  A conformant
-implementation need not support renaming files in all situations
-(for instance, renaming across different physical devices), but the constraints must be
-documented.
-
-{\em Error~reporting}.
-The @renameDirectory@ and @renameFile@ computations may fail with:
-@isPermissionError@ if the user is not permitted to rename the file/directory,
-or if either argument to @renameFile@ is a directory;
-or @isDoesNotExistError@ if the file/directory does not exist.
-
-Computation @getDirectoryContents@~"dir" returns a list of {\em all} entries
-in "dir"\index{reading a directory}.
-Each entry in the returned list is named relative to the directory "dir", not as an absolute path.
-
-If the operating system has a notion of current directories,
-@getCurrentDirectory@ returns an absolute path to the
-current directory of the calling process\index{current directory}.
-
-{\em Error~reporting}.
-The @getDirectoryContents@ and @getCurrentDirectory@ computations may fail with:
-@isPermissionError@ if the user is not permitted to access the directory;
-or @isDoesNotExistError@ if the directory does not exist.
-
-If the operating system has a notion of current directories,
-@setCurrentDirectory@~"dir" changes the current directory of the
-calling process to "dir"\index{changing the directory}\index{setting the directory}.
-
-{\em Error~reporting}.
-@setCurrentDirectory@ may fail with:
-@isPermissionError@ if the user is not permitted to change directory
-to that specified;
-or @isDoesNotExistError@ if the directory does not exist.
-
-The @Permissions@ type is used to record whether certain operations are
-permissible on a file/directory.  @getPermissions@ and
-@setPermissions@ get and set these permissions, respectively.  
-Permissions apply both to files and directories.  For
-directories, the @executable@ field will be @False@, and for files the
-@searchable@ field will be @False@.  Note that directories may be
-searchable without being readable, if permission has been given to use
-them as part of a path, but not to examine the directory contents.
-
-Note that to change
-some, but not all permissions, a construct on the following lines must
-be used.  
-\bprog
-@
-makeReadable f = do
-                   p <- getPermissions f
-                   setPermissions f (p {readable = True})
-@
-\eprog
-The operation @doesDirectoryExist@ returns @True@ if the argument file
-exists and is a directory, and @False@ otherwise. The operation @doesFileExist@ returns @True@
-if the argument file exists and is not a directory, and @False@ otherwise.
-
-The @getModificationTime@ operation returns the
-clock time at which the file/directory was last modified.
-
-{\em Error~reporting}.
-@get(set)Permissions@,
-@doesFile(Directory)Exist@,
-and @getModificationTime@
-may fail with:
-@isPermissionError@ if the user is not permitted to access
-the appropriate information;
-or @isDoesNotExistError@ if the file/directory does not exist.
-The @setPermissions@
-computation may also fail with:
-@isPermissionError@ if the user is not permitted to change
-the permission for the specified file or directory;
-or @isDoesNotExistError@ if the file/directory does not exist.
-% Duplicates the first case above, and would require
-% extensive consistency checking throughout. KH
-% The @doesFileExist@ and @doesDirectoryExist@ computations
-% may also fail with @isPermissionError@ if some part of the path
-% to the file/directory cannot be searched.
-
-%**~footer
-
diff --git a/libraries/h98-libs.gif b/libraries/h98-libs.gif
deleted file mode 100644 (file)
index e997197..0000000
Binary files a/libraries/h98-libs.gif and /dev/null differ
diff --git a/libraries/h98-libs.ppt b/libraries/h98-libs.ppt
deleted file mode 100644 (file)
index 985730e..0000000
Binary files a/libraries/h98-libs.ppt and /dev/null differ
diff --git a/libraries/headers/Array.hs b/libraries/headers/Array.hs
deleted file mode 100644 (file)
index 2bb99d0..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-module  Array ( 
-        module Ix,  -- export all of Ix for convenience
-        Array, array, listArray, (!), bounds, indices, elems, assocs, 
-        accumArray, (//), accum, ixmap ) where
-
-import Ix
-
-infixl 9  !, //
-
-data  (Ix a)    => Array a b = ...     -- Abstract
-
-array           :: (Ix a) => (a,a) -> [(a,b)] -> Array a b
-listArray       :: (Ix a) => (a,a) -> [b] -> Array a b
-(!)             :: (Ix a) => Array a b -> a -> b
-bounds          :: (Ix a) => Array a b -> (a,a)
-indices         :: (Ix a) => Array a b -> [a]
-elems           :: (Ix a) => Array a b -> [b]
-assocs          :: (Ix a) => Array a b -> [(a,b)]
-accumArray      :: (Ix a) => (b -> c -> b) -> b -> (a,a) -> [(a,c)]
-                             -> Array a b
-(//)            :: (Ix a) => Array a b -> [(a,b)] -> Array a b
-accum           :: (Ix a) => (b -> c -> b) -> Array a b -> [(a,c)]
-                             -> Array a b
-ixmap           :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c
-                             -> Array a c
-
-instance                            Functor (Array a) where ...
-instance  (Ix a, Eq b)           => Eq   (Array a b)  where ...
-instance  (Ix a, Ord b)          => Ord  (Array a b)  where ...
-instance  (Ix a, Show a, Show b) => Show (Array a b)  where ...
-instance  (Ix a, Read a, Read b) => Read (Array a b)  where ...
-
diff --git a/libraries/headers/CPUTime.hs b/libraries/headers/CPUTime.hs
deleted file mode 100644 (file)
index f03437a..0000000
+++ /dev/null
@@ -1,4 +0,0 @@
-module CPUTime ( getCPUTime, cpuTimePrecision ) where
-
-getCPUTime        :: IO Integer
-cpuTimePrecision  :: Integer
diff --git a/libraries/headers/Char.hs b/libraries/headers/Char.hs
deleted file mode 100644 (file)
index 3722821..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-module Char ( 
-    isAscii, isLatin1, isControl, isPrint, isSpace, isUpper, isLower, 
-    isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum, 
-    digitToInt, intToDigit,
-    toUpper, toLower,
-    ord, chr,
-    readLitChar, showLitChar, lexLitChar,
-
-       -- ...and what the Prelude exports
-    Char, String
-    ) where
-
-isAscii, isLatin1, isControl, isPrint, isSpace, isUpper, isLower, 
- isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum :: Char -> Bool
-
-toUpper, toLower        :: Char -> Char
-
-digitToInt :: Char -> Int
-intToDigit :: Int -> Char
-
-ord        :: Char -> Int
-chr        :: Int  -> Char
-
-lexLitChar  :: ReadS String
-readLitChar :: ReadS Char
-showLitChar :: Char -> ShowS
diff --git a/libraries/headers/Complex.hs b/libraries/headers/Complex.hs
deleted file mode 100644 (file)
index d78b78a..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-module  Complex ( 
-    Complex((:+)), realPart, imagPart, conjugate, 
-    mkPolar, cis, polar, magnitude, phase ) where
-
-infix  6  :+
-
-data  (RealFloat a)     => Complex a = !a :+ !a
-
-realPart, imagPart      :: (RealFloat a) => Complex a -> a
-conjugate              :: (RealFloat a) => Complex a -> Complex a
-mkPolar                        :: (RealFloat a) => a -> a -> Complex a
-cis                    :: (RealFloat a) => a -> Complex a
-polar                  :: (RealFloat a) => Complex a -> (a,a)
-magnitude, phase        :: (RealFloat a) => Complex a -> a
-
-instance  (RealFloat a) => Eq         (Complex a)  where ...
-instance  (RealFloat a) => Read       (Complex a)  where ...
-instance  (RealFloat a) => Show       (Complex a)  where ...
-instance  (RealFloat a) => Num        (Complex a)  where ...
-instance  (RealFloat a) => Fractional (Complex a)  where ...
-instance  (RealFloat a) => Floating   (Complex a)  where ...
diff --git a/libraries/headers/Directory.hs b/libraries/headers/Directory.hs
deleted file mode 100644 (file)
index e8315a3..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-module Directory ( 
-    Permissions( Permissions, readable, writable, executable, searchable ), 
-    createDirectory, removeDirectory, removeFile, 
-    renameDirectory, renameFile, getDirectoryContents,
-    getCurrentDirectory, setCurrentDirectory,
-    doesFileExist, doesDirectoryExist,
-    getPermissions, setPermissions,
-    getModificationTime ) where
-
-import Time ( ClockTime )
-
-data Permissions = Permissions {
-                       readable,   writable,
-                       executable, searchable :: Bool
-                  }
-
-instance Eq   Permissions where ...
-instance Ord  Permissions where ...
-instance Read Permissions where ...
-instance Show Permissions where ...
-
-
-
-createDirectory        :: FilePath -> IO ()
-removeDirectory        :: FilePath -> IO ()
-removeFile             :: FilePath -> IO ()
-renameDirectory        :: FilePath -> FilePath -> IO ()
-renameFile             :: FilePath -> FilePath -> IO ()
-
-getDirectoryContents   :: FilePath -> IO [FilePath]
-getCurrentDirectory    :: IO FilePath
-setCurrentDirectory    :: FilePath -> IO ()
-
-doesFileExist          :: FilePath -> IO Bool
-doesDirectoryExist     :: FilePath -> IO Bool
-
-getPermissions         :: FilePath -> IO Permissions
-setPermissions         :: FilePath -> Permissions -> IO ()
-
-getModificationTime    :: FilePath -> IO ClockTime
-
diff --git a/libraries/headers/IO.hs b/libraries/headers/IO.hs
deleted file mode 100644 (file)
index 2e2b1d8..0000000
+++ /dev/null
@@ -1,47 +0,0 @@
-module IO (
-    Handle, HandlePosn,
-    IOMode(ReadMode,WriteMode,AppendMode,ReadWriteMode),
-    BufferMode(NoBuffering,LineBuffering,BlockBuffering),
-    SeekMode(AbsoluteSeek,RelativeSeek,SeekFromEnd),
-    stdin, stdout, stderr, 
-    openFile, hClose, hFileSize, hIsEOF, isEOF,
-    hSetBuffering, hGetBuffering, hFlush, 
-    hGetPosn, hSetPosn, hSeek, 
-    hWaitForInput, hReady, hGetChar, hGetLine, hLookAhead, hGetContents, 
-    hPutChar, hPutStr, hPutStrLn, hPrint,
-    hIsOpen, hIsClosed, hIsReadable, hIsWritable, hIsSeekable,
-    isAlreadyExistsError, isDoesNotExistError, isAlreadyInUseError, 
-    isFullError, isEOFError,
-    isIllegalOperation, isPermissionError, isUserError, 
-    ioeGetErrorString, ioeGetHandle, ioeGetFileName,
-    try, bracket, bracket_,
-
-    -- ...and what the Prelude exports
-    IO, FilePath, IOError, ioError, userError, catch, interact,
-    putChar, putStr, putStrLn, print, getChar, getLine, getContents,
-    readFile, writeFile, appendFile, readIO, readLn
-    ) where
-
-import Ix(Ix)
-
-data Handle = ...                      -- implementation-dependent
-instance Eq Handle where ...
-instance Show Handle where ..           -- implementation-dependent
-
-data HandlePosn = ...                  -- implementation-dependent
-instance Eq HandlePosn where ...
-instance Show HandlePosn where ---      -- implementation-dependent
-
-
-data IOMode      =  ReadMode | WriteMode | AppendMode | ReadWriteMode
-                    deriving (Eq, Ord, Ix, Bounded, Enum, Read, Show)
-data BufferMode  =  NoBuffering | LineBuffering 
-                 |  BlockBuffering (Maybe Int)
-                    deriving (Eq, Ord, Read, Show)
-data SeekMode    =  AbsoluteSeek | RelativeSeek | SeekFromEnd
-                    deriving (Eq, Ord, Ix, Bounded, Enum, Read, Show)
-
-stdin, stdout, stderr :: Handle
-
-openFile              :: FilePath -> IOMode -> IO Handle
-hClose                :: Handle -> IO ()
diff --git a/libraries/headers/IO1.hs b/libraries/headers/IO1.hs
deleted file mode 100644 (file)
index 413affd..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-hFileSize             :: Handle -> IO Integer
-hIsEOF                :: Handle -> IO Bool
-isEOF                 :: IO Bool
-isEOF                 =  hIsEOF stdin
-
-hSetBuffering         :: Handle  -> BufferMode -> IO ()
-hGetBuffering         :: Handle  -> IO BufferMode
-hFlush                :: Handle -> IO () 
-hGetPosn              :: Handle -> IO HandlePosn
-hSetPosn              :: HandlePosn -> IO () 
-hSeek                 :: Handle -> SeekMode -> Integer -> IO () 
-
-hWaitForInput        :: Handle -> Int -> IO Bool
-hReady                :: Handle -> IO Bool 
-hReady h             =  hWaitForInput h 0
-hGetChar              :: Handle -> IO Char
-hGetLine              :: Handle -> IO String
-hLookAhead            :: Handle -> IO Char
-hGetContents          :: Handle -> IO String
-hPutChar              :: Handle -> Char -> IO ()
-hPutStr               :: Handle -> String -> IO ()
-hPutStrLn             :: Handle -> String -> IO ()
-hPrint                :: Show a => Handle -> a -> IO ()
-
-hIsOpen               :: Handle -> IO Bool
-hIsClosed             :: Handle -> IO Bool
-hIsReadable           :: Handle -> IO Bool
-hIsWritable           :: Handle -> IO Bool
-hIsSeekable           :: Handle -> IO Bool
-
-isAlreadyExistsError  :: IOError -> Bool
-isDoesNotExistError   :: IOError -> Bool
-isAlreadyInUseError   :: IOError -> Bool
-isFullError           :: IOError -> Bool
-isEOFError            :: IOError -> Bool
-isIllegalOperation    :: IOError -> Bool
-isPermissionError     :: IOError -> Bool
-isUserError           :: IOError -> Bool
-
-ioeGetErrorString     :: IOError -> String
-ioeGetHandle          :: IOError -> Maybe Handle
-ioeGetFileName        :: IOError -> Maybe FilePath
-
-try                   :: IO a -> IO (Either IOError a)
-bracket               :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
-bracket_              :: IO a -> (a -> IO b) -> IO c -> IO c
diff --git a/libraries/headers/Ix.hs b/libraries/headers/Ix.hs
deleted file mode 100644 (file)
index ac5199d..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-module Ix ( Ix(range, index, inRange, rangeSize) ) where
-
-class  Ord a => Ix a  where
-    range       :: (a,a) -> [a]
-    index       :: (a,a) -> a -> Int
-    inRange     :: (a,a) -> a -> Bool
-    rangeSize   :: (a,a) -> Int
-
-instance                   Ix Char      where ...
-instance                   Ix Int       where ...
-instance                   Ix Integer   where ...
-instance  (Ix a, Ix b)  => Ix (a,b)     where ...
--- et cetera
-instance                   Ix Bool      where ...
-instance                   Ix Ordering  where ...
diff --git a/libraries/headers/List.hs b/libraries/headers/List.hs
deleted file mode 100644 (file)
index df18dd3..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-module List ( 
-    elemIndex, elemIndices,
-    find, findIndex, findIndices,
-    nub, nubBy, delete, deleteBy, (\\), deleteFirstsBy,
-    union, unionBy, intersect, intersectBy,
-    intersperse, transpose, partition, group, groupBy,
-    inits, tails, isPrefixOf, isSuffixOf,
-    mapAccumL, mapAccumR,
-    sort, sortBy, insert, insertBy, maximumBy, minimumBy,
-    genericLength, genericTake, genericDrop,
-    genericSplitAt, genericIndex, genericReplicate,
-    zip4, zip5, zip6, zip7,
-    zipWith4, zipWith5, zipWith6, zipWith7,
-    unzip4, unzip5, unzip6, unzip7, unfoldr,
-
-    -- ...and what the Prelude exports
-    -- []((:), []),    -- This is built-in syntax
-    map, (++), concat, filter,
-    head, last, tail, init, null, length, (!!),
-    foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,
-    iterate, repeat, replicate, cycle,
-    take, drop, splitAt, takeWhile, dropWhile, span, break,
-    lines, words, unlines, unwords, reverse, and, or,
-    any, all, elem, notElem, lookup,
-    sum, product, maximum, minimum, concatMap, 
-    zip, zip3, zipWith, zipWith3, unzip, unzip3
-    ) where
-
-infix 5 \\
-
-elemIndex           :: Eq a => a -> [a] -> Maybe Int
-elemIndices         :: Eq a => a -> [a] -> [Int]
-find                :: (a -> Bool) -> [a] -> Maybe a
-findIndex           :: (a -> Bool) -> [a] -> Maybe Int
-findIndices         :: (a -> Bool) -> [a] -> [Int]
-nub                 :: Eq a => [a] -> [a]
-nubBy               :: (a -> a -> Bool) -> [a] -> [a]
-delete              :: Eq a => a -> [a] -> [a]
-deleteBy            :: (a -> a -> Bool) -> a -> [a] -> [a]
-(\\)                :: Eq a => [a] -> [a] -> [a]
-deleteFirstsBy      :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-union               :: Eq a => [a] -> [a] -> [a]
-unionBy             :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-
diff --git a/libraries/headers/List1.hs b/libraries/headers/List1.hs
deleted file mode 100644 (file)
index 9e55b0d..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-intersect           :: Eq a => [a] -> [a] -> [a]
-intersectBy         :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-intersperse         :: a -> [a] -> [a]
-transpose           :: [[a]] -> [[a]]
-partition           :: (a -> Bool) -> [a] -> ([a],[a])
-group               :: Eq a => [a] -> [[a]]
-groupBy             :: (a -> a -> Bool) -> [a] -> [[a]]
-inits               :: [a] -> [[a]] 
-tails               :: [a] -> [[a]] 
-isPrefixOf          :: Eq a => [a] -> [a] -> Bool
-isSuffixOf          :: Eq a => [a] -> [a] -> Bool
-mapAccumL           :: (a -> b -> (a, c)) -> a -> [b] -> (a, [c])
-mapAccumR           :: (a -> b -> (a, c)) -> a -> [b] -> (a, [c])
-unfoldr                    :: (b -> Maybe (a,b)) -> b -> [a]
-sort                :: Ord a => [a] -> [a]
-sortBy              :: (a -> a -> Ordering) -> [a] -> [a]
-insert             :: Ord a => a -> [a] -> [a]
-insertBy            :: (a -> a -> Ordering) -> a -> [a] -> [a]
-maximumBy           :: (a -> a -> Ordering) -> [a] -> a
-minimumBy           :: (a -> a -> Ordering) -> [a] -> a
-genericLength       :: Integral a => [b] -> a
-genericTake        :: Integral a => a -> [b] -> [b]
-genericDrop        :: Integral a => a -> [b] -> [b]
-genericSplitAt     :: Integral a => a -> [b] -> ([b],[b])
-genericIndex       :: Integral a => [b] -> a -> b
-genericReplicate    :: Integral a => a -> b -> [b]
-
-zip4                :: [a] -> [b] -> [c] -> [d] -> [(a,b,c,d)]
-zip5                :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a,b,c,d,e)]
-zip6                :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] 
-                          -> [(a,b,c,d,e,f)]
-zip7                :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
-                          -> [(a,b,c,d,e,f,g)]
-zipWith4            :: (a->b->c->d->e) -> [a]->[b]->[c]->[d]->[e]
-zipWith5            :: (a->b->c->d->e->f) -> 
-                       [a]->[b]->[c]->[d]->[e]->[f]
-zipWith6            :: (a->b->c->d->e->f->g) ->
-                       [a]->[b]->[c]->[d]->[e]->[f]->[g]
-zipWith7            :: (a->b->c->d->e->f->g->h) ->
-                       [a]->[b]->[c]->[d]->[e]->[f]->[g]->[h]
-unzip4              :: [(a,b,c,d)] -> ([a],[b],[c],[d])
-unzip5              :: [(a,b,c,d,e)] -> ([a],[b],[c],[d],[e])
-unzip6              :: [(a,b,c,d,e,f)] -> ([a],[b],[c],[d],[e],[f])
-unzip7              :: [(a,b,c,d,e,f,g)] -> ([a],[b],[c],[d],[e],[f],[g])
diff --git a/libraries/headers/Locale.hs b/libraries/headers/Locale.hs
deleted file mode 100644 (file)
index a9a57d1..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-module Locale(TimeLocale(..), defaultTimeLocale) where
-
-data TimeLocale = TimeLocale {
-        wDays  :: [(String, String)],   -- full and abbreviated week days
-        months :: [(String, String)],   -- full and abbreviated months
-        amPm   :: (String, String),     -- AM/PM symbols
-        dateTimeFmt, dateFmt,           -- formatting strings
-          timeFmt, time12Fmt :: String     
-        } deriving (Eq, Ord, Show)
-
-defaultTimeLocale :: TimeLocale 
diff --git a/libraries/headers/Maybe.hs b/libraries/headers/Maybe.hs
deleted file mode 100644 (file)
index e536efa..0000000
+++ /dev/null
@@ -1,17 +0,0 @@
-module Maybe(
-    isJust, isNothing,
-    fromJust, fromMaybe, listToMaybe, maybeToList,
-    catMaybes, mapMaybe,
-
-    -- ...and what the Prelude exports
-    Maybe(Nothing, Just),
-    maybe
-  ) where
-
-isJust, isNothing    :: Maybe a -> Bool
-fromJust             :: Maybe a -> a
-fromMaybe            :: a -> Maybe a -> a
-listToMaybe          :: [a] -> Maybe a
-maybeToList          :: Maybe a -> [a]
-catMaybes            :: [Maybe a] -> [a]
-mapMaybe             :: (a -> Maybe b) -> [a] -> [b]
diff --git a/libraries/headers/Monad.hs b/libraries/headers/Monad.hs
deleted file mode 100644 (file)
index 561e29f..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-module Monad (
-    MonadPlus(mzero, mplus),
-    join, guard, when, unless, ap,
-    msum,
-    filterM, mapAndUnzipM, zipWithM, zipWithM_, foldM, 
-    liftM, liftM2, liftM3, liftM4, liftM5,
-
-    -- ...and what the Prelude exports
-    Monad((>>=), (>>), return, fail),
-    Functor(fmap),
-    mapM, mapM_, sequence, sequence_, (=<<), 
-    ) where
-
-class  Monad m => MonadPlus m  where
-    mzero  :: m a
-    mplus  :: m a -> m a -> m a
-
-join             :: Monad m => m (m a) -> m a
-guard            :: MonadPlus m => Bool -> m ()
-when             :: Monad m => Bool -> m () -> m ()
-unless           :: Monad m => Bool -> m () -> m ()
-ap              :: Monad m => m (a -> b) -> m a -> m b
-
-mapAndUnzipM     :: Monad m => (a -> m (b,c)) -> [a] -> m ([b], [c])
-zipWithM         :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
-zipWithM_        :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
-foldM            :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
-filterM                 :: Monad m => (a -> m Bool) -> [a] -> m [a]
-
-msum            :: MonadPlus m => [m a] -> m a
-
-liftM            :: Monad m => (a -> b) -> (m a -> m b)
-liftM2           :: Monad m => (a -> b -> c) -> (m a -> m b -> m c)
-liftM3           :: Monad m => (a -> b -> c -> d) ->
-                               (m a -> m b -> m c -> m d)
-liftM4           :: Monad m => (a -> b -> c -> d -> e) ->
-                               (m a -> m b -> m c -> m d -> m e)
-liftM5           :: Monad m => (a -> b -> c -> d -> e -> f) ->
-                               (m a -> m b -> m c -> m d -> m e -> m f)
-
diff --git a/libraries/headers/Numeric.hs b/libraries/headers/Numeric.hs
deleted file mode 100644 (file)
index 04e6710..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-module Numeric(fromRat,
-               showSigned, showIntAtBase,
-               showInt, showOct, showHex,
-               readSigned, readInt,
-               readDec, readOct, readHex, 
-               floatToDigits,
-               showEFloat, showFFloat, showGFloat, showFloat, 
-               readFloat, lexDigits) where
-
-fromRat        :: (RealFloat a) => Rational -> a
-
-showSigned     :: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
-showIntAtBase  :: Integral a => a -> (Int -> Char) -> a -> ShowS
-showInt        :: Integral a => a -> ShowS
-showOct        :: Integral a => a -> ShowS
-showHex        :: Integral a => a -> ShowS
-
-readSigned     :: (Real a) => ReadS a -> ReadS a
-readInt        :: (Integral a) =>
-                    a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
-readDec        :: (Integral a) => ReadS a
-readOct        :: (Integral a) => ReadS a
-readHex        :: (Integral a) => ReadS a
-
-showEFloat     :: (RealFloat a) => Maybe Int -> a -> ShowS
-showFFloat     :: (RealFloat a) => Maybe Int -> a -> ShowS
-showGFloat     :: (RealFloat a) => Maybe Int -> a -> ShowS
-showFloat      :: (RealFloat a) => a -> ShowS
-
-floatToDigits  :: (RealFloat a) => Integer -> a -> ([Int], Int)
-
-readFloat      :: (RealFrac a) => ReadS a
-lexDigits      :: ReadS String 
diff --git a/libraries/headers/Random.hs b/libraries/headers/Random.hs
deleted file mode 100644 (file)
index 76f587a..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-module Random (
-       RandomGen(next, split, genRange),
-       StdGen, mkStdGen,
-       Random( random,   randomR, 
-               randoms,  randomRs,
-               randomIO, randomRIO ),
-       getStdRandom, getStdGen, setStdGen, newStdGen
-  ) where
-       
----------------- The RandomGen class ------------------------
-
-class RandomGen g where
-  genRange :: g -> (Int, Int)
-  next     :: g -> (Int, g)
-  split    :: g -> (g, g)
-
----------------- A standard instance of RandomGen -----------
-data StdGen = ...      -- Abstract
-
-instance RandomGen StdGen where ...
-instance Read     StdGen where ...
-instance Show     StdGen where ...
-
-mkStdGen :: Int -> StdGen
-
----------------- The Random class ---------------------------
-class Random a where
-   randomR :: RandomGen g => (a, a) -> g -> (a, g)
-   random  :: RandomGen g => g -> (a, g)
-
-   randomRs :: RandomGen g => (a, a) -> g -> [a]
-   randoms  :: RandomGen g => g -> [a]
-
-   randomRIO :: (a,a) -> IO a
-   randomIO  :: IO a
-
-instance Random Int     where ...
-instance Random Integer where ...
-instance Random Float   where ...
-instance Random Double  where ...
-instance Random Bool    where ...
-instance Random Char    where ...
-
----------------- The global random generator ----------------
-newStdGen    :: IO StdGen
-setStdGen    :: StdGen -> IO ()
-getStdGen    :: IO StdGen      
-getStdRandom :: (StdGen -> (a, StdGen)) -> IO a
-
-
diff --git a/libraries/headers/Ratio.hs b/libraries/headers/Ratio.hs
deleted file mode 100644 (file)
index 13755cf..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-module Ratio (
-    Ratio, Rational, (%), numerator, denominator, approxRational ) where
-
-infixl 7  %
-data  (Integral a)     => Ratio a = ...
-type  Rational         =  Ratio Integer
-(%)                    :: (Integral a) => a -> a -> Ratio a
-numerator, denominator :: (Integral a) => Ratio a -> a
-approxRational         :: (RealFrac a) => a -> a -> Rational
-instance  (Integral a)  => Eq         (Ratio a)  where ...
-instance  (Integral a) => Ord        (Ratio a)  where ...
-instance  (Integral a) => Num        (Ratio a)  where ...
-instance  (Integral a) => Real       (Ratio a)  where ...
-instance  (Integral a) => Fractional (Ratio a)  where ...
-instance  (Integral a) => RealFrac   (Ratio a)  where ...
-instance  (Integral a) => Enum       (Ratio a)  where ...
-instance  (Read a,Integral a) => Read (Ratio a)  where ...
-instance  (Integral a)  => Show       (Ratio a)  where ...
-
diff --git a/libraries/headers/System.hs b/libraries/headers/System.hs
deleted file mode 100644 (file)
index e534519..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-module System ( 
-    ExitCode(ExitSuccess,ExitFailure),
-    getArgs, getProgName, getEnv, system, exitWith, exitFailure
-  ) where
-
-data ExitCode = ExitSuccess | ExitFailure Int 
-                deriving (Eq, Ord, Read, Show)
-
-getArgs                :: IO [String]
-getProgName            :: IO String
-getEnv                 :: String -> IO String
-system                 :: String -> IO ExitCode
-exitWith               :: ExitCode -> IO a
-exitFailure            :: IO a
diff --git a/libraries/headers/Time.hs b/libraries/headers/Time.hs
deleted file mode 100644 (file)
index 971c0a3..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-module Time (
-       ClockTime, 
-       Month(January,February,March,April,May,June,
-             July,August,September,October,November,December),
-       Day(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday),
-       CalendarTime(CalendarTime, ctYear, ctMonth, ctDay, ctHour, ctMin,
-                    ctPicosec, ctWDay, ctYDay, ctTZName, ctTZ, ctIsDST),
-       TimeDiff(TimeDiff, tdYear, tdMonth, tdDay, tdHour,
-                tdMin, tdSec, tdPicosec),
-       getClockTime, addToClockTime, diffClockTimes,
-        toCalendarTime, toUTCTime, toClockTime,
-        calendarTimeToString, formatCalendarTime ) where
-
-import Ix(Ix)
-
-data ClockTime = ...                   -- Implementation-dependent
-instance Ord  ClockTime where ...
-instance Eq   ClockTime where ...
-
-data Month =  January   | February | March    | April
-           |  May       | June     | July     | August
-           |  September | October  | November | December
-           deriving (Eq, Ord, Enum, Bounded, Ix, Read, Show)
-
-data Day   =  Sunday | Monday  | Tuesday  | Wednesday | Thursday 
-           |  Friday | Saturday
-           deriving (Eq, Ord, Enum, Bounded, Ix, Read, Show)
-
-data CalendarTime = CalendarTime {
-               ctYear                          :: Int,
-               ctMonth                         :: Month,
-               ctDay, ctHour, ctMin, ctSec     :: Int,
-               ctPicosec                       :: Integer,
-               ctWDay                          :: Day,
-               ctYDay                          :: Int,
-               ctTZName                        :: String,
-               ctTZ                            :: Int,
-               ctIsDST                         :: Bool
-       } deriving (Eq, Ord, Read, Show)
-
-data TimeDiff = TimeDiff {
-               tdYear, tdMonth, tdDay, tdHour, tdMin, tdSec :: Int,
-               tdPicosec                                    :: Integer
-       } deriving (Eq, Ord, Read, Show)
diff --git a/libraries/headers/Time1.hs b/libraries/headers/Time1.hs
deleted file mode 100644 (file)
index 1ce79d5..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
--- Functions on times
-getClockTime         :: IO ClockTime
-                    
-addToClockTime       :: TimeDiff  -> ClockTime -> ClockTime
-diffClockTimes       :: ClockTime -> ClockTime -> TimeDiff
-                    
-toCalendarTime       :: ClockTime    -> IO CalendarTime
-toUTCTime            :: ClockTime    -> CalendarTime
-toClockTime          :: CalendarTime -> ClockTime
-calendarTimeToString :: CalendarTime -> String
-formatCalendarTime   :: TimeLocale -> String -> CalendarTime -> String
diff --git a/libraries/html.config b/libraries/html.config
deleted file mode 100644 (file)
index 668b0d6..0000000
+++ /dev/null
@@ -1,43 +0,0 @@
-aux=library.aux
-htmldir=haskell98-library-html/
-refs=librefs
-files=introduction.verb
-files=ratio.verb
-files=complex.verb
-files=numeric.verb
-files=ix.verb
-files=array.verb
-files=list.verb
-files=maybe.verb
-files=char.verb
-files=monad.verb
-files=io.verb
-files=directory.verb
-files=system.verb
-files=time.verb
-files=locale.verb
-files=cputime.verb
-files=random.verb
-#files=bit.verb
-#files=nat.verb
-#files=signed.verb
-
-
-
-index=haskell98-library-html/libindex.html
-style=article
-
-~top=<a href="index.html">top</a>
-~style=<body bgcolor="#ffffff">
-~id=<i>The Haskell 98 Library Report</i><br>
-~back=<a href="~prev.html">back</a>
-~nxt=<a href="~next.html">next</a>
-~contents=<a href="libindex.html">contents</a>
-~foot=<br><font size=2>Sept 2002</font>
-~footer=<hr>~id~top | ~back | ~nxt | ~contents ~foot
-~sfooter=<hr>~id~top | back | ~nxt | ~contents ~foot
-~efooter=<hr>~id~top | ~back | next | ~contents ~foot
-~header=~style ~id ~top | ~back | ~nxt | ~contents <br><hr>
-~sheader=~style ~id ~top | back | ~nxt | ~contents <br><hr>
-~eheader=~style ~id ~top | ~back | next | ~contents <br><hr>
-~indexHeader=<title>Haskell 98 Library Index</title>~style ~id~top <br><h3>Haskell 98 Library Report: Index</h3>
diff --git a/libraries/index-intro.verb b/libraries/index-intro.verb
deleted file mode 100644 (file)
index 902ccc4..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-Code entities are shown in @typewriter@ font.  Ordinary index entries
-are shown in a roman font.
-
diff --git a/libraries/index.html b/libraries/index.html
deleted file mode 100644 (file)
index 053ca7f..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-<title> The Haskell 98 Library Report </title>
-
-<body bgcolor="#ffffff">
-
-<div align=center>
-
-<img src="h98-libs.gif" alt="Haskell 98 Libraries">
-
-<h3 align="center">Standard Libraries for Haskell 98</h3>
-<h3 align="center">Revised: Sept 2002</h3>
-</div>
-<hr>
-<h3>Table of Contents</h3>
-<ul>
-<li><a href="libindex.html">Full Table of Contents</a>
-<li><a href="introduction.html">Introduction</a>
-<li><a href="ratio.html">Ratio</a>
-<li><a href="complex.html">Complex</a>
-<li><a href="numeric.html">Numeric</a>
-<li><a href="ix.html">Ix</a>
-<li><a href="array.html">Array</a>
-<li><a href="list.html">List</a>
-<li><a href="maybe.html">Maybe</a>
-<li><a href="char.html">Char</a>
-<li><a href="monad.html">Monad</a>
-<li><a href="io.html">IO</a>
-<li><a href="directory.html">Directory</a>
-<li><a href="system.html">System</a>
-<li><a href="time.html">Time</a>
-<li><a href="locale.html">Locale</a>
-<li><a href="cputime.html">CPUTime</a>
-<li><a href="random.html">Random</a>
-</ul>
-<hr>
-
-<div align=center>
-<a href="http://research.microsoft.com/Users/simonpj">
-Simon Peyton Jones</a> [editor], Microsoft Research, Cambridge <br>
-<a href="http://www.cs.chalmers.se/~rjmh">
-John Hughes</a> [editor], Chalmers University of Technology <br>
-<a href="http://www.cs.chalmers.se/~augustss">
-Lennart Augustsson</a>, Sandburst Corporation <br>
-<a href="http://www.inmet.com/~dlb">
-Dave Barton</a>, Intermetrics <br>
-<a href="http://www.comp.vuw.ac.nz/Staff/Brian-Boutel.html">
-Brian Boutel</a>, Victoria University of Wellington <br>
-<a href="http://fas.sfu.ca/cs/people/Faculty/Burton/">
-Warren Burton</a>, Simon Fraser University <br>
-<a href="http://coyote.lanl.gov/HOMES/jfasel.html">
-Joseph Fasel</a>, Los Alamos National Laboratory <br>
-<a href="http://www.dcs.st-and.ac.uk/~kh/kh.html">
-Kevin Hammond</a>, University of St. Andrews <br>
-<a href="http://titan.informatik.uni-bonn.de/~ralf">
-Ralf Hinze</a>, University of Bonn <br>
-<a href="http://www.cs.yale.edu/homes/hudak-paul.html">
-Paul Hudak</a>, Yale University <br>
-<a href="http://www.cs.chalmers.se/~johnsson">
-Thomas Johnsson</a>, Chalmers University of Technology <br>
-<a href="http://www.cse.ogi.edu/~mpj">
-Mark Jones</a>, Oregon Graduate Institute <br>
-<a href="http://www.cse.ogi.edu/~jl">
-John Launchbury</a>, Oregon Graduate Institute <br>
-<a href="http://research.microsoft.com/~emeijer">
-Erik Meijer</a>, Microsoft Corporation<br>
-<a href="http://www.cs.yale.edu/homes/peterson-john.html">
-John Peterson</a>, Yale University <br>
-<a href="http://www.cs.yale.edu/homes/reid-alastair.html">
-Alastair Reid</a>, University of Utah <br>
-<a href="http://www.cs.york.ac.uk/~colin/home.html">
-Colin Runciman</a>, York University <br>
-<a href="http://cm.bell-labs.com/cm/cs/who/wadler/">
-Philip Wadler</a>, Avaya Labs <br>
-</div>
-
-<p>
-Copyright (c) Simon Peyton Jones and John Hughes. 
-<br>
-<em> The authors intend this Report to belong to the entire Haskell
-community, and so we grant permission to copy and distribute it for
-any purpose, provided that it is reproduced in its entirity,
-including this Notice. Modified versions of this Report may also be
-copied and distributed for any purpose, provided that the modified
-version is clearly presented as such, and that it does not claim to be
-a definition of the language Haskell 98.</em>
-<p>
-The master version of the Haskell Library Report is at <a
-href="http://haskell.org/definition"> haskell.org</a>.  Any corrections or
-changes in the report are found there.
-
-</body>
diff --git a/libraries/introduction.verb b/libraries/introduction.verb
deleted file mode 100644 (file)
index b08af4d..0000000
+++ /dev/null
@@ -1,101 +0,0 @@
-%**<title>The Haskell 98 Library Report: Introduction</title>
-%**~sheader
-
-\markboth{PREFACE}{PREFACE}
-\begin{center}
-{\Large \bf Preface}
-\end{center}
-
-\vspace{.2in}
-
-This document defines the standard libraries for \Haskell{} 98.
-
-The libraries presented here represent a selection of basic
-functionality that is expected to be useful to many \Haskell{}
-programmers.  Most implementations provide further libraries
-which are not a recognized part of the \Haskell{} standard.
-
-The latest version of this report, as well many other available libraries,
-can be found on the web at @http://haskell.org@.
-
-\subsection*{The August 2001 Revision}
-
-Both Haskell 98 Reports were revised in August 2001, to incorporate
-dozens of typographical errors and presentational improvements.  A
-complete list of all changes can be found at @http://haskell.org@.
-
-
-\subsection*{Acknowledgements}
-
-We would like to express our thanks to those who have contributed
-directly or indirectly to this report without being named as authors,
-including
-Olaf Chitil,
-Mark Carroll,
-Tony Davie,
-Hal Daume,
-Sigbjorn Finne,
-Andy Gill, 
-Mike Gunter,
-Fergus Henderson,
-Orjan Johansen,
-Kent Karlsson,
-Sandra Loosemore,
-Graeme Moss,
-Sven Panne,
-Keith Wansbrough.
-
-In addition, many people named in the Acknowledgements to the Haskell 98 Language
-Report also contributed to the Library Report.
-
-\clearpage
-\section{Introduction}
-\label{introduction}
-
-This document defines the standard libraries for \Haskell{} 98.  Like the @Prelude@,
-these libraries are a required part of a \Haskell{}
-implementation.  Unlike the Prelude, however, these modules must
-be {\em explicitly} imported into scope.
-
-When possible, library functions are described solely by executable
-\Haskell{} code.  Functions which require implementation-dependent
-primitives are
-represented by type signatures without definitions.
-Some data types are implementation-dependent: these are indicated
-by comments in the source.
-
-The code found here is a {\em specification}, rather than an
-{\em implementation}.  Implementations may choose more efficient versions of
-these functions.  However, all
-properties of these specifications must be preserved, including
-strictness properties. 
-
-Classes defined in libraries may be derivable.  This report includes
-the derivation of such classes when appropriate.  
-When @Prelude@ types
-are instances of derivable library classes a commented empty instance
-declaration is used.  The comment, ``as derived'', indicates that the
-instance is the same as would have been generated by a @deriving@ in
-the Prelude type declaration. 
-
-The following table summarises the fixities of all the operators 
-introduced by the standard libraries:
-\begin{table}[htb]
-\[
-\centerline{
-\begin{tabular}{|r||l|l|l|}
-\hline 
-Prec-  & Left associative      & Non-associative       & Right associative \\
-edence & operators             & operators             & operators \\ \hline\hline
-9 & @Array.!@, @Array.//@      & & \\ \hline
-7 & @Ratio.%@                  & & \\ \hline
-6 &                            & @Complex.:+@          & \\ \hline
-5 &                            & @List.\\@             & \\ \hline
-\end{tabular}}
-\]
-\ecaption{Precedences and fixities of library operators}
-\indextt{>>=}
-\end{table}
-
-
-%**~sfooter
diff --git a/libraries/io.verb b/libraries/io.verb
deleted file mode 100644 (file)
index a4f6846..0000000
+++ /dev/null
@@ -1,637 +0,0 @@
-%**<title>The Haskell 98 Library Report: IO</title>
-%**~header
-\section{Input/Output}
-\label{IO}
-\index{input/output}
-\index{I/O}
-\indextt{IO}
-
-% Gotta break the figure ...
-\outline{
-\inputHS{headers/IO}
-}
-\outline{
-\inputHS{headers/IO1}
-}
-
-The monadic I/O system used in \Haskell{} is described by the
-\Haskell{} language report.  Commonly used I/O functions such as
-@print@ are part of the standard prelude and need not be explicitly
-imported.  This library contain more advanced I/O features.
-Some related operations on file systems are contained in the
-@Directory@ library.
-
-\subsection{I/O Errors}
-\index{I/O errors}
-\label{IOError}
-Errors of type @IOError@ are used by the I/O monad.  This is an
-abstract type; the library provides functions to interrogate and
-construct values in @IOError@:\indextt{IOError}
-\begin{itemize}
-\item
-@isAlreadyExistsError@\indextt{isAlreadyExistsError}
- -- the operation failed because one of its
-arguments already exists.
-\item
-@isDoesNotExistError@\indextt{isDoesNotExistError}
- -- the operation failed because one of its
-arguments does not exist.
-\item
-@isAlreadyInUseError@\indextt{isAlreadyInUseError}
- -- the operation failed because one of its
-arguments is a single-use resource, which is already being used (for
-example, opening the same file twice for writing might give this
-error).
-\item
-@isFullError@\indextt{isFullError}
- -- the operation failed because the device is full.
-\item
-@isEOFError@\indextt{isEOFError}
- -- the operation failed because the end of file
-has been reached.
-\item
-@isIllegalOperation@\indextt{isIllegalOperation}
- -- the operation is not possible.
-\item
-@isPermissionError@\indextt{isPermissionError}
- -- the operation failed because the user does not
-have sufficient operating system privilege to perform that operation.
-\item
-@isUserError@\indextt{isUserError}
- -- a programmer-defined error value has been raised using
-@fail@.\indextt{fail}
-\end{itemize}
-All these functions return a @Bool@, which is @True@ if
-its argument is the corresponding kind of error, and @False@
-otherwise.  
-
-Any computation which returns an @IO@ result may fail with
-@isIllegalOperation@.  Additional errors which could be raised by
-an implementation are listed after the corresponding operation.  In
-some cases, an implementation will not be able to distinguish between
-the possible error causes.  In this case it should return
-@isIllegalOperation@.
-
-Three additional functions are provided to obtain information about an
-error value.  These are @ioeGetHandle@\indextt{ioeGetHandle} which
-returns @Just@~"hdl" if the error value refers to handle "hdl" and
-@Nothing@ otherwise; @ioeGetFileName@\indextt{ioeGetFileName} which
-returns @Just@~"name" if the error value refers to file "name", and
-@Nothing@ otherwise; and @ioeGetErrorString@\indextt{ioeGetErrorString} which returns a
-string.  For ``user'' errors (those which are raised using @fail@),
-the string returned by @ioeGetErrorString@ is the argument that was passed to
-@fail@; for all other errors, the string is implementation-dependent.
-
-The @try@ function returns an error in a computation explicitly using
-the @Either@ type.
-
-The @bracket@ function 
-captures a common allocate, compute, deallocate idiom in which the
-deallocation step must occur even in the case of an error during
-computation.  This is similar to try-catch-finally in Java.
-% Inline the code here since there's no other functions in IO that
-% are not primitive.
-
-
-
-\subsection{Files and Handles}
-\Haskell{} interfaces to the external world through an abstract {\em file
-system}\index{file system}.  This file system is a collection of named {\em file
-system objects}, which may be organised
-in {\em directories}\index{directories} (see @Directory@).  
-In some implementations, directories may themselves be file system
-objects and could be entries in other directories.  For simplicity,
-any non-directory file system object is termed a {\em file}\index{file},
-although it could in fact be a communication channel, or any other
-object recognised by the operating system.  {\em Physical
-files}\index{physical file} are 
-persistent, ordered files, and normally reside on disk.
-
-File and directory names are values of type @String@, whose precise
-meaning is operating system dependent.  Files can be opened, yielding
-a handle which can then be used to operate on the contents of that
-file.
-
-\label{Handles}
-\index{handles}
-
-\Haskell{} defines operations to read and write characters from and to files,
-represented by values of type @Handle@.  Each value of this type is a {\em
-handle}: a record used by the \Haskell{} run-time system to {\em manage} I/O
-with file system objects.  A handle has at least the following properties:
-
-\begin{itemize}
-\item
- whether it manages input or output or both;
-\item
- whether it is {\em open}, {\em closed} or {\em semi-closed};
-\item
- whether the object is seekable;
-\item
- whether buffering is disabled, or enabled on a line or block basis;
-\item
- a buffer (whose length may be zero).
-\end{itemize}
-
-Most handles will also have a current I/O position indicating where the next
-input or output operation will occur.  A handle is {\em readable} if it
-manages only input or both input and output; likewise, it is {\em writable} if
-it manages only output or both input and output.  A handle is {\em open} when
-first allocated.  Once it is closed it can no longer be used for either input
-or output, though an implementation cannot re-use its storage while references
-remain to it.  Handles are in the @Show@ and @Eq@ classes.  The string
-produced by showing a handle is system dependent; it should include 
-enough information to identify the handle for debugging.  A handle is
-equal according to @==@ only to itself; no attempt
-is made to compare the internal state of different handles for equality.
-
-\subsubsection{Standard Handles}
-\label{StandardHandles}
-\index{standard handles}
-
-Three handles are allocated during program initialisation.  The first
-two (@stdin@\indextt{stdin} and @stdout@\indextt{stdout}) manage input or output from the \Haskell{}
-program's standard input or output channel respectively.  The third
-(@stderr@\indextt{stderr}) manages output to the standard error channel.  These
-handles are initially open.
-
-\subsubsection{Semi-Closed Handles}
-\label{SemiClosed}
-\index{semi-closed handles}
-
-The operation "@hGetContents@ hdl"\indextt{hGetContents} (Section~\ref{hGetContents})
-puts a handle "hdl" into an intermediate
-state, {\em semi-closed}.  In this state, "hdl" is effectively closed,
-but items are read from "hdl" on demand and accumulated in a special
-list returned by @hGetContents@~"hdl".
-Any operation that fails because a handle is
-closed, also fails if a handle is semi-closed. The only exception is @hClose@.
-A semi-closed handle becomes closed:
-\begin{itemize}
-\item
-if  @hClose@ is applied to it;
-\item
-if an I/O error occurs when reading an item from the handle;
-\item
-or once the entire contents of the handle has been read.
-\end{itemize}
-
-Once a semi-closed handle becomes closed, the contents of the
-associated list becomes fixed.  The contents of this final list is
-only partially specified: it will contain at least all the items of
-the stream that were evaluated prior to the handle becoming closed.
-
-Any I/O errors encountered while a handle is semi-closed are simply
-discarded.
-\subsubsection{File locking}
-
-Implementations should enforce as far as possible, at least locally to the
-\Haskell{} process, multiple-reader single-writer locking on files.
-That is, {\em there may either be many handles on the same file which manage
-input, or just one handle on the file which manages output}.  If any
-open or semi-closed handle is managing a file for output, no new
-handle can be allocated for that file.  If any open or semi-closed
-handle is managing a file for input, new handles can only be allocated
-if they do not manage output.  Whether two files are the same is
-implementation-dependent, but they should normally be the same if they
-have the same absolute path name and neither has been renamed, for
-example.
-
-{\em Warning}: the @readFile@ operation (Section 7.1 of the Haskell Language Report)
-holds a semi-closed handle on the file until the entire contents of the file have been
-consumed.  It follows that an attempt to write to a file (using @writeFile@, for example)
-that was earlier opened by @readFile@ will usually result in 
-failure with @isAlreadyInUseError@.
-\indextt{readFile}
-\indextt{writeFile}
-
-
-\subsection{Opening and Closing Files}
-\label{OpeningClosing}
-
-\subsubsection{Opening Files}
-\label{Opening}
-\index{opening a file}
-\index{creating a file}
-
-Computation @openFile@~"file"~"mode"\indextt{openFile} allocates and
-returns a new, open handle to manage the file "file".
-% I don't believe this footnote is technically correct -- functions
-% are never computations IIRC: the computation is the action
-% that occurs when the function is applied to a state token -- KH
-% \footnote{We use
-% the term "computation" instead of "function" here to separate
-% functions which denote actions in the I/O monad from those outside the monad.}
-It manages
-input if "mode"\indextycon{IOMode} is @ReadMode@\indextt{ReadMode},
-output if "mode" is @WriteMode@\indextt{WriteMode} or
-@AppendMode@,\indextt{AppendMode} and both input and output if mode is
-@ReadWriteMode@.\indextt{ReadWriteMode}
-
-If the file does not exist and it is opened for output, it should be created
-as a new file.  If "mode" is @WriteMode@ and the file already exists, then it
-should be truncated to zero length.  Some operating systems delete empty
-files, so there is no guarantee that the file will exist following an
-@openFile@ with "mode" @WriteMode@ unless it is subsequently written to
-successfully.  The handle is positioned at the end of the file if "mode" is
-@AppendMode@, and otherwise at the beginning (in which case its internal I/O
-position is 0).  The initial buffer mode is implementation-dependent.
-
-If @openFile@ fails on a file opened for output, the file may still
-have been created if it did not already exist.
-
-{\em Error reporting}: the @openFile@ computation may fail with
-@isAlreadyInUseError@ if the file is already open and cannot be
-reopened;
-@isDoesNotExistError@ if the file does not exist; or
-@isPermissionError@ if the user does not have
-permission to open the file.
-\indextt{isAlreadyInUseError}
-\indextt{isDoesNotExistError}
-\indextt{isPermissionError}
-
-\subsubsection{Closing Files}
-\label{Closing}
-\index{closing a file}
-
-Computation @hClose@~"hdl"\indextt{hClose} makes handle "hdl" closed.  Before the
-computation finishes, if "hdl" is writable its buffer is flushed as
-for @hFlush@.
-Performing @hClose@ on a handle that has already been closed has no effect; 
-doing so not an error.  All other operations on a closed handle will fail.
-If @hClose@ fails for any reason, any further operations (apart from @hClose@) on the 
-handle will still fail as if "hdl" had been successfully closed.
-
-\subsection{Determining the Size of a File}
-\label{FileSize}
-\index{size of file}
-
-For a handle "hdl" which is attached to a physical file, @hFileSize@\indextt{hFileSize}
-"hdl" returns the size of that file in 8-bit bytes ("\geq" 0).
-
-\subsubsection{Detecting the End of Input}
-\label{EOF}
-\index{end of file}
-
-For a readable handle "hdl", computation @hIsEOF@~"hdl"\indextt{hIsEOF} returns @True@
-if no further input can be taken from "hdl"; for a handle attached to a 
-physical file this means that the current I/O position is equal to the length of the file.
-Otherwise, it returns @False@.  The computation @isEOF@\indextt{isEOF} is identical,
-except that it works only on @stdin@.
-
-% The computation may fail with:
-% \begin{itemize}
-% \item
-% @HardwareFault@
-% A physical I/O error has occurred.
-% [@EIO@]
-% \item
-% @ResourceExhausted@
-% Insufficient resources are available to perform the operation.
-% [@ENOMEM@]
-% \item
-% @IllegalOperation@
-% The handle is not open for reading.
-% \end{itemize}
-
-\subsubsection{Buffering Operations}
-\label{Buffering}
-\index{file buffering}
-
-Three kinds of buffering are supported: line-buffering, 
-block-buffering or no-buffering.  These modes have the following effects.
-For output, items are written out, or {\em flushed}, from the internal buffer 
-according to the buffer mode:
-\begin{itemize}
-\item
-{\bf line-buffering:}
-the entire buffer is flushed whenever a newline is output, the
-buffer overflows, a @hFlush@ is issued, or the handle is closed.
-\item
-{\bf block-buffering:}
-the entire buffer is written out whenever it overflows, a @hFlush@ is
-issued, or the handle is closed.
-\item
-{\bf no-buffering:}
-output is written immediately, and never stored in the buffer.
-\end{itemize}
-An implementation is free to flush the buffer more frequently, but not 
-less frequently, than
-specified above.  The buffer is emptied as soon as it has been written out.
-
-Similarly, input occurs according to the buffer mode for handle "hdl".
-\begin{itemize}
-\item
-{\bf line-buffering:}
-when the buffer for "hdl" is not empty, the next item is obtained from
-the buffer; otherwise, when the buffer is empty, characters are read into
-the buffer until the next newline character is encountered or the buffer is full.  No
-characters are available until the newline character is available or the buffer is full.
-\item
-{\bf block-buffering:} 
-when the buffer for "hdl" becomes empty, the
-next block of data is read into the buffer.
-\item
-{\bf no-buffering:} 
-the next input item is read and returned.  The @hLookAhead@\indextt{hLookAhead} 
-operation (Section~\ref{hLookAhead}) implies that
-even a no-buffered handle may require a one-character buffer.
-\end{itemize}
-
-For most implementations, physical files will normally be block-buffered 
-and terminals will normally be line-buffered.
-
-Computation @hSetBuffering@~"hdl"~"mode"\indextt{hSetBuffering} sets the
-mode of buffering for handle "hdl" on subsequent reads and writes.
-\begin{itemize}
-\item
-If "mode" is @LineBuffering@, line-buffering is
-enabled if possible.
-\item
-If "mode" is @BlockBuffering@~"size", then block-buffering
-is enabled if possible.  The size of the buffer is "n" items
-if "size" is @Just @"n" and is otherwise implementation-dependent.
-\item
-If "mode" is @NoBuffering@, then buffering is disabled if possible.
-\end{itemize}
-
-If the buffer mode is changed from @BlockBuffering@ or
-@LineBuffering@ to @NoBuffering@, then 
-\begin{itemize}
-\item
-if "hdl" is writable, the buffer is flushed as for 
-@hFlush@;
-\item
-if "hdl" is not writable, the contents of the buffer is discarded.
-\end{itemize}
-
-{\em Error reporting}: the @hSetBuffering@ computation may fail with
-@isPermissionError@ if
-the handle has already been used for reading or writing
-and the implementation does not allow the buffering mode to
-be changed.
-
-Computation @hGetBuffering@~"hdl"\indextt{hGetBuffering} returns the current buffering mode
-for "hdl".
-
-The default buffering mode when a handle is opened is
-implementation-dependent and may depend on the file system object which is
-attached to that handle.
-
-\subsubsection{Flushing Buffers}
-\label{Flushing}
-\index{flushing a file buffer}
-
-Computation @hFlush@~"hdl"\indextt{hFlush} causes any items buffered for output in
-handle "hdl" to be sent immediately to the operating system.
-
-{\em Error reporting}: the @hFlush@ computation may fail with:
-@isFullError@ if the device is full; @isPermissionError@ if a
-system resource limit would be exceeded.  It is unspecified whether the
-characters in the buffer are discarded or retained under these circumstances.
-
-\subsection{Repositioning Handles}
-\label{Seeking}
-\index{random access files}
-\index{seeking a file}
-
-\subsubsection{Revisiting an I/O Position}
-
-Computation @hGetPosn@~"hdl"\indextt{hGetPosn} returns the current I/O position of "hdl" as a
-value of the abstract type @HandlePosn@.  If a call to "@hGetPosn@~h" returns a position "p",
-then computation @hSetPosn@~"p"\indextt{hSetPosn} sets the
-position of "h" to the position it held at the time of the call to @hGetPosn@.
-
-
-{\em Error reporting}: the @hSetPosn@ computation may fail with:
-@isPermissionError@ if a system resource limit would be exceeded.
-
-\subsubsection{Seeking to a new Position}
-
-Computation @hSeek@~"hdl"~"mode"~"i"\indextt{hSeek} sets the position of handle
-"hdl" depending on "mode".\indextycon{SeekMode}  If "mode" is:
-\begin{itemize}
-\item
-@AbsoluteSeek@:\indextt{AbsoluteSeek} the position of "hdl" is set to "i".
-\item
-@RelativeSeek@:\indextt{RelativeSeek} the position of "hdl" is set to offset "i" from
-the current position.
-\item
-@SeekFromEnd@:\indextt{SeekFromEnd} the position of "hdl" is set to offset "i" from
-the end of the file.
-\end{itemize}
-The offset is given in terms of 8-bit bytes.
-
-If "hdl" is block- or line-buffered, then seeking to a position which is not
-in the current buffer will first cause any items in the output buffer to be
-written to the device, and then cause the input buffer to be discarded.  Some
-handles may not be seekable (see @hIsSeekable@), or only support a subset of
-the possible positioning operations (for instance, it may only be possible to
-seek to the end of a tape, or to a positive offset from the beginning or
-current position).  It is not possible to set a negative I/O position, or for
-a physical file, an I/O position beyond the current end-of-file.
-
-{\em Error reporting}:
-the @hSeek@ computation may fail with:
-@isPermissionError@ if a system resource limit would be exceeded.
-
-\subsection{Handle Properties}
-\label{Query}
-
-The functions 
-@hIsOpen@\indextt{hIsOpen}, 
-@hIsClosed@\indextt{hIsClosed},
-@hIsReadable@\indextt{hIsReadable},
-@hIsWritable@\indextt{hIsWritable} and
-@hIsSeekable@\indextt{hIsSeekable}
-return information about the properties of a handle.
-Each of these returns @True@ if the handle has the specified property, and
-@False@ otherwise.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%
-%% Haskell 1.3 Text Input: LibReadTextIO
-%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\subsection{Text Input and Output}
-\index{reading from a file}
-%\indextt{LibReadTextIO}
-
-Here we define a standard set of input operations for reading
-characters and strings from text files, using handles.  Many of these
-functions are generalizations of Prelude functions.  I/O in the
-Prelude generally uses @stdin@ and @stdout@; here, handles are explicitly
-specified by the I/O operation.
-
-\subsubsection{Checking for Input}
-\label{hReady}
-\label{hWaitForInput}
-\index{polling a handle for input}
-
-Computation @hWaitForInput@~"hdl"~"t"\indextt{hWaitForInput} 
-waits until input is available on handle "hdl".
-It returns @True@ as soon as input is available on "hdl", or @False@ if no input is available
-within "t" milliseconds.
-
-Computation @hReady@~"hdl"\indextt{hReady} indicates whether at least one item is
-available for input from handle "hdl".
-
-{\em Error reporting}.
-The @hWaitForInput@ and @hReady@ computations fail with
-@isEOFError@ if the end of file has been reached.
-
-\subsubsection{Reading Input}
-
-Computation @hGetChar@~"hdl"\indextt{hGetChar} reads a character from
-the file or channel managed by "hdl".
-
-Computation @hGetLine@~"hdl"\indextt{hGetLine} reads a line from the file or
-channel managed by "hdl". The Prelude's @getLine@ is a shorthand
-for @hGetLine stdin@.
-{\em Error reporting}.
-The @hGetChar@ computation fails with
-@isEOFError@ if the end of file has been reached.
-The @hGetLine@ fails with @isEOFError@ if the end of file is encountered
-when reading the {\em first} character of the line. If @hGetLine@ encounters
-end-of-file at any other point while reading in a line, it is treated as
-a line terminator and the (partial) line is returned.
-
-
-\subsubsection{Reading Ahead}
-\label{hLookAhead}
-\index{lookahead}
-
-Computation @hLookAhead@~"hdl"\indextt{hLookAhead} returns the next character from handle
-"hdl" without removing it from the input buffer, blocking until a
-character is available.
-
-{\em Error reporting}:
-the @hLookAhead@ computation may fail with:
-@isEOFError@ if the end of file has been reached.
-
-\subsubsection{Reading The Entire Input}
-\label{hGetContents}
-\index{get the contents of a file}
-
-Computation @hGetContents@~"hdl"\indextt{hGetContents} returns the list of
-characters corresponding to the unread portion of the channel or file managed
-by "hdl", which is made semi-closed.
-
-{\em Error reporting}:
-the @hGetContents@ computation may fail with:
-@isEOFError@ if the end of file has been reached.
-
-\subsubsection{Text Output}
-
-Computation @hPutChar@~"hdl"~"c"\indextt{hPutChar} writes the character "c" to the file
-or channel managed by "hdl".  Characters may be buffered if buffering
-is enabled for "hdl".
-
-Computation @hPutStr@~"hdl"~"s"\indextt{hPutStr} writes the string
-"s" to the file or channel managed by "hdl".
-
-Computation @hPrint@~"hdl"~"t"\indextt{hPrint} writes the string representation of "t"
-given by the @shows@ function to the file or channel managed by "hdl" and appends a newline.
-
-{\em Error reporting}:
-the @hPutChar@, @hPutStr@ and @hPrint@ computations may fail with:
-@isFull@-@Error@ if the device is full;
-or @isPermissionError@ if another system resource limit would be exceeded.
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%
-%% Haskell 1.3 Examples
-%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\subsection{Examples}
-\index{input/output examples}
-
-Here are some simple examples to illustrate \Haskell{} I/O.
-
-\subsubsection{Summing Two Numbers}
-
-This program reads and sums two @Integer@s.
-\bprog
-@
-import IO
-
-main = do
-         hSetBuffering stdout NoBuffering            
-         putStr   "Enter an integer: "        
-         x1 <- readNum 
-         putStr   "Enter another integer: "          
-         x2 <- readNum                          
-         putStr  ("Their sum is " ++ show (x1+x2) ++ "\n")
-       where readNum :: IO Integer
-               -- Providing a type signature avoids reliance on
-               -- the defaulting rule to fix the type of x1,x2
-             readNum = readLn
-@
-\eprog
-
-\subsubsection{Copying Files}
-
-A simple program to create a copy of a file, with all lower-case
-characters translated to upper-case.  This program will not allow a
-file to be copied to itself.  This version uses character-level I/O.
-Note that exactly two arguments must be supplied to the program.
-\bprog
-@
-import IO
-import System
-import Char( toUpper )
-
-main = do 
-         [f1,f2] <- getArgs
-         h1 <- openFile f1 ReadMode     
-         h2 <- openFile f2 WriteMode 
-         copyFile h1 h2            
-         hClose h1                  
-         hClose h2
-
-copyFile h1 h2 = do
-                   eof <- hIsEOF h1
-                   if eof then return () else
-                      do
-                        c <- hGetChar h1
-                        hPutChar h2 (toUpper c)   
-                        copyFile h1 h2
-@
-\eprog
-
-An equivalent but much shorter version, using string I/O is:
-\bprog
-@
-import System
-import Char( toUpper )
-
-main = do
-         [f1,f2] <- getArgs
-         s <- readFile f1
-         writeFile f2 (map toUpper s)
-@
-\eprog
-
-%      Not any more in Haskell 98!
-% The @~@ used in the patterns above is a necessary consequence of the
-% @do@-notation which has been used for the I/O operations.  In general,
-% if the pattern on the left of any @<-@ fails to match, the value of
-% the entire @do@-expression is defined to be the ``zero'' in the
-% underlying monad.  However, since the @IO@ monad has no zero, the @~@
-% is required in order to force the pattern to be irrefutable.  Without
-% the @~@, a class error would occur because there is no instance of
-% @IO@ for class @MonadZero@.
-
-\subsection{Library @IO@}
-
-\inputHS{code/IO}
-
-%**~footer
diff --git a/libraries/ix.verb b/libraries/ix.verb
deleted file mode 100644 (file)
index 1f0015a..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-%**<title>The Haskell 98 Library Report: Indexing Operations</title>
-%**~header
-\section{Indexing Operations}
-
-\outline{
-\inputHS{headers/Ix}
-}
-The @Ix@ class is used to map a contiguous subrange of values in a
-type onto integers.  It is used primarily for array indexing (see
-Section~\ref{arrays}).  
-The @Ix@ class contains the methods @range@\indextt{range},
-@index@\indextt{index}, and @inRange@\indextt{inRange}. 
-The @index@ operation maps a bounding pair, which defines the lower
-and upper bounds of the range, and a 
-subscript, to an integer.  The @range@ operation enumerates all
-subscripts; the @inRange@ operation tells whether a particular subscript
-lies in the range defined by a bounding pair.
-
-An implementation is entitled to assume the following laws about these
-operations:
-\bprog
-@
-   range (l,u) !! index (l,u) i == i   -- when i is in range
-   inRange (l,u) i             == i `elem` range (l,u)
-   map index (range (l,u))      == [0..rangeSize (l,u)]
-@
-\eprog
-
-% It is the responsibility of the programmer to enforce bounds
-% checking for non-derived instances of class @Ix@, if desired.
-% An implementation is not required to check that an index
-% lies within the bounds of an array when accessing that array.
-
-\subsection{Deriving Instances of @Ix@}
-\index{Ix@@{\tt Ix}!derived instance}
-
-It is possible to derive an instance of @Ix@ automatically, using
-a @deriving@ clause on a @data@ declaration (Section~4.3.3
-of the Language Report).
-Such derived instance declarations for the class @Ix@ are only possible
-for enumerations\index{enumeration} (i.e.~datatypes having
-only nullary constructors) and single-constructor datatypes,
-whose constituent types are instances of @Ix@.   A Haskell implementation
-must provide @Ix@ instances for tuples up to at least size 15.
-
-\begin{itemize}
-\item
-For an {\em enumeration}, the nullary constructors are assumed to be
-numbered left-to-right with the indices being $0$ to $n-1\/$ inclusive.
-This is the same numbering defined by the @Enum@ class.  For example,
-given the datatype:
-\bprog
-@
-data Colour = Red | Orange | Yellow | Green | Blue | Indigo | Violet
-@
-\eprog
-we would have:
-\bprog
-@
-range   (Yellow,Blue)        ==  [Yellow,Green,Blue]
-index   (Yellow,Blue) Green  ==  1
-inRange (Yellow,Blue) Red    ==  False
-@
-\eprog
-\item
-For {\em single-constructor datatypes}, the derived instance declarations
-are as shown for tuples in
-Figure~\ref{prelude-index}.
-\end{itemize}
-
-\begin{figure}[tb]
-\outline{
-@
-instance  (Ix a, Ix b)  => Ix (a,b) where
-        range ((l,l'),(u,u'))
-                = [(i,i') | i <- range (l,u), i' <- range (l',u')]
-        index ((l,l'),(u,u')) (i,i')
-                =  index (l,u) i * rangeSize (l',u') + index (l',u') i'
-        inRange ((l,l'),(u,u')) (i,i')
-                = inRange (l,u) i && inRange (l',u') i'
-
--- Instances for other tuples are obtained from this scheme:
---
---  instance  (Ix a1, Ix a2, ... , Ix ak) => Ix (a1,a2,...,ak)  where
---      range ((l1,l2,...,lk),(u1,u2,...,uk)) =
---          [(i1,i2,...,ik) | i1 <- range (l1,u1),
---                            i2 <- range (l2,u2),
---                            ...
---                            ik <- range (lk,uk)]
---
---      index ((l1,l2,...,lk),(u1,u2,...,uk)) (i1,i2,...,ik) =
---        index (lk,uk) ik + rangeSize (lk,uk) * (
---         index (lk-1,uk-1) ik-1 + rangeSize (lk-1,uk-1) * (
---          ...
---           index (l1,u1)))
---
---      inRange ((l1,l2,...lk),(u1,u2,...,uk)) (i1,i2,...,ik) =
---          inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
---              ... && inRange (lk,uk) ik
-@
-}
-\ecaption{Derivation of Ix instances}
-\label{prelude-index}
-\indextt{Ix}                                                
-\indextt{range}\indextt{index}\indextt{inRange}   
-\indextt{rangeSize}                                         
-\end{figure}
-
-\clearpage
-\subsection{Library {\tt Ix}}
-\inputHS{code/Ix}
-
-%**~footer
diff --git a/libraries/library.verb b/libraries/library.verb
deleted file mode 100644 (file)
index 53e8b57..0000000
+++ /dev/null
@@ -1,525 +0,0 @@
-%
-% $Header: /home/cvs/root/haskell-report/libraries/library.verb,v 1.13 2002/12/02 11:22:00 simonpj Exp $
-%
-% NOTE:--------------------------------------------------------------
-% The formatting of this report and the ``new font selection scheme''
-% for LaTeX don't agree w/ each other.  Using an ``oldlfont'' style
-% option may help.
-% -------------------------------------------------------------------
-%
-
-% -------------------------------------------------------------------
-% formatting for ONE-SIDED printing:
-%  * De-comment the \documentstyle, etc., here; comment out the
-%    two-sided ones below.
-%  * Change the definition of \startnewstuff (below).
-%  * Copy the pre-built index file for one-sided printing:
-%       cp haskell.ind.one-sided haskell.ind
-%  * Comment out the "twosidefix" stuff from Joe Fasel, just below.
-%  * If you don't have "makeindex", make the adjustments
-%    listed in the README file.
-%  * Run "make haskell.dvi" several times (three, at most) to be
-%    sure that cross-references stabilise.  [For the 1.1 report,
-%    one run should be enough.]
-\documentstyle[twoside,11pt,makeidx]{article}
-\oddsidemargin=.25in
-\evensidemargin=.25in
-
-% formatting for double-sided
-%\documentstyle[twoside,11pt,makeidx]{article}
-% Inverted for SIGPLAN -- Page 1 is a LEFT page!!
-%\evensidemargin=0in
-%\oddsidemargin=.5in
-%\evensidemargin=.5in
-%\oddsidemargin=0in
-%---------------------------------------------------------------------
-% Joe Fasel said this "twosidefix" is necessary if you really
-% have a two-sided printer:
-%       (note: double @@'s for verbatim-ery)
-\makeatletter
-\def\titlepage{\@@restonecolfalse\if@@twocolumn\@@restonecoltrue\onecolumn
- \else \newpage \fi \thispagestyle{empty}\c@@page\m@@ne}
-\def\endtitlepage{\if@@twoside\newpage\thispagestyle{empty}\hbox{}
-                        \else \c@@page\@@z \fi
-   \if@@restonecol\twocolumn \else \newpage \fi}
-\makeatother
-%---------------------------------------------------------------------
-
-% the major sections have \cleardoublepages between them
-% if you want those between EVERY section, change the
-% following defn:
-\newcommand{\startnewsection}{\clearpage}
-%
-% if doing one-sided printing, change this defn to
-% be just "\clearpage":
-\newcommand{\startnewstuff}{\clearpage}
-%\newcommand{\startnewstuff}{\cleardoublepage}
-% keep some pages from looking unbelievably appalling
-\raggedbottom
-
-% Fix those ugly floating figures.
-\renewcommand{\floatpagefraction}{0.1}
-\renewcommand{\textfraction}{0.1}
-\renewcommand{\topfraction}{1.0}
-\renewcommand{\bottomfraction}{1.0}
-
-% table of contents: show only down to subsections
-\setcounter{tocdepth}{2}
-
-% general formatting
-\textheight=8.5in
-\textwidth=6.0in
-\topmargin=0in
-\pagestyle{headings}
-
-\makeindex
-% an extra thing for makeindex
-\newcommand{\hseealso}[2]{{\em see also\/} #1}
-
-% NEWCOMMANDS
-
-% general
-\newcommand{\folks}[1]{\begin{quote}\sf#1\end{quote}}
-\newcommand{\sectionpart}[1]{\vspace{2 ex}\noindent{\bf #1}}
-\newcommand{\bq}{\begin{quote}}
-\newcommand{\eq}{\end{quote}}
-\newcommand{\bt}{\begin{tabular}}
-\newcommand{\et}{\end{tabular}}
-\newcommand{\bi}{\begin{itemize}}
-\newcommand{\ei}{\end{itemize}}
-\newcommand{\struthack}[1]{\rule{0pt}{#1}}
-\newcommand{\inputHS}{\input}
-\newcommand{\ignorehtml}[1]{#1}
-
-%\newcommand{\ToDo}[1]{}
-\newcommand{\ToDo}[1]{({\bf $\spadesuit$ ToDo:} {\em #1})}
-
-\newcommand{\WeSay}[1]{}
-%\newcommand{\WeSay}[1]{({\bf $\clubsuit$ YaleSays:} {\em #1})}
-
-\newcommand{\anchor}[2]{#2}
-
-% indexing
-\newcommand{\indextt}[1]{\index{#1@@{\tt #1}}}
-\newcommand{\indexsyn}[1]{\index{#1@@{\it #1}}}
-\newcommand{\indexmodule}[1]{\index{#1@@{\tt #1} (module)}}
-\newcommand{\indextycon}[1]{\index{#1@@{\tt #1} (datatype)}}
-\newcommand{\indexsynonym}[1]{\index{#1@@{\tt #1} (type synonym)}}
-\newcommand{\indexnote}[1]{#1n}
-
-\makeatletter
-\def\theindex{\@@restonecoltrue\if@@twocolumn\@@restonecolfalse\fi
-\columnseprule \z@@
-\columnsep 35pt\twocolumn[\section*{Index}
-        \addcontentsline{toc}{section}{Index}
-        \input{index-intro}\vskip 20pt]
- \@@mkboth{INDEX}{INDEX}\thispagestyle{plain}\parindent\z@@
- \parskip\z@@ plus .3pt\relax\let\item\@@idxitem
-}
-\makeatother
-
-% outlined figures
-\newcommand{\ecaption}[1]{\vspace{-1 ex}\caption{#1}\vspace{1 ex}}
-% partain fiddled here...
-%   also had to change two lines in verbatim.lex from
-%<SYNTAX>{nl}"|"{sp}    { printf ("$\\\\ \n$\\it "); 
-%                         printf ("$\\>\\makebox[3em]{$|$}$\\it "); }
-% to
-%
-%<SYNTAX>{nl}"|"{sp}    { printf ("$\\\\ \n$\\it "); 
-%                         printf ("$\\>\\makebox[3.5em]{$|$}$\\it "); }
-% so things would still line up.  Oh what a hack.
-%
-%\newcommand{\outline}{\outlinewidth{1.0}}
-%\newcommand{\outlinewidth}[2]{
-%\begin{center}
-%\fbox{ \begin{minipage}{#1\textwidth}
-%\vspace{1 ex}
-%#2
-%\end{minipage} }
-%\vspace{1 ex}
-%\end{center}
-%}
-% 6.0in (\textwidth) - 15pt (overfullness) ~=~ 415pt
-\newcommand{\outline}[1]{%
-\begin{center}
-\fbox{ \begin{minipage}{415pt}
-\vspace{1 ex}
-#1
-\end{minipage} }
-\vspace{1 ex}
-\end{center}
-}
-
-\newcommand{\outlinec}{\outline}  % Centered outlines in html
-
-% haskell code
-% partain fiddled here...
-% \newcommand{\bprog}{\par \begin{tabular}{|l} 
-%                   \mbox \bgroup \begin{minipage} {\textwidth} }
-% 6.0in (\textwidth) - 17pt (\parindent) ~=~ 412pt
-%\newcommand{\bprog}{\par \begin{tabular}{@@{}l@@{}} 
-%                   \mbox \bgroup \begin{minipage} {412pt} }
-%\newcommand{\eprog}{\end{minipage} 
-%                    \egroup
-%                    \end{tabular}\\[\parskip]}
-% 17pt is \parindent
-% this method gives a 17pt indent in _all_ situations
-\newcommand{\bprog}{%
-\par\noindent\begin{tabular}{@@{\hspace*{17pt}}l@@{}}}
-\newcommand{\eprog}{%
-\end{tabular}\\[\parskip]}
-\newcommand{\eprogNoSkip}{%
-\end{tabular}}
-%
-% variants for stdprelude; don't indent, and skip a little more
-\newcommand{\bprogB}{%
-\begin{tabular}{@@{}l@@{}}}
-\newcommand{\eprogB}{%
-\end{tabular}\\[0.6\baselineskip]}
-
-%special characters
-\newcommand{\bkq}{\mbox{\it \char'022}} % (syntax) backquote char
-\newcommand{\bkqB}{\bkq} % (syntax) backquote char (Before)
-\newcommand{\bkqA}{\hspace{-.2em}\mbox{\it \char'022}}% (syntax) backquote char (After)
-%\newcommand{\fwq}{\mbox{\it \char'023}} % (syntax) (forward) quote char
-% math formatting
-\newcommand{\ba}{\begin{array}}
-\newcommand{\ea}{\end{array}}
-\newcommand{\mc}{\multicolumn}
-\newcommand{\pile}[1]{\ba[t]{@@{}l@@{}} #1 \ea}
-\newcommand{\eqn}[1]{\ba[t]{@@{}lcl@@{}} #1 \ea}
-\newcommand{\equate}[1]{\[\eqn{#1}\]}
-\newcommand{\la}{\leftarrow}
-\newcommand{\ra}{\rightarrow}
-\newcommand{\sq}[1]{[\,#1\,]}
-\newcommand{\ab}[1]{\langle#1\rangle}
-\newcommand{\ablarge}[1]{\langle \pile{#1\,\rangle}}
-\newcommand{\lb}{[\![}
-\newcommand{\rb}{]\!]}
-\newcommand{\db}[1]{\lb#1\rb}
-\newcommand{\ti}[1]{\mbox{{\it #1}}}
-\newcommand{\tr}[1]{\mbox{{\rm #1}}}
-\newcommand{\tb}[1]{\mbox{{\bf #1}}}
-\newcommand{\x}{\times}
-\newcommand{\lam}{\lambda}
-\newcommand{\kr}{\kappa_{\rho}}
-\newcommand{\syneq}{\rightarrow}
-% denotational semantics
-\newcommand{\denote}[3]{\[\ba{c} {\cal #1} : #2 \\[1 ex] #3 \ea\]}
-\newcommand{\den}[2]{{\cal #1}\db{#2}\,}
-
-\newcommand{\A}{\den{A}}
-\newcommand{\B}{\den{B}}
-\newcommand{\D}{\den{D}}
-\newcommand{\E}{\den{E}}
-\newcommand{\F}{\den{F}}
-\newcommand{\G}{\den{G}}
-\newcommand{\I}{\den{I}}
-%%% \renewcommand{\L}{\den{L}}
-\newcommand{\LE}{\den{L_E}}
-\newcommand{\LH}{\den{L_H}}
-\newcommand{\M}{\den{M}}
-%%% \renewcommand{\O}{\den{O}}
-\renewcommand{\P}{\den{P}}
-\newcommand{\Pbot}{\den{P_{\bot}}}
-\newcommand{\Q}{\den{Q}}
-\newcommand{\R}{\den{R}}
-\renewcommand{\S}{\den{S}}
-\newcommand{\V}{\den{V}}
-\newcommand{\W}{\den{W}}
-\newcommand{\T}[2]{\den{T}{#1}\,\db{#2}}
-% meta language
-\newcommand{\PP}{\den{P'}}
-\newcommand{\PS}{\den{P_S}}
-\newcommand{\otherwise}{\quad\tr{otherwise}}
-\newcommand{\case}[2]{\pile{
- \tr{case}\ (#1)\ \tr{of} \\
- \ba{@@{\quad}l@@{\ \ra\ }l@@{}} #2 \ea}}
-\newcommand{\where}[2]{#1 \quad\tr{where}\quad #2}
-\newcommand{\wherelarge}[2]{\pile{#1 \\ \tr{where} \\ \eqn{#2}}}
-\newcommand{\cond}[3]{#1 \ra #2,\ #3}
-\newcommand{\condlarge}[1]{\ba[t]{@@{}l@@{\ \ra\ }l@@{}} #1 \ea}
-\newcommand{\range}[2]{{}_{#1}^{#2}\,}
-% semantic operators
-\newcommand{\concat}{\frown}
-\newcommand{\seq}[1]{\ti{List}\ #1}
-\newcommand{\opt}[1]{\widetilde{#1}}
-\newcommand{\ov}{\opt{v}}
-\newcommand{\fail}{\ti{none}}
-\newcommand{\nonfail}{\ti{proper}}
-\newcommand{\sym}{\bigtriangledown}
-\newcommand{\pri}{\mathbin{\vec{\sym}}}
-\newcommand{\mrg}{\mathbin{\dot{\sym}}}
-\newcommand{\Sym}{\mathbin{\nabla}}
-\newcommand{\Pri}{\mathbin{\vec{\Sym}}}
-\newcommand{\Mrg}{\mathbin{\dot{\Sym}}}
-\newcommand{\optSym}{\mathbin{\opt{\Sym}}}
-\newcommand{\optodot}{\mathbin{\opt{\odot}}}
-\newcommand{\proj}{\mid}
-\newcommand{\restrict}{\setminus}
-\newcommand{\sel}[4]{\ti{sel}_{#3#2}\ #4}
-\newcommand{\bindnone}{\ti{bindnone}}
-\newcommand{\bindvar}[2]{\ti{bindvar}\ \db{#1}\ #2}
-\newcommand{\bindcon}[2]{\ti{bindcon}\ \db{#1}\ #2}
-\newcommand{\bindconlarge}[4]{
- #4\ \bindcon{#1}{\ablarge{ #2, \\ #3}}}
-\newcommand{\bindmod}[2]{\ti{bindmod}\ \db{#1}\ #2}
-
-\newcommand{\lookupval}[2]{\ti{lookupval}\ #1\ \db{#2}} %%% NEW
-\newcommand{\lookupcon}[1]{\ti{lookupcon}\ \db{#1}} %%% NEW
-\newcommand{\lookupdecon}[2]{\ti{lookupdecon}\ #1\ \db{#2}} %%% NEW
-
-% used in static.verb
-\newcommand{\TT}{\den{T_T}}
-\newcommand{\TA}{\den{T_A}}
-\newcommand{\TB}{\den{T_B}}
-\newcommand{\TD}{\den{T_D}}
-\newcommand{\TDA}{\den{T_{D_A}}}
-\newcommand{\TDB}{\den{T_{D_B}}}
-\newcommand{\TDP}{\den{T_{P_D}}}
-\newcommand{\TE}{\den{T_E}}
-\newcommand{\TLE}{\den{T_{L_E}}}
-\newcommand{\TLH}{\den{T_{L_H}}}
-%%% \newcommand{\TG}{\den{T_G}}
-\newcommand{\TQ}{\den{T_Q}}
-%%% \newcommand{\TR}{\den{T_R}}
-\newcommand{\TF}{\den{T_F}}
-\newcommand{\TFA}{\den{T_F'}}
-\newcommand{\TP}{\den{T_P}}
-\newcommand{\TPP}{\den{T_P'}}
-\newcommand{\TPS}{\den{T_{PS}}}
-\newcommand{\MGU}{\ti{MGU}}
-\newcommand{\TI}{\den{T_I}}
-\newcommand{\TL}{\den{T_L}}
-\newcommand{\TM}{\den{T_M}}
-%%% \newcommand{\TO}{\den{T_O}}
-\newcommand{\TS}{\den{T_S}}
-\newcommand{\TV}{\den{T_V}}
-\newcommand{\tenvm}{\ddot{\nabla}}
-\renewcommand{\tb}[1]{\triangleright#1\triangleleft}
-\newcommand{\unbindvar}[2]{\ti{unbindvar}\ \db{#1}\ #2}
-\newcommand{\unbindcon}[2]{\ti{unbindcon}\ \db{#1}\ #2}
-
-%
-% \newcommand{\bindnone}{\ab{[], []}}
-% \newcommand{\bindvar}[2]{\ab{[\,#1 \mapsto #2\,], []}}
-% \newcommand{\bindcon}[2]{\ab{[], [\,#1 \mapsto #2\,]}}
-% \newcommand{\bindconlarge}[4]{
-%  \langle [], [\,#1 \mapsto \langle \pile{#2 \\ #3 \rangle\,] #4 \rangle}}
-% \newcommand{\bindmod}[2]{[\,#1 \mapsto #2\,]}
-%
-% Haskell syntax macros: math mode assumed
-\newcommand{\system}[2]{#1@;;@\cdots@;;@#2}
-\newcommand{\module}[4]{module\ #1@:@\ #2\ #3\ #4}
-%%% \newcommand{\exportnone}{\,}
-%%% \newcommand{\export}[1]{@export@\ #1@;@}
-%%% \newcommand{\importnone}{\,}
-%%% \newcommand{\importcomb}[2]{#1\ #2}
-%%% \newcommand{\import}[1]{@import@\ #1@;@}
-%%% \newcommand{\importwith}[2]{@import@\ #1\ #2@;@}
-%%% \newcommand{\rename}[2]{#1@<-@#2}
-%%% \newcommand{\declcomb}[2]{#1\ @;;@\ #2}
-\newcommand{\exposing}[1]{@expose@\ #1}
-\newcommand{\hiding}[1]{@hide@\ #1}
-\newcommand{\importnone}{\;}
-\newcommand{\importcomb}[2]{#1\ @;;@\ #2}
-\newcommand{\import}[2]{@import@\ #1\ #2}
-\newcommand{\rename}[2]{#1\ @=@\ #2}
-\newcommand{\declcomb}[2]{#1\ @;;@\ #2}
-
-\newcommand{\type}[2]{@type@\ #1\ @=@\;#2}
-\newcommand{\data}[2]{@data@\ #1\ @=@\;#2}
-\newcommand{\tuple}[2]{@tuple@\ #1\ @=@\;#2} %%% NEW!
-\newcommand{\view}[3]{@view@\ #1\ @=@\;#2\ @where@\ @{@\ #3\ @}@}
-\newcommand{\class}[2]{@class@\ #1\ @where@\ @{@\ #2\ @}@}
-\newcommand{\instance}[2]{@instance@\ #1\ @where@\ @{@\ #2\ @}@}
-\newcommand{\signature}[2]{#1\ @::@\ #2}
-\newcommand{\binding}[2]{#1\ @=@\ #2}
-\newcommand{\lamexpr}[2]{@\@ #1 @->@ #2}
-% While lambda defs. change...  if change, take care of preceding line MMG
-\newcommand{\lamb}{@\ @}
-\newcommand{\whereexpr}[2]{#1\ @where@\ @{@\ #2\ @}@}
-\newcommand{\compexpr}[2]{@[@#1\ @|@\ #2@]@}
-\newcommand{\genclause}[2]{#1\ @<-@\ #2}
-\newcommand{\qualcomb}[2]{#1\ @,@\ #2}
-\newcommand{\genguard}[1]{\ #1\ }
-\newcommand{\caseexpr}[2]{@case@\ #1\ @of@\ @{@\ #2\ @}@}
-\newcommand{\simplecaseexpr}[5]{@case@\ #1\ @of@\ @{@\ #2\ @->@\ #3;\ #4\ @->@\ #5\ @}@} 
-\newcommand{\iteexpr}[3]{@if@\ #1\ @then@\ #2\ @else@\ #3}
-\newcommand{\itexpr}[2]{@if@\ #1\ @then@\ #2}
-\newcommand{\gpat}[2]{#1\ @|@\ #2}
-\newcommand{\aspat}[2]{#1 @ @@ @ #2}
-\newcommand{\fclause}[2]{#1\ @=@\ #2}
-\newcommand{\fsym}[2]{#1\ @;@\ #2}
-\newcommand{\fpri}[2]{#1\ @;@\ @else@\ @;@\ #2}
-\newcommand{\aclause}[2]{#1\ @->@\ #2}
-\newcommand{\saclause}[4]{#1\ @->@\ #2;\ #3\ @->@\ #4}
-\newcommand{\asym}[2]{#1\ @;@\ #2}
-\newcommand{\apri}[2]{#1\ @;@\ @else@\ @;@\ #2}
-\newcommand{\dotted}[3]{#1\ #2\ \ldots\ #3}
-\newcommand{\functype}[2]{#1\ @->@\ #2}
-\newcommand{\predtype}[2]{#1\ @=>@ #2}
-\newcommand{\xp}{\dotted{x}{p_1}{p_n}}
-\newcommand{\xpg}{\dotted{x}{p_1}{p_n\ @{@\ g\ @}@}}
-\newcommand{\es}{e_1\ \ldots\ e_n}
-\newcommand{\ps}{p_1\ \ldots\ p_n}
-\newcommand{\vs}{v_1\ \ldots\ v_n} %%% NEW
-\newcommand{\xs}{x_1\ \ldots\ x_n} %%% NEW
-\newcommand{\cT}{\dotted{c}{T_1}{T_n}}
-\newcommand{\cTm}{\dotted{c_i}{T_{i1}}{T_{in_i}}\, @|@\range{i=1}{m}}
-% syntax meta-language
-\newcommand{\arity}[1]{\tr{arity}\ #1}
-\newcommand{\infix}[1]{\tr{infix}\ #1}
-\newcommand{\prefix}[1]{\tr{prefix}\ #1}
-%
-\newcommand{\tl}[1]{{\sc #1}}
-%OLD: \newcommand{\Haskell}{{\sc Haskell}}
-\newcommand{\Haskell}{Haskell}
-
-%\newcommand{\subsubsubsection}[1]{\par\noindent{\it #1}}
-\newcommand{\subsubsubsection}{\subsubsection*}
-
-\sloppy
-
-% a few hyphenation patterns, anyone?
-\hyphenation{da-ta-type da-ta-types}
-\hyphenation{Has-kell}
-
-
-\begin{document}
-
-
-% Set the float fractions to sensible values
-\setcounter{topnumber}{2}
-\setcounter{bottomnumber}{0}
-\setcounter{totalnumber}{2}
-\setcounter{dbltopnumber}{2}
-\renewcommand{\textfraction}{0.1}
-\renewcommand{\floatpagefraction}{0.9}
-\renewcommand{\dblfloatpagefraction}{0.9}
-
-\setcounter{page}{0}
-
-\begin{titlepage}
-
-\setcounter{page}{0}
-
-\outline{
-\vspace{.3in}
-\begin{center}
-{\LARGE\bf Standard Libraries} \\[.1in]
-{\Large\bf for the} \\[.1in]
-{\huge\bf Haskell 98} \\[.3in]
-{\LARGE\bf Programming Language} \\[.3in]
-{\large\bf Revised: Sept 2002}
-\end{center}
-
-\vspace{.15in}
-\begin{center} \large
-\begin{tabular}{l@@{\hspace{5mm}}l}
-Simon Peyton Jones$^8$ [editor] & Lennart Augustsson$^9$ \\
-Dave Barton$^7$                & Brian Boutel$^4$ \\
-Warren Burton$^5$              & Joseph Fasel$^6$ \\
-Kevin Hammond$^2$              & Ralf Hinze$^{12}$  \\
-Paul Hudak$^1$                         & John Hughes$^3$ \\
-Thomas Johnsson$^3$            & Mark Jones$^{14}$ \\
-John Launchbury$^{14}$                 & Erik Meijer$^{10}$ \\
-John Peterson$^1$              & Alastair Reid$^{15}$ \\
-Colin Runciman$^{13}$          & Philip Wadler$^{11}$
-\end{tabular}
-\end{center}
-\vspace{.15in}
-
-\begin{quotation} \noindent
-Authors' affiliations:
-(1)~Yale University
-(2)~University of St.~Andrews
-(3)~Chalmers University of Technology
-(4)~Victoria University of Wellington
-(5)~Simon Fraser University
-(6)~Los Alamos National Laboratory
-(7)~Intermetrics
-(8)~Microsoft Research, Cambridge
-(9)~Sandburst Corporation
-(10)~Microsoft Corporation
-(11)~Avaya Labs
-(12)~University of Bonn
-(13)~York University
-(14)~Oregon Graduate Institute
-(15)~University of Utah
-\end{quotation}
-\vspace{.2in}
-\begin{center}
-Copyright (c) Simon Peyton Jones. 
-\end{center}
-
-{\em The authors intend this Report to belong to the entire Haskell
-community, and so we grant permission to copy and distribute it for
-any purpose, provided that it is reproduced in its entirety,
-including this Notice. Modified versions of this Report may also be
-copied and distributed for any purpose, provided that the modified
-version is clearly presented as such, and that it does not claim to be
-a definition of the language Haskell 98.}
-}
-
-\end{titlepage}
-
-\tableofcontents
-\startnewstuff
-
-\sloppy
-\setlength{\parskip}{0.25cm}
-\setlength{\parsep}{0.25cm}
-\setlength{\topsep}{0cm}
-\setlength{\parindent}{0cm}
-\renewcommand{\textfraction}{0.2}
-\renewcommand{\floatpagefraction}{0.7}
-% \parskip=6pt plus2pt minus2pt
-
-%\markboth{\rm \thepage\hfil \sl \leftmark}{{\sl \rightmark}\hfil \rm\thepage}
-\pagestyle{headings}
-\startnewstuff
-\pagenumbering{arabic}
-
-\input{introduction}\startnewsection
-\input{ratio}\startnewsection
-\input{complex}\startnewsection
-\input{numeric}\startnewsection
-\input{ix}\startnewsection
-\input{array}\startnewsection
-\input{list}\startnewsection
-\input{maybe}\startnewsection
-\input{char}\startnewsection
-\input{monad}\startnewsection
-\input{io}\startnewsection
-\input{directory}\startnewsection
-\input{system}\startnewsection
-\input{time}\startnewsection
-\input{locale}\startnewsection
-\input{cputime}\startnewsection
-\input{random}\startnewsection
-% \input{bit}\startnewsection
-% \input{nat}\startnewsection
-% \input{signed}\startnewsection
-%\input{interrupt}\startnewsection
-
-% There's no extra indexing stuff yet.
-% \startnewstuff
-% insert the extra indexing things LAST
-% \input{index-extra}
-
-% There's currently no bibliography!  -- jcp
-
-% Add a contents line for the References -- may be off by one page
-%\addcontentsline{toc}{section}{References}
-% \bibliographystyle{plain}
-% \bibliography{library}
-%
-\startnewstuff
-\printindex
-\end{document}
-
-% Local Variables: 
-% mode: latex
-% End:
diff --git a/libraries/list.verb b/libraries/list.verb
deleted file mode 100644 (file)
index 72d57f9..0000000
+++ /dev/null
@@ -1,273 +0,0 @@
-%**<title>The Haskell 98 Library Report: List Utilities</title>
-%**~header
-\section{List Utilities}
-
-\outline{
-\inputHS{headers/List}
-}
-\outline{
-\inputHS{headers/List1}
-}
-
-This library defines some lesser-used operations over lists.
-
-\subsection{Indexing lists}
-
-\begin{itemize}
-\item @elemIndex val list@\indextt{elemIndex} returns the index of
-the first occurrence, if any, of @val@  
-in @list@ as @Just index@.  @Nothing@ is returned if @not (val `elem` list)@.
-
-\item @elemIndices val list@\indextt{elemIndices} returns an
-in-order list of indices, giving the occurrences of @val@ in @list@.
-
-\item  @find@\indextt{find} 
-returns the first element of a list that satisfies a predicate,
-or Nothing, if there is no such element.
-@findIndex@ returns the corresponding index.
-@findIndices@ returns a list of all such indices.
-\end{itemize}
-
-\subsection{``Set'' operations}
-
-There are a number of ``set'' operations defined over the @List@ type.
-@nub@ (meaning ``essence'') removes duplicates elements from a list.
-@delete@, @(\\)@, @union@ and @intersect@ (and their @By@ variants) 
-preserve the invariant their result
-does not contain duplicates, provided that their first argument
-contains no duplicates.
-
-\begin{itemize}
-\item 
-@nub@\indextt{nub} removes duplicate elements from a list. For example:
-\bprog
-@
-  nub [1,3,1,4,3,3] = [1,3,4]
-@
-\eprog
-\item
-@delete x@\indextt{delete} 
-removes the first occurrence of @x@ from its list argument,
-e.g.,  
-\bprog
-@
-  delete 'a' "banana" == "bnana"
-@
-\eprog
-
-\item
-@(\\)@\indextt{(\\)} is list 
-difference (non-associative).  In the result of @xs \\ ys@,
-the first occurrence of each element of @ys@ in turn (if any)
-has been removed from @xs@.  Thus, @(xs ++ ys) \\ xs == ys@.
-
-\item 
-@union@\indextt{union} is list union, e.g., 
-\bprog
-@
-  "dog" `union` "cow" == "dogcw"
-@
-\eprog
-
-\item
-@intersect@\indextt{intersect} is list intersection, e.g.,  
-\bprog
-@
-  [1,2,3,4] `intersect` [2,4,6,8] == [2,4]
-@
-\eprog
-\end{itemize}
-
-\subsection{List transformations}
-
-\begin{itemize}
-\item
-@intersperse sep@\indextt{intersperse} 
-inserts @sep@ between the elements of its list argument,
-e.g.,  
-\bprog
-@
-  intersperse ',' "abcde" == "a,b,c,d,e"
-@
-\eprog
-
-\item
-@transpose@\indextt{transpose} transposes the rows and columns of its argument,
-e.g., 
-\bprog
-@
-  transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]
-@
-\eprog
-
-\item
-@partition@\indextt{partition} 
-takes a predicate and a list and returns a pair of lists:
-those elements of the argument list that do and do not satisfy the
-predicate, respectively; i.e.,
-\bprog
-@
-  partition p xs == (filter p xs, filter (not . p) xs)
-@
-\eprog
-
-\item
-@sort@\indextt{sort}
-implement a stable sorting algorithm, here specified
-in terms of the @insertBy@ function, which inserts objects into a list
-according to the specified ordering relation.
-
-\item
-@insert@\indextt{insert}
-inserts a new element into an {\em ordered} list (arranged in increasing order).
-
-\item
-@group@\indextt{group} splits its list argument into a list of lists of equal, adjacent
-elements. For example
-\bprog
-@
-  group "Mississippi" == ["M","i","ss","i","ss","i","pp","i"]
-@
-\eprog
-
-\item
-@inits@\indextt{inits} returns the list of initial segments of its argument list, shortest first.
-\bprog
-@
-  inits "abc" == ["","a","ab","abc"]
-@
-\eprog
-
-\item
-@tails@\indextt{tails} 
-returns the list of all final segments of its argument list, longest first.
-\bprog
-@
-  tails "abc" == ["abc", "bc", "c",""]
-@
-
-\eprog
-\item
-@mapAccumL f s l@\indextt{mapAccumL} 
-applies @f@ to an accumulating ``state'' parameter @s@
-and to each element of @l@ in turn.
-
-\item
-@mapAccumR@\indextt{mapAccumR}
-is similar to @mapAccumL@ except that the list
-is processed from right-to-left rather than left-to-right.
-\end{itemize}
-
-\subsection{@unfoldr@}
-
-The @unfoldr@ function is a `dual' to @foldr@: while @foldr@ reduces a list
-to a summary value, @unfoldr@ builds a list from a seed value.  For 
-example:
-\bprog
-@
-  iterate f == unfoldr (\x -> Just (x, f x))
-@
-\eprog
-In some cases, @unfoldr@ can undo a @foldr@ operation:
-\bprog
-@
-  unfoldr f' (foldr f z xs) == xs
-@
-\eprog
-if the following holds:
-\bprog
-@
-  f' (f x y) = Just (x,y)
-  f' z       = Nothing
-@
-\eprog
-
-\subsection{Predicates}
-
-@isPrefixOf@ and @isSuffixOf@ check whether the first argument is a prefix (resp. suffix)
-of the second argument.
-
-
-\subsection{The ``@By@'' operations}
-
-By convention, overloaded functions have a non-overloaded
-counterpart whose name is suffixed with ``@By@''.  For example, the
-function @nub@ could be defined as follows:
-\bprog
-@
-  nub              :: (Eq a) => [a] -> [a]
-  nub []           =  []
-  nub (x:xs)       =  x : nub (filter (\y -> not (x == y)) xs)
-@
-\eprog
-However, the equality method may not be appropriate in all situations.
-The function:
-\bprog
-@
-  nubBy            :: (a -> a -> Bool) -> [a] -> [a]
-  nubBy eq []      =  []
-  nubBy eq (x:xs)  =  x : nubBy eq (filter (\y -> not (eq x y)) xs)
-@
-\eprog
-allows the programmer to supply their own equality test.
-When the ``@By@'' function replaces an @Eq@ context by a binary predicate,
-the predicate is assumed to define an equivalence; when the ``@By@''
-function replaces an @Ord@ context by a binary predicate, the
-predicate is assumed to define a total ordering.
-
-The ``@By@'' variants are as follows:
-@nubBy@, @deleteBy@, @deleteFirstsBy@ (the "@By@" variant of @\\@),
-@unionBy@, @intersectBy@, @groupBy@,
-@sortBy@, @insertBy@, @maximumBy@, @minimumBy@.  
-\indextt{nubBy} 
-\indextt{deleteBy} 
-\indextt{deleteFirstsBy} 
-\indextt{unionBy} 
-\indextt{intersectBy} 
-\indextt{groupBy} 
-\indextt{sortBy} 
-\indextt{insertBy} 
-\indextt{maximumBy} 
-\indextt{minimumBy} 
-
-The library does not
-provide @elemBy@, because @any (eq x)@ does the same job as @elemBy eq x@ would.
-A handful of overloaded functions (@elemIndex@, @elemIndices@, @isPrefixOf@, @isSuffixOf@)
-were not considered important enough to have ``@By@'' variants.
-
-% Several of the functions defined here are derivatives of, or
-% related to, Prelude functions.  These functions are
-% @elem@, @maximum@, @minimum@, @zip@, @zip3@, @zipWith@,
-% @zipWith3@, @unzip@, @unzip3@, 
-% [according to Keith] @take@, @drop@, @splitAt@, @index@, @replicate@.
-
-\subsection{The ``@generic@'' operations}
-
-The prefix ``@generic@'' indicates an overloaded function that is
-a generalised version of a @Prelude@ function.  For example,
-\bprog
-@
-  genericLength       :: Integral a => [b] -> a
-@ 
-\eprog
-is a generalised version of @length@.
-
-The ``@generic@'' operations are as follows:
-@genericLength@, @genericTake@, @genericDrop@,
-    @genericSplitAt@, @genericIndex@ (the generic version of @!!@), @genericReplicate@.
-
-
-\subsection{Further ``@zip@'' operations}
-
-The Prelude provides @zip@, @zip3@, @unzip@, @unzip3@, @zipWith@, and @zipWith3@.
-The List library provides these same three operations for 4, 5, 6, and 7 a