data IO a :: * -> *
base Prelude, base System.IO
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.
module System.IO
base System.IO
The standard IO library.
module Data.Array.IO
array Data.Array.IO
Mutable boxed and unboxed arrays in the IO monad.
module Data.Text.IO
text Data.Text.IO
Efficient locale-sensitive support for text I/O. Skip past the synopsis for some important notes on performance and portability across different versions of GHC.
module Data.Text.Lazy.IO
text Data.Text.Lazy.IO
Efficient locale-sensitive support for lazy text I/O. Skip past the synopsis for some important notes on performance and portability across different versions of GHC.
module GHC.Conc.IO
base GHC.Conc.IO
Basic concurrency stuff.
module System.Posix.IO
unix System.Posix.IO
POSIX IO support. These types and functions correspond to the unix functions open(2), close(2), etc. For more portable functions which are more like fopen(3) and friends from stdio.h, see System.IO.
type IOError = IOException
base Prelude, base System.IO.Error
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.
module Data.IORef
base Data.IORef
Mutable references in the IO monad.
type IOCallback = FdKey -> Event -> IO ()
base System.Event
Callback invoked on I/O events.
data IOErrorType
base System.IO.Error
An abstract type that contains a value for each variant of IOError.
IOException :: IOException -> Exception
base Control.OldException
These are the standard IO exceptions generated by Haskell's IO operations. See also System.IO.Error.
data IOException
base Control.Exception.Base, base Control.Exception, base Control.OldException
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.
data IOMode
base System.IO
See System.IO.openFile
data IORef a
base Data.IORef
A mutable variable in the IO monad
module Data.Graph.Inductive.Monad.IOArray
fgl Data.Graph.Inductive.Monad.IOArray
Static IOArray-based Graphs
data IOArray i e :: * -> * -> *
array Data.Array.IO, array Data.Array.IO.Safe
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.
class IODevice a
base GHC.IO.Device
I/O operations required for implementing a Handle.
data IODeviceType
base GHC.IO.Device
Type of a device that can be used to back a GHC.IO.Handle.Handle (see also GHC.IO.Handle.mkFileHandle). The standard libraries provide creation of GHC.IO.Handle.Handles via Posix file operations with file descriptors (see GHC.IO.Handle.FD.mkHandleFromFD) with FD being the underlying IODevice instance. Users may provide custom instances of IODevice which are expected to conform the following rules:
package IOR
IOR monad is a wrapper around IO that allows region based resource management. Version 0.1
package IORefCAS
After GHC 7.2 a new `casMutVar#` primop became available, but was not yet exposed in Data.IORef.  This package fills that gap until such a time as Data.IORef obsoletes it. Further, in addition to exposing native Haskell CAS operations, this package contains "mockups" that imititate the same functionality using either atomicModifyIORef and unsafe pointer equality (in Data.CAS.Fake) or using foreign functions (Data.CAS.Foreign). These alternatives are useful for debugging. Note that the foreign option does not operate on IORefs and so is directly interchangeable with `Data.CAS` and `Data.CAS.Fake` only if the interface in `Data.CAS.Class` is used. Version
IORose :: (IO (Rose a)) -> Rose a
QuickCheck Test.QuickCheck.Property
package IOSpec
This package consists of several modules, that give a pure specification of functions in the IO monad: * Test.IOSpec.Fork: a pure specification of forkIO. * Test.IOSpec.IORef: a pure specification of most functions that create and manipulate on IORefs. * Test.IOSpec.MVar: a pure specification of most functions that create and manipulate and MVars. * Test.IOSpec.STM: a pure specification of atomically and the STM monad. * Test.IOSpec.Teletype: a pure specification of getChar, putChar, and several related Prelude functions. Besides these modules containing the specifications, there are a few other important modules: * Test.IOSpec.Types: defines the IOSpec type and several amenities. * Test.IOSpec.VirtualMachine: defines a virtual machine on which to execute pure specifications. * Test.IOSpec.Surrogate: a drop-in replacement for the other modules. Import this and recompile your code once you've finished testing and debugging. There are several well-documented examples included with the source distribution. Version 0.2.5
data IOUArray i e
array Data.Array.IO, array Data.Array.IO.Safe
Mutable, unboxed, strict arrays 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. Only certain element types are supported: see Data.Array.MArray for a list of instances.
ioError :: IOError -> IO a
base Prelude, base Control.Exception.Base, base Control.Exception, base System.IO.Error, base Control.OldException
Raise an IOError in the IO monad.
ioeGetErrorString :: IOError -> String
base System.IO.Error
ioeGetErrorType :: IOError -> IOErrorType
base System.IO.Error
ioeGetFileName :: IOError -> Maybe FilePath
base System.IO.Error
ioeGetHandle :: IOError -> Maybe Handle
base System.IO.Error
ioeGetLocation :: IOError -> String
base System.IO.Error
ioErrors :: Exception -> Maybe IOError
base Control.OldException
ioeSetErrorString :: IOError -> String -> IOError
base System.IO.Error
ioeSetErrorType :: IOError -> IOErrorType -> IOError
base System.IO.Error
ioeSetFileName :: IOError -> FilePath -> IOError
base System.IO.Error
ioeSetHandle :: IOError -> Handle -> IOError
base System.IO.Error
ioeSetLocation :: IOError -> String -> IOError
base System.IO.Error
package io-capture
capture IO action's stdout and stderr Version 0.3
package io-choice
Choice for IO and lifted IO Version 0.0.5
package io-manager
A skeleton library to help learners of Haskell concentrate on the pure-functional aspect and let the IO be handled by the library. Version
package io-memoize
Transform an IO action into a similar IO action that performs the original action only once. You can choose to perform the original action in one of three ways: * lazily (might never be performed) * eagerly * concurrently (eager) Special thanks to shachaf and headprogrammingczar from #haskell irc for helping me reason about the behavior of this library. Version

Show more results