Monad m => Functor (Concurrently m)	Since: unliftio-0.1.0.0
Instance details Defined in UnliftIO.Async Methods fmap :: (a -> b) -> Concurrently m a -> Concurrently m b # (<$) :: a -> Concurrently m b -> Concurrently m a #
MonadUnliftIO m => Applicative (Concurrently m)	Since: unliftio-0.1.0.0
Instance details Defined in UnliftIO.Async Methods pure :: a -> Concurrently m a # (<>) :: Concurrently m (a -> b) -> Concurrently m a -> Concurrently m b # liftA2 :: (a -> b -> c) -> Concurrently m a -> Concurrently m b -> Concurrently m c # (>) :: Concurrently m a -> Concurrently m b -> Concurrently m b # (<*) :: Concurrently m a -> Concurrently m b -> Concurrently m a #
MonadUnliftIO m => Alternative (Concurrently m)	Since: unliftio-0.1.0.0
Instance details Defined in UnliftIO.Async Methods empty :: Concurrently m a # (<\|>) :: Concurrently m a -> Concurrently m a -> Concurrently m a # some :: Concurrently m a -> Concurrently m [a] # many :: Concurrently m a -> Concurrently m [a] #
(MonadUnliftIO m, Semigroup a) => Semigroup (Concurrently m a)	Only defined by `async` for `base >= 4.9`. Since: unliftio-0.1.0.0
Instance details Defined in UnliftIO.Async Methods (<>) :: Concurrently m a -> Concurrently m a -> Concurrently m a # sconcat :: NonEmpty (Concurrently m a) -> Concurrently m a # stimes :: Integral b => b -> Concurrently m a -> Concurrently m a #
(Semigroup a, Monoid a, MonadUnliftIO m) => Monoid (Concurrently m a)	Since: unliftio-0.1.0.0
Instance details Defined in UnliftIO.Async Methods mempty :: Concurrently m a # mappend :: Concurrently m a -> Concurrently m a -> Concurrently m a # mconcat :: [Concurrently m a] -> Concurrently m a #

Low-level concurrency using `async`

data Async a #

An asynchronous action spawned by async or withAsync. Asynchronous actions are executed in a separate thread, and operations are provided for waiting for asynchronous actions to complete and obtaining their results (see e.g. wait).

Instances

Functor Async
Instance details Defined in Control.Concurrent.Async Methods fmap :: (a -> b) -> Async a -> Async b # (<$) :: a -> Async b -> Async a #
Eq (Async a)
Instance details Defined in Control.Concurrent.Async Methods (==) :: Async a -> Async a -> Bool # (/=) :: Async a -> Async a -> Bool #
Ord (Async a)
Instance details Defined in Control.Concurrent.Async Methods compare :: Async a -> Async a -> Ordering # (<) :: Async a -> Async a -> Bool # (<=) :: Async a -> Async a -> Bool # (>) :: Async a -> Async a -> Bool # (>=) :: Async a -> Async a -> Bool # max :: Async a -> Async a -> Async a # min :: Async a -> Async a -> Async a #
Hashable (Async a)
Instance details Defined in Control.Concurrent.Async Methods hashWithSalt :: Int -> Async a -> Int # hash :: Async a -> Int #

async :: MonadUnliftIO m => m a -> m (Async a) #

Unlifted async.

Since: unliftio-0.1.0.0

asyncBound :: MonadUnliftIO m => m a -> m (Async a) #

Unlifted asyncBound.

Since: unliftio-0.1.0.0

asyncOn :: MonadUnliftIO m => Int -> m a -> m (Async a) #

Unlifted asyncOn.

Since: unliftio-0.1.0.0

asyncWithUnmask :: MonadUnliftIO m => ((forall b. m b -> m b) -> m a) -> m (Async a) #

Unlifted asyncWithUnmask.

Since: unliftio-0.1.0.0

asyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall b. m b -> m b) -> m a) -> m (Async a) #

Unlifted asyncOnWithUnmask.

Since: unliftio-0.1.0.0

cancel :: MonadIO m => Async a -> m () #

Lifted cancel.

Since: unliftio-0.1.0.0

uninterruptibleCancel :: MonadIO m => Async a -> m () #

Lifted uninterruptibleCancel.

Since: unliftio-0.1.0.0

cancelWith :: (Exception e, MonadIO m) => Async a -> e -> m () #

Lifted cancelWith. Additionally uses toAsyncException to ensure async exception safety.

Since: unliftio-0.1.0.0

withAsync :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b #

Unlifted withAsync.

Since: unliftio-0.1.0.0

