|
|
|
|
Synopsis |
|
|
|
Documentation |
|
|
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
handle: a record used by the Haskell run-time system to manage I/O
with file system objects. A handle has at least the following properties:
- whether it manages input or output or both;
- whether it is open, closed or semi-closed;
- whether the object is seekable;
- whether buffering is disabled, or enabled on a line or block basis;
- a buffer (whose length may be zero).
Most handles will also have a current I/O position indicating where the next
input or output operation will occur. A handle is readable if it
manages only input or both input and output; likewise, it is writable if
it manages only output or both input and output. A handle is 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.
GHC note: a Handle will be automatically closed when the garbage
collector detects that it has become unreferenced by the program.
However, relying on this behaviour is not generally recommended:
the garbage collector is unpredictable. If possible, use explicit
an explicit hClose to close Handles when they are no longer
required. GHC does not currently attempt to free up file
descriptors when they have run out, it is your responsibility to
ensure that this doesn't happen.
|
|
|
HandlePosn |
|
IOMode |
|
|
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 flushed,
from the internal buffer according to the buffer mode:
- line-buffering: the entire output buffer is flushed
whenever a newline is output, the buffer overflows,
a System.IO.hFlush is issued, or the handle is closed.
- block-buffering: the entire buffer is written out whenever it
overflows, a System.IO.hFlush is issued, or the handle is closed.
- no-buffering: output is written immediately, and never stored
in the buffer.
An implementation is free to flush the buffer more frequently,
but not less frequently, than specified above.
The output buffer is emptied as soon as it has been written out.
Similarly, input occurs according to the buffer mode for the handle:
- line-buffering: when the buffer for the handle is not empty,
the next item is obtained from the buffer; otherwise, when the
buffer is empty, characters up to and including the next newline
character are read into the buffer. No characters are available
until the newline character is available or the buffer is full.
- block-buffering: when the buffer for the handle becomes empty,
the next block of data is read into the buffer.
- no-buffering: the next input item is read and returned.
The System.IO.hLookAhead operation implies that even a no-buffered
handle may require a one-character buffer.
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.
For most implementations, physical files will normally be block-buffered
and terminals will normally be line-buffered.
| Constructors | NoBuffering | buffering is disabled if possible.
| LineBuffering | line-buffering should be enabled if possible.
| BlockBuffering (Maybe Int) | block-buffering should be enabled if possible.
The size of the buffer is n items if the argument
is Just n and is otherwise implementation-dependent.
|
|
|
|
SeekMode |
|
stdin |
|
stdout |
|
stderr |
|
openFile |
|
hClose |
|
hFileSize |
|
hIsEOF |
|
isEOF |
|
hSetBuffering |
|
hGetBuffering |
|
hFlush |
|
hGetPosn |
|
hSetPosn |
|
hSeek |
|
hWaitForInput |
|
|
Computation hReady hdl indicates whether at least one item is
available for input from handle hdl.
This operation may fail with:
- System.IO.Error.isEOFError if the end of file has been reached.
|
|
hGetChar |
|
hGetLine |
|
hLookAhead |
|
hGetContents |
|
hPutChar |
|
hPutStr |
|
|
The same as hPutStr, but adds a newline character.
|
|
|
Computation hPrint hdl t writes the string representation of t
given by the shows function to the file or channel managed by hdl
and appends a newline.
This operation may fail with:
- System.IO.Error.isFullError if the device is full; or
- System.IO.Error.isPermissionError if another system resource limit would be exceeded.
|
|
hIsOpen |
|
hIsClosed |
|
hIsReadable |
|
hIsWritable |
|
hIsSeekable |
|
|
An error indicating that an IO operation failed because
one of its arguments already exists.
|
|
|
An error indicating that an IO operation failed because
one of its arguments does not exist.
|
|
|
An error indicating that an IO 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).
|
|
|
An error indicating that an IO operation failed because
the device is full.
|
|
|
An error indicating that an IO operation failed because
the end of file has been reached.
|
|
|
An error indicating that an IO operation failed because
the operation was not possible.
Any computation which returns an IO result may fail with
isIllegalOperation. In some cases, an implementation will not be
able to distinguish between the possible error causes. In this case
it should fail with isIllegalOperation.
|
|
|
An error indicating that an IO operation failed because
the user does not have sufficient operating system privilege
to perform that operation.
|
|
|
A programmer-defined error value constructed using userError.
|
|
|
|
|
|
|
|
|
The construct try comp exposes IO errors which occur within a
computation, and which are not fully handled.
Non-I/O exceptions are not caught by this variant; to catch all
exceptions, use Control.Exception.try from Control.Exception.
|
|
|
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.
This version handles only IO errors, as defined by Haskell 98.
The version of bracket in Control.Exception handles all exceptions,
and should be used instead.
|
|
|
A variant of bracket where the middle computation doesn't want x.
This version handles only IO errors, as defined by Haskell 98.
The version of bracket_ in Control.Exception handles all exceptions,
and should be used instead.
|
|
|
A value of type IO a is a computation which, when performed,
does some I/O before returning a value of type a.
There is really only one way to "perform" an I/O action: bind it to
Main.main in your program. When your program is run, the I/O will
be performed. It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO monad and called
at some point, directly or indirectly, from Main.main.
IO is a monad, so IO actions can be combined using either the do-notation
or the >> and >>= operations from the Monad class.
|
|
|
|
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.
|
|
|
The Haskell 98 type for exceptions in the IO monad.
Any I/O operation may raise an IOError instead of returning a result.
For a more general type of exception, including also those that arise
in pure code, see Control.Exception.Exception.
In Haskell 98, this is an opaque type.
|
|
|
Raise an IOError in the IO monad.
|
|
|
Construct an IOError value with a string describing the error.
The fail method of the IO instance of the Monad class raises a
userError, thus:
instance Monad IO where
...
fail s = ioError (userError s)
|
|
|
The catch function establishes a handler that receives any IOError
raised in the action protected by catch. An IOError is caught by
the most recent handler established by catch. These handlers are
not selective: all IOErrors are caught. Exception propagation
must be explicitly provided in a handler by re-raising any unwanted
exceptions. For example, in
f = catch g (\e -> if IO.isEOFError e then return [] else ioError e)
the function f returns [] when an end-of-file exception
(cf. isEOFError) occurs in g; otherwise, the
exception is propagated to the next outer handler.
When an exception propagates outside the main program, the Haskell
system prints the associated IOError value and exits the program.
Non-I/O exceptions are not caught by this variant; to catch all
exceptions, use Control.Exception.catch from Control.Exception.
|
|
|
The interact function takes a function of type String->String
as its argument. The entire input from the standard input device is
passed to this function as its argument, and the resulting string is
output on the standard output device.
|
|
|
Write a character to the standard output device
(same as hPutChar stdout).
|
|
|
Write a string to the standard output device
(same as hPutStr stdout).
|
|
|
The same as putStr, but adds a newline character.
|
|
|
The print function outputs a value of any printable type to the
standard output device.
Printable types are those that are instances of class Show; print
converts values to strings for output using the show operation and
adds a newline.
For example, a program to print the first 20 integers and their
powers of 2 could be written as:
main = print ([(n, 2^n) | n <- [0..19]])
|
|
|
Read a character from the standard input device
(same as hGetChar stdin).
|
|
|
Read a line from the standard input device
(same as hGetLine stdin).
|
|
|
The getContents operation returns all user input as a single string,
which is read lazily as it is needed
(same as hGetContents stdin).
|
|
|
The readFile function reads a file and
returns the contents of the file as a string.
The file is read lazily, on demand, as with getContents.
|
|
|
The computation writeFile file str function writes the string str,
to the file file.
|
|
|
The computation appendFile file str function appends the string str,
to the file file.
Note that writeFile and appendFile write a literal string
to a file. To write a value of any printable type, as with print,
use the show function to convert the value to a string first.
main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])
|
|
|
The readIO function is similar to read except that it signals
parse failure to the IO monad instead of terminating the program.
|
|
|
The readLn function combines getLine and readIO.
|
|
Produced by Haddock version 2.6.0 |