GHC.IO

| Haskell Hierarchical Libraries (base package) | Contents | Index
GHC.IO |
Portability | non-portable
Stability | internal
Maintainer | libraries@haskell.org
Description
String I/O functions
Synopsis
hWaitForInput :: Handle -> Int -> IO Bool
hGetChar :: Handle -> IO Char
hGetLine :: Handle -> IO String
hGetContents :: Handle -> IO String
hPutChar :: Handle -> Char -> IO ()
hPutStr :: Handle -> String -> IO ()
hGetBuf :: Handle -> Ptr a -> Int -> IO Int
hGetBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
hPutBuf :: Handle -> Ptr a -> Int -> IO ()
hPutBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
slurpFile :: FilePath -> IO (Ptr (), Int)
memcpy_ba_baoff :: RawBuffer -> RawBuffer -> Int -> CSize -> IO (Ptr ())
memcpy_ptr_baoff :: Ptr a -> RawBuffer -> Int -> CSize -> IO (Ptr ())
memcpy_baoff_ba :: RawBuffer -> Int -> RawBuffer -> CSize -> IO (Ptr ())
memcpy_baoff_ptr :: RawBuffer -> Int -> Ptr a -> CSize -> IO (Ptr ())
Documentation
hWaitForInput :: Handle -> Int -> IO Bool
Computation `hWaitForInput` `hdl t` 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. If `t` is less than zero, then `hWaitForInput` waits indefinitely. NOTE: in the current implementation, this is the only case that works correctly (if `t` is non-zero, then all other concurrent threads are blocked until data is available). This operation may fail with: `isEOFError` if the end of file has been reached.
hGetChar :: Handle -> IO Char
Computation `hGetChar` `hdl` reads a character from the file or channel managed by `hdl`, blocking until a character is available. This operation may fail with: `isEOFError` if the end of file has been reached.
hGetLine :: Handle -> IO String
Computation `hGetLine` `hdl` reads a line from the file or channel managed by `hdl`. This operation may fail with: `isEOFError` if the end of file is encountered when reading the 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.
hGetContents :: Handle -> IO String
Computation `hGetContents` `hdl` returns the list of characters corresponding to the unread portion of the channel or file managed by `hdl`, which is put into an intermediate state, 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: if `hClose` is applied to it; if an I/O error occurs when reading an item from the handle; or once the entire contents of the handle has been read. 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. This operation may fail with: `isEOFError` if the end of file has been reached.
hPutChar :: Handle -> Char -> IO ()
Computation `hPutChar` `hdl ch` writes the character `ch` to the file or channel managed by `hdl`. Characters may be buffered if buffering is enabled for `hdl`. This operation may fail with: `isFullError` if the device is full; or `isPermissionError` if another system resource limit would be exceeded.
hPutStr :: Handle -> String -> IO ()
Computation `hPutStr` `hdl s` writes the string `s` to the file or channel managed by `hdl`. This operation may fail with: `isFullError` if the device is full; or `isPermissionError` if another system resource limit would be exceeded.
hGetBuf :: Handle -> Ptr a -> Int -> IO Int
`hGetBuf` `hdl buf count` reads data from the handle `hdl` into the buffer `buf` until either EOF is reached or `count` 8-bit bytes have been read. It returns the number of bytes actually read. This may be zero if EOF was reached before any data was read (or if `count` is zero). `hGetBuf` never raises an EOF exception, instead it returns a value smaller than `count`. If the handle is a pipe or socket, and the writing end is closed, `hGetBuf` will behave as if EOF was reached.
hGetBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
`hGetBufNonBlocking` `hdl buf count` reads data from the handle `hdl` into the buffer `buf` until either EOF is reached, or `count` 8-bit bytes have been read, or there is no more data available to read immediately. `hGetBufNonBlocking` is identical to `hGetBuf`, except that it will never block waiting for data to become available, instead it returns only whatever data is available. To wait for data to arrive before calling `hGetBufNonBlocking`, use `hWaitForInput`. If the handle is a pipe or socket, and the writing end is closed, `hGetBufNonBlocking` will behave as if EOF was reached.
hPutBuf :: Handle -> Ptr a -> Int -> IO ()
`hPutBuf` `hdl buf count` writes `count` 8-bit bytes from the buffer `buf` to the handle `hdl`. It returns (). This operation may fail with: `ResourceVanished` if the handle is a pipe or socket, and the reading end is closed. (If this is a POSIX system, and the program has not asked to ignore SIGPIPE, then a SIGPIPE may be delivered instead, whose default action is to terminate the program).
hPutBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
slurpFile :: FilePath -> IO (Ptr (), Int)
memcpy_ba_baoff :: RawBuffer -> RawBuffer -> Int -> CSize -> IO (Ptr ())
memcpy_ptr_baoff :: Ptr a -> RawBuffer -> Int -> CSize -> IO (Ptr ())
memcpy_baoff_ba :: RawBuffer -> Int -> RawBuffer -> CSize -> IO (Ptr ())
memcpy_baoff_ptr :: RawBuffer -> Int -> Ptr a -> CSize -> IO (Ptr ())
Produced by Haddock version 0.6