withAsyncBound :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b #

Unlifted withAsyncBound.

Since: unliftio-0.1.0.0

withAsyncOn :: MonadUnliftIO m => Int -> m a -> (Async a -> m b) -> m b #

Unlifted withAsyncOn.

Since: unliftio-0.1.0.0

withAsyncWithUnmask :: MonadUnliftIO m => ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b #

Unlifted withAsyncWithUnmask.

Since: unliftio-0.1.0.0

withAsyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b #

Unlifted withAsyncOnWithMask.

Since: unliftio-0.1.0.0

wait :: MonadIO m => Async a -> m a #

Lifted wait.

Since: unliftio-0.1.0.0

waitSTM :: Async a -> STM a #

A version of wait that can be used inside an STM transaction.

waitCatch :: MonadIO m => Async a -> m (Either SomeException a) #

Lifted waitCatch.

Since: unliftio-0.1.0.0

waitCatchSTM :: Async a -> STM (Either SomeException a) #

A version of waitCatch that can be used inside an STM transaction.

waitAny :: MonadIO m => [Async a] -> m (Async a, a) #

Lifted waitAny.

Since: unliftio-0.1.0.0

waitAnySTM :: [Async a] -> STM (Async a, a) #

A version of waitAny that can be used inside an STM transaction.

Since: async-2.1.0

waitAnyCatch :: MonadIO m => [Async a] -> m (Async a, Either SomeException a) #

Lifted waitAnyCatch.

Since: unliftio-0.1.0.0

waitAnyCatchSTM :: [Async a] -> STM (Async a, Either SomeException a) #

A version of waitAnyCatch that can be used inside an STM transaction.

Since: async-2.1.0

waitAnyCancel :: MonadIO m => [Async a] -> m (Async a, a) #

Lifted waitAnyCancel.

Since: unliftio-0.1.0.0

waitAnyCatchCancel :: MonadIO m => [Async a] -> m (Async a, Either SomeException a) #

Lifted waitAnyCatchCancel.

Since: unliftio-0.1.0.0

waitEither :: MonadIO m => Async a -> Async b -> m (Either a b) #

Lifted waitEither.

Since: unliftio-0.1.0.0

waitEitherSTM :: Async a -> Async b -> STM (Either a b) #

A version of waitEither that can be used inside an STM transaction.

Since: async-2.1.0

waitEither_ :: MonadIO m => Async a -> Async b -> m () #

Lifted waitEither_.

Since: unliftio-0.1.0.0

waitEitherSTM_ :: Async a -> Async b -> STM () #

A version of waitEither_ that can be used inside an STM transaction.

Since: async-2.1.0

waitEitherCatch :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b)) #

Lifted waitEitherCatch.

Since: unliftio-0.1.0.0

waitEitherCatchSTM :: Async a -> Async b -> STM (Either (Either SomeException a) (Either SomeException b)) #

A version of waitEitherCatch that can be used inside an STM transaction.

Since: async-2.1.0

waitEitherCancel :: MonadIO m => Async a -> Async b -> m (Either a b) #

Lifted waitEitherCancel.

Since: unliftio-0.1.0.0

waitEitherCatchCancel :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b)) #

Lifted waitEitherCatchCancel.

Since: unliftio-0.1.0.0

waitBoth :: MonadIO m => Async a -> Async b -> m (a, b) #

Lifted waitBoth.

Since: unliftio-0.1.0.0

waitBothSTM :: Async a -> Async b -> STM (a, b) #

A version of waitBoth that can be used inside an STM transaction.

Since: async-2.1.0

poll :: MonadIO m => Async a -> m (Maybe (Either SomeException a)) #

Lifted poll.

Since: unliftio-0.1.0.0

pollSTM :: Async a -> STM (Maybe (Either SomeException a)) #

A version of poll that can be used inside an STM transaction.

link :: MonadIO m => Async a -> m () #

Lifted link.

Since: unliftio-0.1.0.0

link2 :: MonadIO m => Async a -> Async b -> m () #

Lifted link2.

Since: unliftio-0.1.0.0

asyncThreadId :: Async a -> ThreadId #

Returns the ThreadId of the thread running the given Async.

compareAsyncs :: Async a -> Async b -> Ordering #

Compare two Asyncs that may have different types

data ExceptionInLinkedThread where #

Constructors

ExceptionInLinkedThread :: ExceptionInLinkedThread

Instances

