Commit 404513d3 authored by rrt's avatar rrt
Browse files

[project @ 2000-01-12 18:05:49 by rrt]

Libraries documentation moved to hslibs tree.
parent 4d0f412f
......@@ -204,7 +204,7 @@ Assertion failures now raise an <Constant>AssertionFailed</Constant> exception.
<ListItem>
<Para>
Added simple high-level interface to the Regex library, see <XRef LinkEnd="RegexString">.
Added simple high-level interface to the Regex library, see the libraries manual.
</Para>
</ListItem>
......
<Sect2 id="sec-byte-array">
<Title>The ByteArray
<IndexTerm><Primary>ByteArray</Primary></IndexTerm>
interface
</Title>
<Para>
<IndexTerm><Primary>ByteArray interface (GHC extensions)</Primary></IndexTerm>
</Para>
<Para>
<Literal>ByteArray</Literal>s are chunks of immutable Haskell heap:
</Para>
<Para>
<ProgramListing>
data ByteArray ix -- abstract
-- instance of: Eq, CCallable.
newByteArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (ByteArray ix)
indexCharArray :: Ix ix =&#62; ByteArray ix -&#62; ix -&#62; Char
indexIntArray :: Ix ix =&#62; ByteArray ix -&#62; ix -&#62; Int
indexAddrArray :: Ix ix =&#62; ByteArray ix -&#62; ix -&#62; Addr
indexFloatArray :: Ix ix =&#62; ByteArray ix -&#62; ix -&#62; Float
indexDoubleArray :: Ix ix =&#62; ByteArray ix -&#62; ix -&#62; Double
sizeofByteArray :: Ix ix =&#62; ByteArray ix -&#62; Int
</ProgramListing>
<IndexTerm><Primary>newByteArray</Primary></IndexTerm>
<IndexTerm><Primary>indexCharArray</Primary></IndexTerm>
<IndexTerm><Primary>indexIntArray</Primary></IndexTerm>
<IndexTerm><Primary>indexAddrArray</Primary></IndexTerm>
<IndexTerm><Primary>indexFloatArray</Primary></IndexTerm>
<IndexTerm><Primary>indexDoubleArray</Primary></IndexTerm>
<IndexTerm><Primary>indexDoubleArray</Primary></IndexTerm>
<IndexTerm><Primary>sizeofByteArray</Primary></IndexTerm>
</Para>
<Para>
<Emphasis>Remarks:</Emphasis>
</Para>
<Para>
<ItemizedList>
<ListItem>
<Para>
The operation <Function>newByteArray</Function> creates a byte array of length
equal to the range of its indices <Emphasis>in bytes</Emphasis>.
</Para>
</ListItem>
<ListItem>
<Para>
<Function>sizeofByteArray</Function> returns the size of the byte array, <Emphasis>in bytes</Emphasis>.
</Para>
</ListItem>
<ListItem>
<Para>
Equality on byte arrays is value equality, not pointer equality (as is
the case for its mutable variant.) Two byte arrays are equal if
they're of the same length and they're pairwise equal.
</Para>
</ListItem>
</ItemizedList>
</Para>
</Sect2>
<Sect2 id="MutableArray">
<Title>MutableArray
<IndexTerm><Primary>MutableArray</Primary></IndexTerm>
</Title>
<Para>
The <Literal>MutableArray</Literal> interface provide operations for reading and
writing values to mutable arrays. There's two kinds of
mutable arrays, the mutatable version of Haskell <Literal>Array</Literal>s
and <Emphasis>mutable byte arrays</Emphasis>, chunks of memory containing
values of some basic type.
</Para>
<Sect3 id="MutableArray-mutable-arrays">
<Title>Mutable arrays
<IndexTerm><Primary>Mutable arrays</Primary></IndexTerm>
</Title>
<Para>
The mutable array section of the API provides the following
operations:
</Para>
<Para>
<ProgramListing>
-- mutable arrays:
newArray :: Ix ix -&#62; (ix,ix) -&#62; elt -&#62; ST s (MutableArray s ix elt)
boundsOfArray :: Ix ix =&#62; MutableArray s ix elt -&#62; (ix, ix)
readArray :: Ix ix =&#62; MutableArray s ix elt -&#62; ix -&#62; ST s elt
writeArray :: Ix ix =&#62; MutableArray s ix elt -&#62; ix -&#62; elt -&#62; ST s ()
freezeArray :: Ix ix =&#62; MutableArray s ix elt -&#62; ST s (Array ix elt)
thawArray :: Ix ix =&#62; Array ix elt -&#62; ST s (MutableArray s ix elt)
unsafeFreezeArray :: Ix ix =&#62; MutableArray s ix elt -&#62; ST s (Array ix elt)
unsafeThawArray :: Ix ix =&#62; Array ix elt -&#62; ST s (MutableArray s ix elt)
</ProgramListing>
<IndexTerm><Primary>newArray</Primary></IndexTerm>
<IndexTerm><Primary>boundsOfArray</Primary></IndexTerm>
<IndexTerm><Primary>readArray</Primary></IndexTerm>
<IndexTerm><Primary>writeArray</Primary></IndexTerm>
<IndexTerm><Primary>freezeArray</Primary></IndexTerm>
<IndexTerm><Primary>thawArray</Primary></IndexTerm>
<IndexTerm><Primary>unsafeFreezeArray</Primary></IndexTerm>
<IndexTerm><Primary>unsafeThawArray</Primary></IndexTerm>
</Para>
<Para>
<Emphasis>Remarks:</Emphasis>
</Para>
<Para>
<ItemizedList>
<ListItem>
<Para>
The <Function>freezeArray</Function> action converts a mutable array into an
immutable one by copying, whereas <Function>unsafeFreezeArray</Function> returns
an immutable array that is effectively just the type cast version
of the mutable array. Should you write to the mutable array after
it has been (unsafely) frozen, you'll side-effect the immutable
array in the process. Please don't :-)
</Para>
</ListItem>
<ListItem>
<Para>
The operation <Function>thawArray</Function> goes the other way, converting
an immutable <Literal>Array</Literal> into a mutable one. This is done by
copying. The operation <Function>unsafeThawArray</Function> is also provided,
which places the same kind of proof obligation on the programmer
as <Function>unsafeFreezeArray</Function> does.
</Para>
</ListItem>
</ItemizedList>
</Para>
</Sect3>
<Sect3 id="MutableArray-mutable-byte-arrays">
<Title>Mutable byte arrays
<IndexTerm><Primary>Mutable byte arrays</Primary></IndexTerm>
</Title>
<Para>
<ProgramListing>
-- creators:
newCharArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
newAddrArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
newIntArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
newWordArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
newFloatArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
newDoubleArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
newStablePtrArray :: Ix ix =&#62; (ix,ix) -&#62; ST s (MutableByteArray s ix)
boundsOfMutableByteArray
:: Ix ix =&#62; MutableByteArray s ix -&#62; (ix, ix)
readCharArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Char
readIntArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Int
readAddrArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Addr
readFloatArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Float
readDoubleArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Double
readStablePtrArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s (StablePtr a)
readWord8Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Word8
readWord16Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Word16
readWord32Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Word32
readWord64Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Word64
readInt8Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Int8
readInt16Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Int16
readInt32Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Int32
readInt64Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; ST s Int64
writeCharArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Char -&#62; ST s ()
writeIntArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Int -&#62; ST s ()
writeAddrArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Addr -&#62; ST s ()
writeFloatArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Float -&#62; ST s ()
writeDoubleArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Double -&#62; ST s ()
writeStablePtrArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; StablePtr a -&#62; ST s ()
writeWord8Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Word8 -&#62; ST s ()
writeWord16Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Word16 -&#62; ST s ()
writeWord32Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Word32 -&#62; ST s ()
writeWord64Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Word64 -&#62; ST s ()
writeInt8Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Int8 -&#62; ST s ()
writeInt16Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Int16 -&#62; ST s ()
writeInt32Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Int32 -&#62; ST s ()
writeInt64Array :: Ix ix =&#62; MutableByteArray s ix -&#62; ix -&#62; Int64 -&#62; ST s ()
freezeCharArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
freezeIntArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
freezeAddrArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
freezeFloatArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
freezeDoubleArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
freezeStablePtrArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
unsafeFreezeByteArray :: Ix ix =&#62; MutableByteArray s ix -&#62; ST s (ByteArray ix)
sizeofMutableByteArray :: Ix ix =&#62; MutableByteArray s ix -&#62; Int
thawByteArray :: Ix ix =&#62; ByteArray ixt -&#62; ST s (MutableByteArray s ix)
unsafeThawByteArray :: Ix ix =&#62; ByteArray ixt -&#62; ST s (MutableByteArray s ix)
</ProgramListing>
<IndexTerm><Primary>newCharArray</Primary></IndexTerm>
<IndexTerm><Primary>newAddrArray</Primary></IndexTerm>
<IndexTerm><Primary>newIntArray</Primary></IndexTerm>
<IndexTerm><Primary>newFloatArray</Primary></IndexTerm>
<IndexTerm><Primary>newDoubleArray</Primary></IndexTerm>
<IndexTerm><Primary>boundsOfMutableByteArray</Primary></IndexTerm>
<IndexTerm><Primary>readCharArray</Primary></IndexTerm>
<IndexTerm><Primary>readIntArray</Primary></IndexTerm>
<IndexTerm><Primary>readAddrArray</Primary></IndexTerm>
<IndexTerm><Primary>readFloatArray</Primary></IndexTerm>
<IndexTerm><Primary>readDoubleArray</Primary></IndexTerm>
<IndexTerm><Primary>readWord8Array</Primary></IndexTerm>
<IndexTerm><Primary>readWord16Array</Primary></IndexTerm>
<IndexTerm><Primary>readWord32Array</Primary></IndexTerm>
<IndexTerm><Primary>readWord64Array</Primary></IndexTerm>
<IndexTerm><Primary>readInt8Array</Primary></IndexTerm>
<IndexTerm><Primary>readInt16Array</Primary></IndexTerm>
<IndexTerm><Primary>readInt32Array</Primary></IndexTerm>
<IndexTerm><Primary>readInt64Array</Primary></IndexTerm>
<IndexTerm><Primary>writeCharArray</Primary></IndexTerm>
<IndexTerm><Primary>writeIntArray</Primary></IndexTerm>
<IndexTerm><Primary>writeAddrArray</Primary></IndexTerm>
<IndexTerm><Primary>writeFloatArray</Primary></IndexTerm>
<IndexTerm><Primary>writeDoubleArray</Primary></IndexTerm>
<IndexTerm><Primary>writeWord8Array</Primary></IndexTerm>
<IndexTerm><Primary>writeWord16Array</Primary></IndexTerm>
<IndexTerm><Primary>writeWord32Array</Primary></IndexTerm>
<IndexTerm><Primary>writeWord64Array</Primary></IndexTerm>
<IndexTerm><Primary>writeInt8Array</Primary></IndexTerm>
<IndexTerm><Primary>writeInt16Array</Primary></IndexTerm>
<IndexTerm><Primary>writeInt32Array</Primary></IndexTerm>
<IndexTerm><Primary>writeInt64Array</Primary></IndexTerm>
<IndexTerm><Primary>freezeCharArray</Primary></IndexTerm>
<IndexTerm><Primary>freezeIntArray</Primary></IndexTerm>
<IndexTerm><Primary>freezeAddrArray</Primary></IndexTerm>
<IndexTerm><Primary>freezeFloatArray</Primary></IndexTerm>
<IndexTerm><Primary>freezeDoubleArray</Primary></IndexTerm>
<IndexTerm><Primary>unsafeFreezeByteArray</Primary></IndexTerm>
<IndexTerm><Primary>unsafeThawByteArray</Primary></IndexTerm>
<IndexTerm><Primary>thawByteArray</Primary></IndexTerm>
</Para>
<Para>
<Emphasis>Remarks:</Emphasis>
<ItemizedList>
<ListItem>
<Para>
A Mutable byte array is created by specifying its size in units of
some basic type. For example,
<ProgramListing>
mkPair :: ST s (MutableByteArray s Int)
mkPair = newIntArray (0,1)
</ProgramListing>
creates a mutable array capable of storing two <Literal>Int</Literal>s. Notice
that the range size <Emphasis>is not in bytes</Emphasis>, but in units of the
basic type.
</Para>
</ListItem>
<ListItem>
<Para>
A mutable byte array is not parameterised over the kind of values
it contains. A consequence of this is that it is possible to
have byte arrays containing a mix of basic types, or even read
a value from the array at a different type from which it was
written, e.g.,
<ProgramListing>
isLitteEndian :: IO Bool
isLitteEndian = stToIO $ do
x &#60;- newIntArray (0,1)
writeIntArray x 1
v &#60;- readCharArray x 0
return (v == chr 1)
</ProgramListing>
It's left as an exercise for the reader to determine whether having
byte arrays not be parameterised over the type of values they
contain is a bug or a feature..
</Para>
</ListItem>
<ListItem>
<Para>
As for mutable arrays, operations for turning mutable byte arrays
into immutable byte arrays are also provided by the <Function>freeze*</Function>
class of actions. There's also the non-copying
<Function>unsafeFreezeByteArray</Function>.
</Para>
</ListItem>
<ListItem>
<Para>
Operations for going the other way, where an immutable byte
array is 'thawed' are also provided. <Function>thawByteArray</Function> does
this by copying, whereas <Function>unsafeThawByteArray</Function> does not
</Para>
</ListItem>
<ListItem>
<Para>
The operation <Function>sizeofMutableByteArray</Function> returns the size of
the array, <Emphasis>in bytes.</Emphasis>
</Para>
</ListItem>
</ItemizedList>
</Para>
</Sect3>
</Sect2>
This diff is collapsed.
......@@ -91,17 +91,6 @@ flag).
</Sect1>
<Sect1>
<Title>GHC/Hugs Extension Libraries</Title>
<Para>
The extension libraries provided by both GHC and Hugs are described in
the
<ULink
URL="libs.html">GHC/Hugs Extension Library Document</ULink>
</Para>
</Sect1>
<Sect1>
<Title>GHC-only Extension Libraries</Title>
......@@ -120,73 +109,11 @@ Haskell report says (modulo a few minor issues, see <XRef LinkEnd="vs-Haskell-de
</Para>
<Para>
If you turn on <Option>-fglasgow-exts</Option>, a new world opesn up to you and the compiler
If you turn on <Option>-fglasgow-exts</Option>, a new world opens up to you and the compiler
will recognise and parse unboxed values properly, and provide access to the
various interfaces libraries described here (and piles of other goodies.)
</Para>
&mutablearray
&bytearray
<Sect2>
<Title>The <Literal>CCall</Literal> module</Title>
<Para>
The <Literal>CCall</Literal> module defines the classes <Literal>CCallable</Literal> and <Literal>CReturnable</Literal>,
along with instances for the primitive types (<Literal>Int</Literal>, <Literal>Int&num;</Literal>, <Literal>Float</Literal>,
<Literal>Float&num;</Literal> etc.) GHC knows to import this module if you use <Function>&lowbar;ccall&lowbar;</Function>,
but if you need to define your own instances of these classes, you
will need to import <Literal>CCall</Literal> explicitly.
</Para>
<Para>
More information on how to use <Function>&lowbar;ccall&lowbar;</Function> can be found in <XRef LinkEnd="glasgow-ccalls">.
</Para>
</Sect2>
<Sect2>
<Title>The <Literal>GlaExts</Literal> interface</Title>
<Para>
<IndexTerm><Primary>GlaExts interface (GHC extensions)</Primary></IndexTerm>
</Para>
<Para>
The <Literal>GlaExts</Literal> interface provides access to extensions that only GHC
implements. These currently are: unboxed types, including the
representations of the primitive types (Int, Float, etc.), and the
GHC primitive operations (<Function>+&num;</Function>, <Function>==&num;</Function>, etc.).
</Para>
<Para>
This module used to provide access to all the Glasgow extensions, but
these have since been moved into separate libraries for compatibility
with Hugs (version 2.09: in fact, you can still get at this stuff via
<Literal>GlaExts</Literal> for compatibility, but this facility will likely be removed
in the future).
</Para>
<Para>
<ProgramListing>
-- the representation of some basic types:
data Char = C# Char#
data Int = I# Int#
data Addr = A# Addr#
data Word = W# Word#
data Float = F# Float#
data Double = D# Double#
data Integer = S# Int# -- small integers
| J# Int# ByteArray# -- large integers
module GHC -- all primops and primitive types.
</ProgramListing>
</Para>
</Sect2>
</Sect1>
<Sect1 id="ghc-libs-ghc">
......@@ -337,9 +264,6 @@ allocation during sequences of operations.
<IndexTerm><Primary>numeric types, primitive</Primary></IndexTerm>
<IndexTerm><Primary>integer types, primitive</Primary></IndexTerm>
<IndexTerm><Primary>floating point types, primitive</Primary></IndexTerm>
</Para>
<Para>
There are the following obvious primitive types:
</Para>
......@@ -989,16 +913,12 @@ realWorld# :: State# RealWorld
</Sect2>
<Sect2>
<Sect2 id="sect-mutable">
<Title>Mutable arrays</Title>
<Para>
<Anchor id="sect-mutable">
<IndexTerm><Primary>mutable arrays</Primary></IndexTerm>
<IndexTerm><Primary>arrays, mutable</Primary></IndexTerm>
</Para>
<Para>
Corresponding to <Literal>Array&num;</Literal> and <Literal>ByteArray&num;</Literal>, we have the types of
mutable versions of each. In each case, the representation is a
pointer to a suitable block of (mutable) heap-allocated storage.
......@@ -1152,119 +1072,6 @@ unsafeFreezeByteArray# :: MutableByteArray# s -&#62; State# s -&#62; (# State# s
</Sect2>
<Sect2>
<Title>Stable pointers</Title>
<Para>
<IndexTerm><Primary>stable pointers</Primary></IndexTerm>
<IndexTerm><Primary>pointers, stable</Primary></IndexTerm>
</Para>
<Para>
A stable pointer is a name for a Haskell object which can be passed to
the external world. It is ``stable'' in the sense that the name does
not change when the Haskell garbage collector runs&mdash;in contrast to
the address of the object which may well change.
</Para>
<Para>
The stable pointer type is parameterised by the type of the thing
which is named.
</Para>
<Para>
<ProgramListing>
type StablePtr# a
</ProgramListing>
<IndexTerm><Primary><literal>StablePtr&num;</literal></Primary></IndexTerm>
</Para>
<Para>
A stable pointer is represented by an index into the (static)
<Literal>StablePointerTable</Literal>. The Haskell garbage collector treats the
<Literal>StablePointerTable</Literal> as a source of roots for GC.
</Para>
<Para>
The <Function>makeStablePointer</Function> function converts a value into a stable
pointer. It is part of the <Literal>IO</Literal> monad, because we want to be sure
we don't allocate one twice by accident, and then only free one of the
copies.
</Para>
<Para>
<ProgramListing>
makeStablePointer# :: a -&#62; State# RealWorld -&#62; (# State# RealWord, StablePtr# a #)
freeStablePointer# :: StablePtr# a -&#62; State# RealWorld -&#62; State# RealWorld
deRefStablePointer# :: StablePtr# a -&#62; State# RealWorld -&#62; (# State# RealWorld, a #)
</ProgramListing>
<IndexTerm><Primary><literal>makeStablePointer&num;</literal></Primary></IndexTerm>
<IndexTerm><Primary><literal>freeStablePointer&num;</literal></Primary></IndexTerm>
<IndexTerm><Primary><literal>deRefStablePointer&num;</literal></Primary></IndexTerm>
</Para>
<Para>
There is also a C procedure <Function>FreeStablePtr</Function> which frees a stable pointer.
</Para>
</Sect2>
<Sect2>
<Title>Foreign objects</Title>
<Para>
<IndexTerm><Primary>Foreign objects</Primary></IndexTerm>
</Para>
<Para>
A <Literal>ForeignObj&num;</Literal> is a reference to an object outside the Haskell world
(i.e., from the C world, or a reference to an object on another
machine completely.), where the Haskell world has been told ``Let me
know when you're finished with this&hellip;''.
</Para>
<Para>
<ProgramListing>
type ForeignObj#
</ProgramListing>
<IndexTerm><Primary><literal>ForeignObj&num;</literal></Primary></IndexTerm>
</Para>
<Para>
GHC provides two primitives on <Literal>ForeignObj&num;</Literal>:
</Para>
<Para>
<ProgramListing>
makeForeignObj#
:: Addr# -- foreign reference
-&#62; Addr# -- pointer to finalisation routine
-&#62; (# State# RealWorld, ForeignObj# )
writeForeignObj
:: ForeignObj# -- foreign object
-&#62; Addr# -- datum
-&#62; State# RealWorld
-&#62; State# RealWorld
</ProgramListing>
<IndexTerm><Primary><literal>makeForeignObj&num;</literal></Primary></IndexTerm>
<IndexTerm><Primary><literal>writeForeignObj&num;</literal></Primary></IndexTerm>
</Para>
<Para>
The module <Literal>Foreign</Literal> (see library documentation) provides a more
programmer-friendly interface to foreign objects.
</Para>
</Sect2>
<Sect2>
<Title>Synchronizing variables (M-vars)</Title>
......@@ -1299,7 +1106,4 @@ putMVar# :: SynchVar# s elt -&#62; State# s -&#62; State# s
</Sect1>
&posix
&libmisc
</Chapter>
This diff is collapsed.
......@@ -11,13 +11,9 @@
<!ENTITY glaexts SYSTEM "glasgow_exts.sgml" >
<!ENTITY parallel SYSTEM "parallel.sgml" >
<!ENTITY vs-hs SYSTEM "vs_haskell.sgml" >
<!ENTITY libs SYSTEM "libraries.sgml" >
<!ENTITY posix SYSTEM "posix.sgml" >
<!ENTITY libmisc SYSTEM "libmisc.sgml" >
<!ENTITY wrong SYSTEM "gone_wrong.sgml" >
<!ENTITY libraries SYSTEM "libraries.sgml" >
<!ENTITY utils SYSTEM "utils.sgml" >
<!ENTITY mutablearray SYSTEM "MutableArray.sgml">
<!ENTITY bytearray SYSTEM "ByteArray.sgml">
<!ENTITY win32-dll SYSTEM "win32-dlls.sgml">
]>
<Book>
......@@ -36,8 +32,8 @@
&prof
&sooner
&lang
&libs
&wrong
&libraries
&utils
&win32-dll
......
Markdown is supported
0% or .