IO package:base

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.

The standard IO API.

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.

Basic concurrency stuff. The API of this module is unstable and not meant to be consumed by the general public. If you absolutely must depend on it, make sure to use a tight upper bound, e.g., base < 4.X rather than base < 5, because the interface can change rapidly without much warning.

Definitions for the IO monad and its friends. The API of this module is unstable and not meant to be consumed by the general public. If you absolutely must depend on it, make sure to use a tight upper bound, e.g., base < 4.X rather than base < 5, because the interface can change rapidly without much warning.

The Haskell 2010 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 Exception. In Haskell 2010, this is an opaque type.

Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Monoid under bitwise inclusive OR.

>>> getIor (Ior 0xab <> Ior 0x12) :: Word8
187

Mutable references in the IO monad.

A mutable variable in the IO monad.

>>> import GHC.Internal.Data.IORef

>>> r <- newIORef 0

>>> readIORef r
0

>>> writeIORef r 1

>>> readIORef r
1

>>> atomicWriteIORef r 2

>>> readIORef r
2

>>> modifyIORef' r (+ 1)

>>> readIORef r
3

>>> atomicModifyIORef' r (\a -> (a + 1, ()))

>>> readIORef r
4

See also STRef and MVar.

See openFile

An abstract type that contains a value for each variant of IOError.

A shared I/O port is almost the same as an MVar#. The main difference is that IOPort has no deadlock detection or deadlock breaking code that forcibly releases the lock.

Callback invoked on I/O events.

I/O operations required for implementing a Handle.

Type of a device that can be used to back a Handle (see also mkFileHandle). The standard libraries provide creation of Handles via Posix file operations with file descriptors (see mkHandleFromFD) with FD being the underlying IODevice instance. Users may provide custom instances of IODevice which are expected to conform the following rules:

The IOMode type

Use platform native Sub-System. For unix OSes this is the same as IoPOSIX, but on Windows this means use the Windows native APIs for I/O, including IOCP and RIO.

Use a POSIX I/O Sub-System

The I/O SubSystem to use in the program.

The IOArray type

An IOArray is a mutable, boxed, non-strict array in the IO monad. The type arguments are as follows:

• i: the index type of the array (should be an instance of Ix)
• e: the element type of the array.