Show ExceptionInLinkedThread
Instance details Defined in Control.Concurrent.Async Methods showsPrec :: Int -> ExceptionInLinkedThread -> ShowS # show :: ExceptionInLinkedThread -> String # showList :: [ExceptionInLinkedThread] -> ShowS #
Exception ExceptionInLinkedThread
Instance details Defined in Control.Concurrent.Async Methods toException :: ExceptionInLinkedThread -> SomeException # fromException :: SomeException -> Maybe ExceptionInLinkedThread # displayException :: ExceptionInLinkedThread -> String #

data AsyncCancelled #

The exception thrown by cancel to terminate a thread.

Constructors

AsyncCancelled

Instances

Eq AsyncCancelled
Instance details Defined in Control.Concurrent.Async Methods (==) :: AsyncCancelled -> AsyncCancelled -> Bool # (/=) :: AsyncCancelled -> AsyncCancelled -> Bool #
Show AsyncCancelled
Instance details Defined in Control.Concurrent.Async Methods showsPrec :: Int -> AsyncCancelled -> ShowS # show :: AsyncCancelled -> String # showList :: [AsyncCancelled] -> ShowS #
Exception AsyncCancelled
Instance details Defined in Control.Concurrent.Async Methods toException :: AsyncCancelled -> SomeException # fromException :: SomeException -> Maybe AsyncCancelled # displayException :: AsyncCancelled -> String #

Lower-level concurrency using `forkIO`

forkIO :: MonadUnliftIO m => m () -> m ThreadId #

Unlifted version of forkIO.

Since: unliftio-0.1.1.0

forkWithUnmask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m ()) -> m ThreadId #

Unlifted version of forkIOWithUnmask.

Since: unliftio-0.1.1.0

forkOn :: MonadUnliftIO m => Int -> m () -> m ThreadId #

Unlifted version of forkOn.

Since: unliftio-0.1.1.0

forkOnWithUnmask :: MonadUnliftIO m => Int -> ((forall a. m a -> m a) -> m ()) -> m ThreadId #

Unlifted version of forkOnWithUnmask.

Since: unliftio-0.1.1.0

forkFinally :: MonadUnliftIO m => m a -> (Either SomeException a -> m ()) -> m ThreadId #

Unlifted version of forkFinally.

Since: unliftio-0.1.1.0

throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m () #

Throw an asynchronous exception to another thread.

Synchronously typed exceptions will be wrapped into an AsyncExceptionWrapper, see https://github.com/fpco/safe-exceptions#determining-sync-vs-async.

It's usually a better idea to use the UnliftIO.Async module, see https://github.com/fpco/safe-exceptions#quickstart.

Since: unliftio-0.1.0.0

killThread :: MonadIO m => ThreadId -> m () #

Lifted version of killThread.

Since: unliftio-0.1.1.0

STM

data STM a #

A monad supporting atomic memory transactions.

Instances

Monad STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a # fail :: String -> STM a #
Functor STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Applicative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods pure :: a -> STM a # (<>) :: STM (a -> b) -> STM a -> STM b # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c # (>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a # (<\|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
MonadPlus STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
Compactable STM
Instance details Defined in Control.Compactable Methods compact :: STM (Maybe a) -> STM a # separate :: STM (Either l r) -> (STM l, STM r) # filter :: (a -> Bool) -> STM a -> STM a # partition :: (a -> Bool) -> STM a -> (STM a, STM a) # fmapMaybe :: Functor STM => (a -> Maybe b) -> STM a -> STM b # fmapEither :: Functor STM => (a -> Either l r) -> STM a -> (STM l, STM r) # applyMaybe :: Applicative STM => STM (a -> Maybe b) -> STM a -> STM b # applyEither :: Applicative STM => STM (a -> Either l r) -> STM a -> (STM l, STM r) # bindMaybe :: Monad STM => STM a -> (a -> STM (Maybe b)) -> STM b # bindEither :: Monad STM => STM a -> (a -> STM (Either l r)) -> (STM l, STM r) # traverseMaybe :: (Applicative g, Traversable STM) => (a -> g (Maybe b)) -> STM a -> g (STM b) # traverseEither :: (Applicative g, Traversable STM) => (a -> g (Either l r)) -> STM a -> g (STM l, STM r) #
CompactFold STM
Instance details Defined in Control.Compactable Methods compactFold :: Foldable g => STM (g a) -> STM a # separateFold :: Bifoldable g => STM (g a b) -> (STM a, STM b) # fmapFold :: (Functor STM, Foldable g) => (a -> g b) -> STM a -> STM b # fmapBifold :: (Functor STM, Bifoldable g) => (a -> g l r) -> STM a -> (STM l, STM r) # applyFold :: (Applicative STM, Foldable g) => STM (a -> g b) -> STM a -> STM b # applyBifold :: (Applicative STM, Bifoldable g) => STM (a -> g l r) -> STM a -> (STM l, STM r) # bindFold :: (Monad STM, Foldable g) => STM a -> (a -> STM (g b)) -> STM b # bindBifold :: (Monad STM, Bifoldable g) => STM a -> (a -> STM (g l r)) -> (STM l, STM r) # traverseFold :: (Applicative h, Foldable g, Traversable STM) => (a -> h (g b)) -> STM a -> h (STM b) # traverseBifold :: (Applicative h, Bifoldable g, Traversable STM) => (a -> h (g l r)) -> STM a -> h (STM l, STM r) #
MonadThrow STM
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> STM a #
MonadCatch STM
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => STM a -> (e -> STM a) -> STM a #
Pointed STM
Instance details Defined in Data.Pointed Methods point :: a -> STM a #
MonadBase STM STM
Instance details Defined in Control.Monad.Base Methods liftBase :: STM α -> STM α #

