| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
IO
Contents
Synopsis
- data IO a
- class Monad m => MonadIO (m :: * -> *) where
- fixIO :: (a -> IO a) -> IO a
- timeout :: MonadUnliftIO m => Int -> m a -> m (Maybe a)
- once :: IO a -> IO (IO a)
- onceFork :: IO a -> IO (IO a)
- data Memoized a
- runMemoized :: MonadIO m => Memoized a -> m a
- memoizeMVar :: MonadUnliftIO m => m a -> m (Memoized a)
- module System.IO.Error
IO
A value of type IO aa.
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.
Instances
class Monad m => MonadIO (m :: * -> *) where #
Monads in which IO computations may be embedded.
Any monad built by applying a sequence of monad transformers to the
IO monad will be an instance of this class.
Instances should satisfy the following laws, which state that liftIO
is a transformer of monads:
Minimal complete definition
Instances
fixIO :: (a -> IO a) -> IO a #
The implementation of mfix for IO. If the function passed
to fixIO inspects its argument, the resulting action will throw
FixIOException.
Given an action, produce a wrapped action that runs at most once. If the function raises an exception, the same exception will be reraised each time.
let x ||| y = do t1 <- onceFork x; t2 <- onceFork y; t1; t2 \(x :: IO Int) -> void (once x) == return () \(x :: IO Int) -> join (once x) == x \(x :: IO Int) -> (do y <- once x; y; y) == x \(x :: IO Int) -> (do y <- once x; y ||| y) == x
onceFork :: IO a -> IO (IO a) #
Like once, but immediately starts running the computation on a background thread.
\(x :: IO Int) -> join (onceFork x) == x \(x :: IO Int) -> (do a <- onceFork x; a; a) == x
Memoized IO
A "run once" value, with results saved. Extract the value with
runMemoized. For single-threaded usage, you can use memoizeRef to
create a value. If you need guarantees that only one thread will run the
action at a time, use memoizeMVar.
Note that this type provides a Show instance for convenience, but not
useful information can be provided.
Since: unliftio-0.2.8.0
runMemoized :: MonadIO m => Memoized a -> m a #
Extract a value from a Memoized, running an action if no cached value is
available.
Since: unliftio-0.2.8.0
memoizeMVar :: MonadUnliftIO m => m a -> m (Memoized a) #
Same as memoizeRef, but uses an MVar to ensure that an action is
only run once, even in a multithreaded application.
Since: unliftio-0.2.8.0
IO exceptions
module System.IO.Error