atomically :: MonadIO m => STM a -> m a #

Lifted version of atomically

Since: unliftio-0.2.1.0

retry :: STM a #

Retry execution of the current memory transaction because it has seen values in TVars which mean that it should not continue (e.g. the TVars represent a shared buffer that is now empty). The implementation may block the thread until one of the TVars that it has read from has been updated. (GHC only)

throwSTM :: Exception e => e -> STM a #

A variant of throw that can only be used within the STM monad.

Throwing an exception in STM aborts the transaction and propagates the exception.

Although throwSTM has a type that is an instance of the type of throw, the two functions are subtly different:

throw e    `seq` x  ===> throw e
throwSTM e `seq` x  ===> x

The first example will cause the exception e to be raised, whereas the second one won't. In fact, throwSTM will only cause an exception to be raised when it is used within the STM monad. The throwSTM variant should be used in preference to throw to raise an exception within the STM monad because it guarantees ordering with respect to other STM operations, whereas throw does not.

catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a #

Exception handling within STM actions.

unsafeIOToSTM :: IO a -> STM a #

Unsafely performs IO in the STM monad. Beware: this is a highly dangerous thing to do.

The STM implementation will often run transactions multiple times, so you need to be prepared for this if your IO has any side effects.
The STM implementation will abort transactions that are known to be invalid and need to be restarted. This may happen in the middle of unsafeIOToSTM, so make sure you don't acquire any resources that need releasing (exception handlers are ignored when aborting the transaction). That includes doing any IO using Handles, for example. Getting this wrong will probably lead to random deadlocks.
The transaction may have seen an inconsistent view of memory when the IO runs. Invariants that you expect to be true throughout your program may not be true inside a transaction, due to the way transactions are implemented. Normally this wouldn't be visible to the programmer, but using unsafeIOToSTM can expose it.

Delay

threadDelay :: MonadIO m => Int -> m () #

Lifted version of threadDelay.

Since: unliftio-0.1.1.0

registerDelay :: MonadIO m => Int -> m (TVar Bool) #

Lifted version of registerDelay

Since: unliftio-0.2.1.0

Cooperative concurrency

yield :: MonadIO m => m () #

Lifted version of yield.

Since: unliftio-0.1.1.0

Thread info

data ThreadId #

A ThreadId is an abstract type representing a handle to a thread. ThreadId is an instance of Eq, Ord and Show, where the Ord instance implements an arbitrary total ordering over ThreadIds. The Show instance lets you convert an arbitrary-valued ThreadId to string form; showing a ThreadId value is occasionally useful when debugging or diagnosing the behaviour of a concurrent program.

Note: in GHC, if you have a ThreadId, you essentially have a pointer to the thread itself. This means the thread itself can't be garbage collected until you drop the ThreadId. This misfeature will hopefully be corrected at a later date.

Instances

Eq ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Ord ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadId -> ThreadId -> Ordering # (<) :: ThreadId -> ThreadId -> Bool # (<=) :: ThreadId -> ThreadId -> Bool # (>) :: ThreadId -> ThreadId -> Bool # (>=) :: ThreadId -> ThreadId -> Bool # max :: ThreadId -> ThreadId -> ThreadId # min :: ThreadId -> ThreadId -> ThreadId #
Show ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadId -> ShowS # show :: ThreadId -> String # showList :: [ThreadId] -> ShowS #
Hashable ThreadId
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
NFData ThreadId	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ThreadId -> () #
PrimUnlifted ThreadId	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.UnliftedArray Methods toArrayArray# :: ThreadId -> ArrayArray# # fromArrayArray# :: ArrayArray# -> ThreadId #

myThreadId :: MonadIO m => m ThreadId #

Lifted version of myThreadId.

Since: unliftio-0.1.1.0

mkWeakThreadId :: MonadIO m => ThreadId -> m (Weak ThreadId) #

Lifted version of mkWeakThreadId.

Since: unliftio-0.1.1.0

data ThreadStatus #

The current status of a thread

Constructors

ThreadRunning	the thread is currently runnable or running
ThreadFinished	the thread has finished
ThreadBlocked BlockReason	the thread is blocked on some resource
ThreadDied	the thread received an uncaught exception

Instances

Eq ThreadStatus
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadStatus -> ThreadStatus -> Bool # (/=) :: ThreadStatus -> ThreadStatus -> Bool #
Ord ThreadStatus
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadStatus -> ThreadStatus -> Ordering # (<) :: ThreadStatus -> ThreadStatus -> Bool # (<=) :: ThreadStatus -> ThreadStatus -> Bool # (>) :: ThreadStatus -> ThreadStatus -> Bool # (>=) :: ThreadStatus -> ThreadStatus -> Bool # max :: ThreadStatus -> ThreadStatus -> ThreadStatus # min :: ThreadStatus -> ThreadStatus -> ThreadStatus #
Show ThreadStatus
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadStatus -> ShowS # show :: ThreadStatus -> String # showList :: [ThreadStatus] -> ShowS #

data BlockReason #

Constructors

BlockedOnMVar	blocked on `MVar`
BlockedOnBlackHole	blocked on a computation in progress by another thread
BlockedOnException	blocked in `throwTo`
BlockedOnSTM	blocked in `retry` in an STM transaction
BlockedOnForeignCall	currently in a foreign call
BlockedOnOther	blocked on some other resource. Without `-threaded`, I/O and `threadDelay` show up as `BlockedOnOther`, with `-threaded` they show up as `BlockedOnMVar`.

Instances

Eq BlockReason
Instance details Defined in GHC.Conc.Sync Methods (==) :: BlockReason -> BlockReason -> Bool # (/=) :: BlockReason -> BlockReason -> Bool #
Ord BlockReason
Instance details Defined in GHC.Conc.Sync Methods compare :: BlockReason -> BlockReason -> Ordering # (<) :: BlockReason -> BlockReason -> Bool # (<=) :: BlockReason -> BlockReason -> Bool # (>) :: BlockReason -> BlockReason -> Bool # (>=) :: BlockReason -> BlockReason -> Bool # max :: BlockReason -> BlockReason -> BlockReason # min :: BlockReason -> BlockReason -> BlockReason #
Show BlockReason
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> BlockReason -> ShowS # show :: BlockReason -> String # showList :: [BlockReason] -> ShowS #

threadStatus :: ThreadId -> IO ThreadStatus #

threadCapability :: MonadIO m => ThreadId -> m (Int, Bool) #

Lifted version of threadCapability.

Since: unliftio-0.1.1.0

labelThread :: ThreadId -> String -> IO () #

labelThread stores a string as identifier for this thread if you built a RTS with debugging support. This identifier will be used in the debugging output to make distinction of different threads easier (otherwise you only have the thread state object's address in the heap).

Other applications like the graphical Concurrent Haskell Debugger (http://www.informatik.uni-kiel.de/~fhu/chd/) may choose to overload labelThread for their purposes as well.

File descriptor blocking

threadWaitRead :: MonadIO m => Fd -> m () #

Lifted version of threadWaitRead.

Since: unliftio-0.1.1.0

threadWaitReadSTM :: Fd -> IO (STM (), IO ()) #

Returns an STM action that can be used to wait for data to read from a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.

threadWaitWrite :: MonadIO m => Fd -> m () #

Lifted version of threadWaitWrite.

Since: unliftio-0.1.1.0

threadWaitWriteSTM :: Fd -> IO (STM (), IO ()) #

Returns an STM action that can be used to wait until data can be written to a file descriptor. The second returned value is an IO action that can be used to deregister interest in the file descriptor.

closeFdWith #

Arguments

:: (Fd -> IO ())	Low-level action that performs the real close.
-> Fd	File descriptor to close.
-> IO ()

Close a file descriptor in a concurrency-safe way (GHC only). If you are using threadWaitRead or threadWaitWrite to perform blocking I/O, you must use this function to close file descriptors, or blocked threads may not be woken.

Any threads that are blocked on the file descriptor via threadWaitRead or threadWaitWrite will be unblocked by having IO exceptions thrown.